mozilla-central/__GENERATED__/__RUST_BUILD_SCRIPT__/gtkbind/gtk_bindings.rs

Copy as Markdown

Other Tools

/* automatically generated by rust-bindgen 0.69.4 */
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
Self { storage }
}
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
#[inline]
pub fn get_bit(&self, index: usize) -> bool {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = self.storage.as_ref()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
byte & mask == mask
}
#[inline]
pub fn set_bit(&mut self, index: usize, val: bool) {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = &mut self.storage.as_mut()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
if val {
*byte |= mask;
} else {
*byte &= !mask;
}
}
#[inline]
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
let mut val = 0;
for i in 0..(bit_width as usize) {
if self.get_bit(i + bit_offset) {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
self.set_bit(index + bit_offset, val_bit_is_set);
}
}
}
pub type gint8 = ::std::os::raw::c_schar;
pub type guint8 = ::std::os::raw::c_uchar;
pub type gint16 = ::std::os::raw::c_short;
pub type guint16 = ::std::os::raw::c_ushort;
pub type guint32 = ::std::os::raw::c_uint;
pub type gint64 = ::std::os::raw::c_long;
pub type guint64 = ::std::os::raw::c_ulong;
pub type gssize = ::std::os::raw::c_long;
pub type gsize = ::std::os::raw::c_ulong;
pub type __time_t = ::std::os::raw::c_long;
pub type time_t = __time_t;
pub type gchar = ::std::os::raw::c_char;
pub type gshort = ::std::os::raw::c_short;
pub type glong = ::std::os::raw::c_long;
pub type gint = ::std::os::raw::c_int;
pub type gboolean = gint;
pub type guchar = ::std::os::raw::c_uchar;
pub type gushort = ::std::os::raw::c_ushort;
pub type gulong = ::std::os::raw::c_ulong;
pub type guint = ::std::os::raw::c_uint;
pub type gfloat = f32;
pub type gdouble = f64;
pub type gpointer = *mut ::std::os::raw::c_void;
pub type gconstpointer = *const ::std::os::raw::c_void;
pub type GDestroyNotify = ::std::option::Option<unsafe extern "C" fn(data: gpointer)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GBytes {
_unused: [u8; 0],
}
pub type GBytes = _GBytes;
pub type GArray = _GArray;
pub type GPtrArray = _GPtrArray;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GArray {
pub data: *mut gchar,
pub len: guint,
}
#[test]
fn bindgen_test_layout__GArray() {
const UNINIT: ::std::mem::MaybeUninit<_GArray> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GArray>(),
16usize,
concat!("Size of: ", stringify!(_GArray))
);
assert_eq!(
::std::mem::align_of::<_GArray>(),
8usize,
concat!("Alignment of ", stringify!(_GArray))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GArray),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GArray),
"::",
stringify!(len)
)
);
}
impl Default for _GArray {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GPtrArray {
pub pdata: *mut gpointer,
pub len: guint,
}
#[test]
fn bindgen_test_layout__GPtrArray() {
const UNINIT: ::std::mem::MaybeUninit<_GPtrArray> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GPtrArray>(),
16usize,
concat!("Size of: ", stringify!(_GPtrArray))
);
assert_eq!(
::std::mem::align_of::<_GPtrArray>(),
8usize,
concat!("Alignment of ", stringify!(_GPtrArray))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pdata) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GPtrArray),
"::",
stringify!(pdata)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GPtrArray),
"::",
stringify!(len)
)
);
}
impl Default for _GPtrArray {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type va_list = __builtin_va_list;
pub type GQuark = guint32;
#[doc = " GError:\n @domain: error domain, e.g. #G_FILE_ERROR\n @code: error code, e.g. %G_FILE_ERROR_NOENT\n @message: human-readable informative error message\n\n The `GError` structure contains information about\n an error that has occurred."]
pub type GError = _GError;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GError {
pub domain: GQuark,
pub code: gint,
pub message: *mut gchar,
}
#[test]
fn bindgen_test_layout__GError() {
const UNINIT: ::std::mem::MaybeUninit<_GError> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GError>(),
16usize,
concat!("Size of: ", stringify!(_GError))
);
assert_eq!(
::std::mem::align_of::<_GError>(),
8usize,
concat!("Alignment of ", stringify!(_GError))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).domain) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GError),
"::",
stringify!(domain)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).code) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_GError),
"::",
stringify!(code)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).message) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GError),
"::",
stringify!(message)
)
);
}
impl Default for _GError {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type GMutex = _GMutex;
pub type GCond = _GCond;
#[repr(C)]
#[derive(Copy, Clone)]
pub union _GMutex {
pub p: gpointer,
pub i: [guint; 2usize],
}
#[test]
fn bindgen_test_layout__GMutex() {
const UNINIT: ::std::mem::MaybeUninit<_GMutex> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GMutex>(),
8usize,
concat!("Size of: ", stringify!(_GMutex))
);
assert_eq!(
::std::mem::align_of::<_GMutex>(),
8usize,
concat!("Alignment of ", stringify!(_GMutex))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).p) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GMutex),
"::",
stringify!(p)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GMutex),
"::",
stringify!(i)
)
);
}
impl Default for _GMutex {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GCond {
pub p: gpointer,
pub i: [guint; 2usize],
}
#[test]
fn bindgen_test_layout__GCond() {
const UNINIT: ::std::mem::MaybeUninit<_GCond> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GCond>(),
16usize,
concat!("Size of: ", stringify!(_GCond))
);
assert_eq!(
::std::mem::align_of::<_GCond>(),
8usize,
concat!("Alignment of ", stringify!(_GCond))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).p) as usize - ptr as usize },
0usize,
concat!("Offset of field: ", stringify!(_GCond), "::", stringify!(p))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
8usize,
concat!("Offset of field: ", stringify!(_GCond), "::", stringify!(i))
);
}
impl Default for _GCond {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GData {
_unused: [u8; 0],
}
pub type GData = _GData;
pub type GDuplicateFunc =
::std::option::Option<unsafe extern "C" fn(data: gpointer, user_data: gpointer) -> gpointer>;
pub type GList = _GList;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GList {
pub data: gpointer,
pub next: *mut GList,
pub prev: *mut GList,
}
#[test]
fn bindgen_test_layout__GList() {
const UNINIT: ::std::mem::MaybeUninit<_GList> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GList>(),
24usize,
concat!("Size of: ", stringify!(_GList))
);
assert_eq!(
::std::mem::align_of::<_GList>(),
8usize,
concat!("Alignment of ", stringify!(_GList))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GList),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GList),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GList),
"::",
stringify!(prev)
)
);
}
impl Default for _GList {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GHashTable {
_unused: [u8; 0],
}
pub type GHashTable = _GHashTable;
#[doc = " GPollFD:\n @fd: the file descriptor to poll (or a HANDLE on Win32)\n @events: a bitwise combination from #GIOCondition, specifying which\n events should be polled for. Typically for reading from a file\n descriptor you would use %G_IO_IN | %G_IO_HUP | %G_IO_ERR, and\n for writing you would use %G_IO_OUT | %G_IO_ERR.\n @revents: a bitwise combination of flags from #GIOCondition, returned\n from the poll() function to indicate which events occurred.\n\n Represents a file descriptor, which events to poll for, and which events\n occurred."]
pub type GPollFD = _GPollFD;
#[doc = " GPollFunc:\n @ufds: an array of #GPollFD elements\n @nfsd: the number of elements in @ufds\n @timeout_: the maximum time to wait for an event of the file descriptors.\n A negative value indicates an infinite timeout.\n\n Specifies the type of function passed to g_main_context_set_poll_func().\n The semantics of the function should match those of the poll() system call.\n\n Returns: the number of #GPollFD elements which have events or errors\n reported, or -1 if an error occurred."]
pub type GPollFunc = ::std::option::Option<
unsafe extern "C" fn(ufds: *mut GPollFD, nfsd: guint, timeout_: gint) -> gint,
>;
#[doc = " GPollFD:\n @fd: the file descriptor to poll (or a HANDLE on Win32)\n @events: a bitwise combination from #GIOCondition, specifying which\n events should be polled for. Typically for reading from a file\n descriptor you would use %G_IO_IN | %G_IO_HUP | %G_IO_ERR, and\n for writing you would use %G_IO_OUT | %G_IO_ERR.\n @revents: a bitwise combination of flags from #GIOCondition, returned\n from the poll() function to indicate which events occurred.\n\n Represents a file descriptor, which events to poll for, and which events\n occurred."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _GPollFD {
pub fd: gint,
pub events: gushort,
pub revents: gushort,
}
#[test]
fn bindgen_test_layout__GPollFD() {
const UNINIT: ::std::mem::MaybeUninit<_GPollFD> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GPollFD>(),
8usize,
concat!("Size of: ", stringify!(_GPollFD))
);
assert_eq!(
::std::mem::align_of::<_GPollFD>(),
4usize,
concat!("Alignment of ", stringify!(_GPollFD))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fd) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GPollFD),
"::",
stringify!(fd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).events) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_GPollFD),
"::",
stringify!(events)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).revents) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(_GPollFD),
"::",
stringify!(revents)
)
);
}
pub type GSList = _GSList;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GSList {
pub data: gpointer,
pub next: *mut GSList,
}
#[test]
fn bindgen_test_layout__GSList() {
const UNINIT: ::std::mem::MaybeUninit<_GSList> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GSList>(),
16usize,
concat!("Size of: ", stringify!(_GSList))
);
assert_eq!(
::std::mem::align_of::<_GSList>(),
8usize,
concat!("Alignment of ", stringify!(_GSList))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GSList),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GSList),
"::",
stringify!(next)
)
);
}
impl Default for _GSList {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GMainContext {
_unused: [u8; 0],
}
#[doc = " GMainContext:\n\n The `GMainContext` struct is an opaque data\n type representing a set of sources to be handled in a main loop."]
pub type GMainContext = _GMainContext;
#[doc = " GSource:\n\n The `GSource` struct is an opaque data type\n representing an event source."]
pub type GSource = _GSource;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GSourcePrivate {
_unused: [u8; 0],
}
pub type GSourcePrivate = _GSourcePrivate;
#[doc = " GSourceCallbackFuncs:\n @ref: Called when a reference is added to the callback object\n @unref: Called when a reference to the callback object is dropped\n @get: Called to extract the callback function and data from the\n callback object.\n\n The `GSourceCallbackFuncs` struct contains\n functions for managing callback objects."]
pub type GSourceCallbackFuncs = _GSourceCallbackFuncs;
#[doc = " GSourceFuncs:\n @prepare: Called before all the file descriptors are polled. If the\n source can determine that it is ready here (without waiting for the\n results of the poll() call) it should return %TRUE. It can also return\n a @timeout_ value which should be the maximum timeout (in milliseconds)\n which should be passed to the poll() call. The actual timeout used will\n be -1 if all sources returned -1, or it will be the minimum of all\n the @timeout_ values returned which were >= 0. Since 2.36 this may\n be %NULL, in which case the effect is as if the function always returns\n %FALSE with a timeout of -1. If @prepare returns a\n timeout and the source also has a 'ready time' set then the\n nearer of the two will be used.\n @check: Called after all the file descriptors are polled. The source\n should return %TRUE if it is ready to be dispatched. Note that some\n time may have passed since the previous prepare function was called,\n so the source should be checked again here. Since 2.36 this may\n be %NULL, in which case the effect is as if the function always returns\n %FALSE.\n @dispatch: Called to dispatch the event source, after it has returned\n %TRUE in either its @prepare or its @check function. The @dispatch\n function is passed in a callback function and data. The callback\n function may be %NULL if the source was never connected to a callback\n using g_source_set_callback(). The @dispatch function should call the\n callback function with @user_data and whatever additional parameters\n are needed for this type of event source.\n @finalize: Called when the source is finalized.\n\n The `GSourceFuncs` struct contains a table of\n functions used to handle event sources in a generic manner.\n\n For idle sources, the prepare and check functions always return %TRUE\n to indicate that the source is always ready to be processed. The prepare\n function also returns a timeout value of 0 to ensure that the poll() call\n doesn't block (since that would be time wasted which could have been spent\n running the idle function).\n\n For timeout sources, the prepare and check functions both return %TRUE\n if the timeout interval has expired. The prepare function also returns\n a timeout value to ensure that the poll() call doesn't block too long\n and miss the next timeout.\n\n For file descriptor sources, the prepare function typically returns %FALSE,\n since it must wait until poll() has been called before it knows whether\n any events need to be processed. It sets the returned timeout to -1 to\n indicate that it doesn't mind how long the poll() call blocks. In the\n check function, it tests the results of the poll() call to see if the\n required condition has been met, and returns %TRUE if so."]
pub type GSourceFuncs = _GSourceFuncs;
#[doc = " GSourceFunc:\n @user_data: data passed to the function, set when the source was\n created with one of the above functions\n\n Specifies the type of function passed to g_timeout_add(),\n g_timeout_add_full(), g_idle_add(), and g_idle_add_full().\n\n Returns: %FALSE if the source should be removed. #G_SOURCE_CONTINUE and\n #G_SOURCE_REMOVE are more memorable names for the return value."]
pub type GSourceFunc = ::std::option::Option<unsafe extern "C" fn(user_data: gpointer) -> gboolean>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GSource {
pub callback_data: gpointer,
pub callback_funcs: *mut GSourceCallbackFuncs,
pub source_funcs: *const GSourceFuncs,
pub ref_count: guint,
pub context: *mut GMainContext,
pub priority: gint,
pub flags: guint,
pub source_id: guint,
pub poll_fds: *mut GSList,
pub prev: *mut GSource,
pub next: *mut GSource,
pub name: *mut ::std::os::raw::c_char,
pub priv_: *mut GSourcePrivate,
}
#[test]
fn bindgen_test_layout__GSource() {
const UNINIT: ::std::mem::MaybeUninit<_GSource> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GSource>(),
96usize,
concat!("Size of: ", stringify!(_GSource))
);
assert_eq!(
::std::mem::align_of::<_GSource>(),
8usize,
concat!("Alignment of ", stringify!(_GSource))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).callback_data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GSource),
"::",
stringify!(callback_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).callback_funcs) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GSource),
"::",
stringify!(callback_funcs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).source_funcs) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GSource),
"::",
stringify!(source_funcs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ref_count) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GSource),
"::",
stringify!(ref_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GSource),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priority) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GSource),
"::",
stringify!(priority)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(_GSource),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).source_id) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GSource),
"::",
stringify!(source_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).poll_fds) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GSource),
"::",
stringify!(poll_fds)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GSource),
"::",
stringify!(prev)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_GSource),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_GSource),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_GSource),
"::",
stringify!(priv_)
)
);
}
impl Default for _GSource {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _GSourceCallbackFuncs {
pub ref_: ::std::option::Option<unsafe extern "C" fn(cb_data: gpointer)>,
pub unref: ::std::option::Option<unsafe extern "C" fn(cb_data: gpointer)>,
pub get: ::std::option::Option<
unsafe extern "C" fn(
cb_data: gpointer,
source: *mut GSource,
func: *mut GSourceFunc,
data: *mut gpointer,
),
>,
}
#[test]
fn bindgen_test_layout__GSourceCallbackFuncs() {
const UNINIT: ::std::mem::MaybeUninit<_GSourceCallbackFuncs> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GSourceCallbackFuncs>(),
24usize,
concat!("Size of: ", stringify!(_GSourceCallbackFuncs))
);
assert_eq!(
::std::mem::align_of::<_GSourceCallbackFuncs>(),
8usize,
concat!("Alignment of ", stringify!(_GSourceCallbackFuncs))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ref_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GSourceCallbackFuncs),
"::",
stringify!(ref_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).unref) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GSourceCallbackFuncs),
"::",
stringify!(unref)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GSourceCallbackFuncs),
"::",
stringify!(get)
)
);
}
#[doc = " GSourceDummyMarshal:\n\n This is just a placeholder for #GClosureMarshal,\n which cannot be used here for dependency reasons."]
pub type GSourceDummyMarshal = ::std::option::Option<unsafe extern "C" fn()>;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _GSourceFuncs {
pub prepare: ::std::option::Option<
unsafe extern "C" fn(source: *mut GSource, timeout_: *mut gint) -> gboolean,
>,
pub check: ::std::option::Option<unsafe extern "C" fn(source: *mut GSource) -> gboolean>,
pub dispatch: ::std::option::Option<
unsafe extern "C" fn(
source: *mut GSource,
callback: GSourceFunc,
user_data: gpointer,
) -> gboolean,
>,
pub finalize: ::std::option::Option<unsafe extern "C" fn(source: *mut GSource)>,
pub closure_callback: GSourceFunc,
pub closure_marshal: GSourceDummyMarshal,
}
#[test]
fn bindgen_test_layout__GSourceFuncs() {
const UNINIT: ::std::mem::MaybeUninit<_GSourceFuncs> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GSourceFuncs>(),
48usize,
concat!("Size of: ", stringify!(_GSourceFuncs))
);
assert_eq!(
::std::mem::align_of::<_GSourceFuncs>(),
8usize,
concat!("Alignment of ", stringify!(_GSourceFuncs))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).prepare) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GSourceFuncs),
"::",
stringify!(prepare)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).check) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GSourceFuncs),
"::",
stringify!(check)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dispatch) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GSourceFuncs),
"::",
stringify!(dispatch)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).finalize) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GSourceFuncs),
"::",
stringify!(finalize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).closure_callback) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GSourceFuncs),
"::",
stringify!(closure_callback)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).closure_marshal) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GSourceFuncs),
"::",
stringify!(closure_marshal)
)
);
}
extern "C" {
pub fn g_main_context_new() -> *mut GMainContext;
}
extern "C" {
pub fn g_main_context_ref(context: *mut GMainContext) -> *mut GMainContext;
}
extern "C" {
pub fn g_main_context_unref(context: *mut GMainContext);
}
extern "C" {
pub fn g_main_context_default() -> *mut GMainContext;
}
extern "C" {
pub fn g_main_context_iteration(context: *mut GMainContext, may_block: gboolean) -> gboolean;
}
extern "C" {
pub fn g_main_context_pending(context: *mut GMainContext) -> gboolean;
}
extern "C" {
pub fn g_main_context_find_source_by_id(
context: *mut GMainContext,
source_id: guint,
) -> *mut GSource;
}
extern "C" {
pub fn g_main_context_find_source_by_user_data(
context: *mut GMainContext,
user_data: gpointer,
) -> *mut GSource;
}
extern "C" {
pub fn g_main_context_find_source_by_funcs_user_data(
context: *mut GMainContext,
funcs: *mut GSourceFuncs,
user_data: gpointer,
) -> *mut GSource;
}
extern "C" {
pub fn g_main_context_wakeup(context: *mut GMainContext);
}
extern "C" {
pub fn g_main_context_acquire(context: *mut GMainContext) -> gboolean;
}
extern "C" {
pub fn g_main_context_release(context: *mut GMainContext);
}
extern "C" {
pub fn g_main_context_is_owner(context: *mut GMainContext) -> gboolean;
}
extern "C" {
pub fn g_main_context_wait(
context: *mut GMainContext,
cond: *mut GCond,
mutex: *mut GMutex,
) -> gboolean;
}
extern "C" {
pub fn g_main_context_prepare(context: *mut GMainContext, priority: *mut gint) -> gboolean;
}
extern "C" {
pub fn g_main_context_query(
context: *mut GMainContext,
max_priority: gint,
timeout_: *mut gint,
fds: *mut GPollFD,
n_fds: gint,
) -> gint;
}
extern "C" {
pub fn g_main_context_check(
context: *mut GMainContext,
max_priority: gint,
fds: *mut GPollFD,
n_fds: gint,
) -> gint;
}
extern "C" {
pub fn g_main_context_dispatch(context: *mut GMainContext);
}
extern "C" {
pub fn g_main_context_set_poll_func(context: *mut GMainContext, func: GPollFunc);
}
extern "C" {
pub fn g_main_context_get_poll_func(context: *mut GMainContext) -> GPollFunc;
}
extern "C" {
pub fn g_main_context_add_poll(context: *mut GMainContext, fd: *mut GPollFD, priority: gint);
}
extern "C" {
pub fn g_main_context_remove_poll(context: *mut GMainContext, fd: *mut GPollFD);
}
extern "C" {
pub fn g_main_context_push_thread_default(context: *mut GMainContext);
}
extern "C" {
pub fn g_main_context_pop_thread_default(context: *mut GMainContext);
}
extern "C" {
pub fn g_main_context_get_thread_default() -> *mut GMainContext;
}
extern "C" {
pub fn g_main_context_ref_thread_default() -> *mut GMainContext;
}
extern "C" {
pub fn g_timeout_source_new(interval: guint) -> *mut GSource;
}
extern "C" {
pub fn g_timeout_source_new_seconds(interval: guint) -> *mut GSource;
}
extern "C" {
pub fn g_timeout_add_full(
priority: gint,
interval: guint,
function: GSourceFunc,
data: gpointer,
notify: GDestroyNotify,
) -> guint;
}
extern "C" {
pub fn g_timeout_add(interval: guint, function: GSourceFunc, data: gpointer) -> guint;
}
extern "C" {
pub fn g_timeout_add_seconds_full(
priority: gint,
interval: guint,
function: GSourceFunc,
data: gpointer,
notify: GDestroyNotify,
) -> guint;
}
extern "C" {
pub fn g_timeout_add_seconds(interval: guint, function: GSourceFunc, data: gpointer) -> guint;
}
extern "C" {
pub fn g_main_context_invoke_full(
context: *mut GMainContext,
priority: gint,
function: GSourceFunc,
data: gpointer,
notify: GDestroyNotify,
);
}
extern "C" {
pub fn g_main_context_invoke(context: *mut GMainContext, function: GSourceFunc, data: gpointer);
}
#[doc = " gunichar:\n\n A type which can hold any UTF-32 or UCS-4 character code,\n also known as a Unicode code point.\n\n If you want to produce the UTF-8 representation of a #gunichar,\n use g_ucs4_to_utf8(). See also g_utf8_to_ucs4() for the reverse\n process.\n\n To print/scan values of this type as integer, use\n %G_GINT32_MODIFIER and/or %G_GUINT32_FORMAT.\n\n The notation to express a Unicode code point in running text is\n as a hexadecimal number with four to six digits and uppercase\n letters, prefixed by the string \"U+\". Leading zeros are omitted,\n unless the code point would have fewer than four hexadecimal digits.\n For example, \"U+0041 LATIN CAPITAL LETTER A\". To print a code point\n in the U+-notation, use the format string \"U+\\%04\"G_GINT32_FORMAT\"X\".\n To scan, use the format string \"U+\\%06\"G_GINT32_FORMAT\"X\".\n\n |[\n gunichar c;\n sscanf (\"U+0041\", \"U+%06\"G_GINT32_FORMAT\"X\", &amp;c)\n g_print (\"Read U+%04\"G_GINT32_FORMAT\"X\", c);\n ]|"]
pub type gunichar = guint32;
pub type GString = _GString;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GString {
pub str_: *mut gchar,
pub len: gsize,
pub allocated_len: gsize,
}
#[test]
fn bindgen_test_layout__GString() {
const UNINIT: ::std::mem::MaybeUninit<_GString> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GString>(),
24usize,
concat!("Size of: ", stringify!(_GString))
);
assert_eq!(
::std::mem::align_of::<_GString>(),
8usize,
concat!("Alignment of ", stringify!(_GString))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).str_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GString),
"::",
stringify!(str_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GString),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocated_len) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GString),
"::",
stringify!(allocated_len)
)
);
}
impl Default for _GString {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GKeyFile {
_unused: [u8; 0],
}
pub type GKeyFile = _GKeyFile;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GMarkupParseContext {
_unused: [u8; 0],
}
#[doc = " GMarkupParseContext:\n\n A parse context is used to parse a stream of bytes that\n you expect to contain marked-up text.\n\n See g_markup_parse_context_new(), #GMarkupParser, and so\n on for more details."]
pub type GMarkupParseContext = _GMarkupParseContext;
#[doc = " GMarkupParser:\n @start_element: Callback to invoke when the opening tag of an element\n is seen. The callback's @attribute_names and @attribute_values parameters\n are %NULL-terminated.\n @end_element: Callback to invoke when the closing tag of an element\n is seen. Note that this is also called for empty tags like\n `<empty/>`.\n @text: Callback to invoke when some text is seen (text is always\n inside an element). Note that the text of an element may be spread\n over multiple calls of this function. If the\n %G_MARKUP_TREAT_CDATA_AS_TEXT flag is set, this function is also\n called for the content of CDATA marked sections.\n @passthrough: Callback to invoke for comments, processing instructions\n and doctype declarations; if you're re-writing the parsed document,\n write the passthrough text back out in the same position. If the\n %G_MARKUP_TREAT_CDATA_AS_TEXT flag is not set, this function is also\n called for CDATA marked sections.\n @error: Callback to invoke when an error occurs.\n\n Any of the fields in #GMarkupParser can be %NULL, in which case they\n will be ignored. Except for the @error function, any of these callbacks\n can set an error; in particular the %G_MARKUP_ERROR_UNKNOWN_ELEMENT,\n %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, and %G_MARKUP_ERROR_INVALID_CONTENT\n errors are intended to be set from these callbacks. If you set an error\n from a callback, g_markup_parse_context_parse() will report that error\n back to its caller."]
pub type GMarkupParser = _GMarkupParser;
#[doc = " GMarkupParser:\n @start_element: Callback to invoke when the opening tag of an element\n is seen. The callback's @attribute_names and @attribute_values parameters\n are %NULL-terminated.\n @end_element: Callback to invoke when the closing tag of an element\n is seen. Note that this is also called for empty tags like\n `<empty/>`.\n @text: Callback to invoke when some text is seen (text is always\n inside an element). Note that the text of an element may be spread\n over multiple calls of this function. If the\n %G_MARKUP_TREAT_CDATA_AS_TEXT flag is set, this function is also\n called for the content of CDATA marked sections.\n @passthrough: Callback to invoke for comments, processing instructions\n and doctype declarations; if you're re-writing the parsed document,\n write the passthrough text back out in the same position. If the\n %G_MARKUP_TREAT_CDATA_AS_TEXT flag is not set, this function is also\n called for CDATA marked sections.\n @error: Callback to invoke when an error occurs.\n\n Any of the fields in #GMarkupParser can be %NULL, in which case they\n will be ignored. Except for the @error function, any of these callbacks\n can set an error; in particular the %G_MARKUP_ERROR_UNKNOWN_ELEMENT,\n %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, and %G_MARKUP_ERROR_INVALID_CONTENT\n errors are intended to be set from these callbacks. If you set an error\n from a callback, g_markup_parse_context_parse() will report that error\n back to its caller."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _GMarkupParser {
pub start_element: ::std::option::Option<
unsafe extern "C" fn(
context: *mut GMarkupParseContext,
element_name: *const gchar,
attribute_names: *mut *const gchar,
attribute_values: *mut *const gchar,
user_data: gpointer,
error: *mut *mut GError,
),
>,
pub end_element: ::std::option::Option<
unsafe extern "C" fn(
context: *mut GMarkupParseContext,
element_name: *const gchar,
user_data: gpointer,
error: *mut *mut GError,
),
>,
pub text: ::std::option::Option<
unsafe extern "C" fn(
context: *mut GMarkupParseContext,
text: *const gchar,
text_len: gsize,
user_data: gpointer,
error: *mut *mut GError,
),
>,
pub passthrough: ::std::option::Option<
unsafe extern "C" fn(
context: *mut GMarkupParseContext,
passthrough_text: *const gchar,
text_len: gsize,
user_data: gpointer,
error: *mut *mut GError,
),
>,
pub error: ::std::option::Option<
unsafe extern "C" fn(
context: *mut GMarkupParseContext,
error: *mut GError,
user_data: gpointer,
),
>,
}
#[test]
fn bindgen_test_layout__GMarkupParser() {
const UNINIT: ::std::mem::MaybeUninit<_GMarkupParser> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GMarkupParser>(),
40usize,
concat!("Size of: ", stringify!(_GMarkupParser))
);
assert_eq!(
::std::mem::align_of::<_GMarkupParser>(),
8usize,
concat!("Alignment of ", stringify!(_GMarkupParser))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).start_element) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GMarkupParser),
"::",
stringify!(start_element)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).end_element) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GMarkupParser),
"::",
stringify!(end_element)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GMarkupParser),
"::",
stringify!(text)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).passthrough) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GMarkupParser),
"::",
stringify!(passthrough)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).error) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GMarkupParser),
"::",
stringify!(error)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GOptionGroup {
_unused: [u8; 0],
}
#[doc = " GOptionGroup:\n\n A `GOptionGroup` struct defines the options in a single\n group. The struct has only private fields and should not be directly accessed.\n\n All options in a group share the same translation function. Libraries which\n need to parse commandline options are expected to provide a function for\n getting a `GOptionGroup` holding their options, which\n the application can then add to its #GOptionContext."]
pub type GOptionGroup = _GOptionGroup;
#[doc = " GOptionEntry:\n @long_name: The long name of an option can be used to specify it\n in a commandline as `--long_name`. Every option must have a\n long name. To resolve conflicts if multiple option groups contain\n the same long name, it is also possible to specify the option as\n `--groupname-long_name`.\n @short_name: If an option has a short name, it can be specified\n `-short_name` in a commandline. @short_name must be a printable\n ASCII character different from '-', or zero if the option has no\n short name.\n @flags: Flags from #GOptionFlags\n @arg: The type of the option, as a #GOptionArg\n @arg_data: If the @arg type is %G_OPTION_ARG_CALLBACK, then @arg_data\n must point to a #GOptionArgFunc callback function, which will be\n called to handle the extra argument. Otherwise, @arg_data is a\n pointer to a location to store the value, the required type of\n the location depends on the @arg type:\n - %G_OPTION_ARG_NONE: %gboolean\n - %G_OPTION_ARG_STRING: %gchar*\n - %G_OPTION_ARG_INT: %gint\n - %G_OPTION_ARG_FILENAME: %gchar*\n - %G_OPTION_ARG_STRING_ARRAY: %gchar**\n - %G_OPTION_ARG_FILENAME_ARRAY: %gchar**\n - %G_OPTION_ARG_DOUBLE: %gdouble\n If @arg type is %G_OPTION_ARG_STRING or %G_OPTION_ARG_FILENAME,\n the location will contain a newly allocated string if the option\n was given. That string needs to be freed by the callee using g_free().\n Likewise if @arg type is %G_OPTION_ARG_STRING_ARRAY or\n %G_OPTION_ARG_FILENAME_ARRAY, the data should be freed using g_strfreev().\n @description: the description for the option in `--help`\n output. The @description is translated using the @translate_func\n of the group, see g_option_group_set_translation_domain().\n @arg_description: The placeholder to use for the extra argument parsed\n by the option in `--help` output. The @arg_description is translated\n using the @translate_func of the group, see\n g_option_group_set_translation_domain().\n\n A GOptionEntry struct defines a single option. To have an effect, they\n must be added to a #GOptionGroup with g_option_context_add_main_entries()\n or g_option_group_add_entries()."]
pub type GOptionEntry = _GOptionEntry;
pub const GOptionFlags_G_OPTION_FLAG_NONE: GOptionFlags = 0;
pub const GOptionFlags_G_OPTION_FLAG_HIDDEN: GOptionFlags = 1;
pub const GOptionFlags_G_OPTION_FLAG_IN_MAIN: GOptionFlags = 2;
pub const GOptionFlags_G_OPTION_FLAG_REVERSE: GOptionFlags = 4;
pub const GOptionFlags_G_OPTION_FLAG_NO_ARG: GOptionFlags = 8;
pub const GOptionFlags_G_OPTION_FLAG_FILENAME: GOptionFlags = 16;
pub const GOptionFlags_G_OPTION_FLAG_OPTIONAL_ARG: GOptionFlags = 32;
pub const GOptionFlags_G_OPTION_FLAG_NOALIAS: GOptionFlags = 64;
#[doc = " GOptionFlags:\n @G_OPTION_FLAG_NONE: No flags. Since: 2.42.\n @G_OPTION_FLAG_HIDDEN: The option doesn't appear in `--help` output.\n @G_OPTION_FLAG_IN_MAIN: The option appears in the main section of the\n `--help` output, even if it is defined in a group.\n @G_OPTION_FLAG_REVERSE: For options of the %G_OPTION_ARG_NONE kind, this\n flag indicates that the sense of the option is reversed.\n @G_OPTION_FLAG_NO_ARG: For options of the %G_OPTION_ARG_CALLBACK kind,\n this flag indicates that the callback does not take any argument\n (like a %G_OPTION_ARG_NONE option). Since 2.8\n @G_OPTION_FLAG_FILENAME: For options of the %G_OPTION_ARG_CALLBACK\n kind, this flag indicates that the argument should be passed to the\n callback in the GLib filename encoding rather than UTF-8. Since 2.8\n @G_OPTION_FLAG_OPTIONAL_ARG: For options of the %G_OPTION_ARG_CALLBACK\n kind, this flag indicates that the argument supply is optional.\n If no argument is given then data of %GOptionParseFunc will be\n set to NULL. Since 2.8\n @G_OPTION_FLAG_NOALIAS: This flag turns off the automatic conflict\n resolution which prefixes long option names with `groupname-` if\n there is a conflict. This option should only be used in situations\n where aliasing is necessary to model some legacy commandline interface.\n It is not safe to use this option, unless all option groups are under\n your direct control. Since 2.8.\n\n Flags which modify individual options."]
pub type GOptionFlags = ::std::os::raw::c_uint;
pub const GOptionArg_G_OPTION_ARG_NONE: GOptionArg = 0;
pub const GOptionArg_G_OPTION_ARG_STRING: GOptionArg = 1;
pub const GOptionArg_G_OPTION_ARG_INT: GOptionArg = 2;
pub const GOptionArg_G_OPTION_ARG_CALLBACK: GOptionArg = 3;
pub const GOptionArg_G_OPTION_ARG_FILENAME: GOptionArg = 4;
pub const GOptionArg_G_OPTION_ARG_STRING_ARRAY: GOptionArg = 5;
pub const GOptionArg_G_OPTION_ARG_FILENAME_ARRAY: GOptionArg = 6;
pub const GOptionArg_G_OPTION_ARG_DOUBLE: GOptionArg = 7;
pub const GOptionArg_G_OPTION_ARG_INT64: GOptionArg = 8;
#[doc = " GOptionArg:\n @G_OPTION_ARG_NONE: No extra argument. This is useful for simple flags.\n @G_OPTION_ARG_STRING: The option takes a string argument.\n @G_OPTION_ARG_INT: The option takes an integer argument.\n @G_OPTION_ARG_CALLBACK: The option provides a callback to parse the\n extra argument.\n @G_OPTION_ARG_FILENAME: The option takes a filename as argument.\n @G_OPTION_ARG_STRING_ARRAY: The option takes a string argument, multiple\n uses of the option are collected into an array of strings.\n @G_OPTION_ARG_FILENAME_ARRAY: The option takes a filename as argument,\n multiple uses of the option are collected into an array of strings.\n @G_OPTION_ARG_DOUBLE: The option takes a double argument. The argument\n can be formatted either for the user's locale or for the \"C\" locale.\n Since 2.12\n @G_OPTION_ARG_INT64: The option takes a 64-bit integer. Like\n %G_OPTION_ARG_INT but for larger numbers. The number can be in\n decimal base, or in hexadecimal (when prefixed with `0x`, for\n example, `0xffffffff`). Since 2.12\n\n The #GOptionArg enum values determine which type of extra argument the\n options expect to find. If an option expects an extra argument, it can\n be specified in several ways; with a short option: `-x arg`, with a long\n option: `--name arg` or combined in a single argument: `--name=arg`."]
pub type GOptionArg = ::std::os::raw::c_uint;
#[doc = " GOptionEntry:\n @long_name: The long name of an option can be used to specify it\n in a commandline as `--long_name`. Every option must have a\n long name. To resolve conflicts if multiple option groups contain\n the same long name, it is also possible to specify the option as\n `--groupname-long_name`.\n @short_name: If an option has a short name, it can be specified\n `-short_name` in a commandline. @short_name must be a printable\n ASCII character different from '-', or zero if the option has no\n short name.\n @flags: Flags from #GOptionFlags\n @arg: The type of the option, as a #GOptionArg\n @arg_data: If the @arg type is %G_OPTION_ARG_CALLBACK, then @arg_data\n must point to a #GOptionArgFunc callback function, which will be\n called to handle the extra argument. Otherwise, @arg_data is a\n pointer to a location to store the value, the required type of\n the location depends on the @arg type:\n - %G_OPTION_ARG_NONE: %gboolean\n - %G_OPTION_ARG_STRING: %gchar*\n - %G_OPTION_ARG_INT: %gint\n - %G_OPTION_ARG_FILENAME: %gchar*\n - %G_OPTION_ARG_STRING_ARRAY: %gchar**\n - %G_OPTION_ARG_FILENAME_ARRAY: %gchar**\n - %G_OPTION_ARG_DOUBLE: %gdouble\n If @arg type is %G_OPTION_ARG_STRING or %G_OPTION_ARG_FILENAME,\n the location will contain a newly allocated string if the option\n was given. That string needs to be freed by the callee using g_free().\n Likewise if @arg type is %G_OPTION_ARG_STRING_ARRAY or\n %G_OPTION_ARG_FILENAME_ARRAY, the data should be freed using g_strfreev().\n @description: the description for the option in `--help`\n output. The @description is translated using the @translate_func\n of the group, see g_option_group_set_translation_domain().\n @arg_description: The placeholder to use for the extra argument parsed\n by the option in `--help` output. The @arg_description is translated\n using the @translate_func of the group, see\n g_option_group_set_translation_domain().\n\n A GOptionEntry struct defines a single option. To have an effect, they\n must be added to a #GOptionGroup with g_option_context_add_main_entries()\n or g_option_group_add_entries()."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GOptionEntry {
pub long_name: *const gchar,
pub short_name: gchar,
pub flags: gint,
pub arg: GOptionArg,
pub arg_data: gpointer,
pub description: *const gchar,
pub arg_description: *const gchar,
}
#[test]
fn bindgen_test_layout__GOptionEntry() {
const UNINIT: ::std::mem::MaybeUninit<_GOptionEntry> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GOptionEntry>(),
48usize,
concat!("Size of: ", stringify!(_GOptionEntry))
);
assert_eq!(
::std::mem::align_of::<_GOptionEntry>(),
8usize,
concat!("Alignment of ", stringify!(_GOptionEntry))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).long_name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GOptionEntry),
"::",
stringify!(long_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).short_name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GOptionEntry),
"::",
stringify!(short_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_GOptionEntry),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).arg) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GOptionEntry),
"::",
stringify!(arg)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).arg_data) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GOptionEntry),
"::",
stringify!(arg_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GOptionEntry),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).arg_description) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GOptionEntry),
"::",
stringify!(arg_description)
)
);
}
impl Default for _GOptionEntry {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type GScanner = _GScanner;
pub type GScannerConfig = _GScannerConfig;
pub type GTokenValue = _GTokenValue;
pub type GScannerMsgFunc = ::std::option::Option<
unsafe extern "C" fn(scanner: *mut GScanner, message: *mut gchar, error: gboolean),
>;
pub const GTokenType_G_TOKEN_EOF: GTokenType = 0;
pub const GTokenType_G_TOKEN_LEFT_PAREN: GTokenType = 40;
pub const GTokenType_G_TOKEN_RIGHT_PAREN: GTokenType = 41;
pub const GTokenType_G_TOKEN_LEFT_CURLY: GTokenType = 123;
pub const GTokenType_G_TOKEN_RIGHT_CURLY: GTokenType = 125;
pub const GTokenType_G_TOKEN_LEFT_BRACE: GTokenType = 91;
pub const GTokenType_G_TOKEN_RIGHT_BRACE: GTokenType = 93;
pub const GTokenType_G_TOKEN_EQUAL_SIGN: GTokenType = 61;
pub const GTokenType_G_TOKEN_COMMA: GTokenType = 44;
pub const GTokenType_G_TOKEN_NONE: GTokenType = 256;
pub const GTokenType_G_TOKEN_ERROR: GTokenType = 257;
pub const GTokenType_G_TOKEN_CHAR: GTokenType = 258;
pub const GTokenType_G_TOKEN_BINARY: GTokenType = 259;
pub const GTokenType_G_TOKEN_OCTAL: GTokenType = 260;
pub const GTokenType_G_TOKEN_INT: GTokenType = 261;
pub const GTokenType_G_TOKEN_HEX: GTokenType = 262;
pub const GTokenType_G_TOKEN_FLOAT: GTokenType = 263;
pub const GTokenType_G_TOKEN_STRING: GTokenType = 264;
pub const GTokenType_G_TOKEN_SYMBOL: GTokenType = 265;
pub const GTokenType_G_TOKEN_IDENTIFIER: GTokenType = 266;
pub const GTokenType_G_TOKEN_IDENTIFIER_NULL: GTokenType = 267;
pub const GTokenType_G_TOKEN_COMMENT_SINGLE: GTokenType = 268;
pub const GTokenType_G_TOKEN_COMMENT_MULTI: GTokenType = 269;
pub const GTokenType_G_TOKEN_LAST: GTokenType = 270;
pub type GTokenType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub union _GTokenValue {
pub v_symbol: gpointer,
pub v_identifier: *mut gchar,
pub v_binary: gulong,
pub v_octal: gulong,
pub v_int: gulong,
pub v_int64: guint64,
pub v_float: gdouble,
pub v_hex: gulong,
pub v_string: *mut gchar,
pub v_comment: *mut gchar,
pub v_char: guchar,
pub v_error: guint,
}
#[test]
fn bindgen_test_layout__GTokenValue() {
const UNINIT: ::std::mem::MaybeUninit<_GTokenValue> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GTokenValue>(),
8usize,
concat!("Size of: ", stringify!(_GTokenValue))
);
assert_eq!(
::std::mem::align_of::<_GTokenValue>(),
8usize,
concat!("Alignment of ", stringify!(_GTokenValue))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_symbol) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GTokenValue),
"::",
stringify!(v_symbol)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_identifier) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GTokenValue),
"::",
stringify!(v_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_binary) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GTokenValue),
"::",
stringify!(v_binary)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_octal) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GTokenValue),
"::",
stringify!(v_octal)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_int) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GTokenValue),
"::",
stringify!(v_int)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_int64) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GTokenValue),
"::",
stringify!(v_int64)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_float) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GTokenValue),
"::",
stringify!(v_float)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_hex) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GTokenValue),
"::",
stringify!(v_hex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_string) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GTokenValue),
"::",
stringify!(v_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_comment) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GTokenValue),
"::",
stringify!(v_comment)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_char) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GTokenValue),
"::",
stringify!(v_char)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_error) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GTokenValue),
"::",
stringify!(v_error)
)
);
}
impl Default for _GTokenValue {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GScannerConfig {
pub cset_skip_characters: *mut gchar,
pub cset_identifier_first: *mut gchar,
pub cset_identifier_nth: *mut gchar,
pub cpair_comment_single: *mut gchar,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
pub padding_dummy: guint,
}
#[test]
fn bindgen_test_layout__GScannerConfig() {
const UNINIT: ::std::mem::MaybeUninit<_GScannerConfig> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GScannerConfig>(),
40usize,
concat!("Size of: ", stringify!(_GScannerConfig))
);
assert_eq!(
::std::mem::align_of::<_GScannerConfig>(),
8usize,
concat!("Alignment of ", stringify!(_GScannerConfig))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cset_skip_characters) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GScannerConfig),
"::",
stringify!(cset_skip_characters)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cset_identifier_first) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GScannerConfig),
"::",
stringify!(cset_identifier_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cset_identifier_nth) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GScannerConfig),
"::",
stringify!(cset_identifier_nth)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cpair_comment_single) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GScannerConfig),
"::",
stringify!(cpair_comment_single)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).padding_dummy) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(_GScannerConfig),
"::",
stringify!(padding_dummy)
)
);
}
impl Default for _GScannerConfig {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl _GScannerConfig {
#[inline]
pub fn case_sensitive(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
}
#[inline]
pub fn set_case_sensitive(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn skip_comment_multi(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
}
#[inline]
pub fn set_skip_comment_multi(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn skip_comment_single(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
}
#[inline]
pub fn set_skip_comment_single(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn scan_comment_multi(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
}
#[inline]
pub fn set_scan_comment_multi(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub fn scan_identifier(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
}
#[inline]
pub fn set_scan_identifier(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn scan_identifier_1char(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
}
#[inline]
pub fn set_scan_identifier_1char(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 1u8, val as u64)
}
}
#[inline]
pub fn scan_identifier_NULL(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
}
#[inline]
pub fn set_scan_identifier_NULL(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 1u8, val as u64)
}
}
#[inline]
pub fn scan_symbols(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
}
#[inline]
pub fn set_scan_symbols(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(7usize, 1u8, val as u64)
}
}
#[inline]
pub fn scan_binary(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
}
#[inline]
pub fn set_scan_binary(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 1u8, val as u64)
}
}
#[inline]
pub fn scan_octal(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
}
#[inline]
pub fn set_scan_octal(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(9usize, 1u8, val as u64)
}
}
#[inline]
pub fn scan_float(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
}
#[inline]
pub fn set_scan_float(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(10usize, 1u8, val as u64)
}
}
#[inline]
pub fn scan_hex(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
}
#[inline]
pub fn set_scan_hex(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 1u8, val as u64)
}
}
#[inline]
pub fn scan_hex_dollar(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
}
#[inline]
pub fn set_scan_hex_dollar(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 1u8, val as u64)
}
}
#[inline]
pub fn scan_string_sq(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
}
#[inline]
pub fn set_scan_string_sq(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 1u8, val as u64)
}
}
#[inline]
pub fn scan_string_dq(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
}
#[inline]
pub fn set_scan_string_dq(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(14usize, 1u8, val as u64)
}
}
#[inline]
pub fn numbers_2_int(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
}
#[inline]
pub fn set_numbers_2_int(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(15usize, 1u8, val as u64)
}
}
#[inline]
pub fn int_2_float(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
}
#[inline]
pub fn set_int_2_float(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(16usize, 1u8, val as u64)
}
}
#[inline]
pub fn identifier_2_string(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
}
#[inline]
pub fn set_identifier_2_string(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(17usize, 1u8, val as u64)
}
}
#[inline]
pub fn char_2_token(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
}
#[inline]
pub fn set_char_2_token(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(18usize, 1u8, val as u64)
}
}
#[inline]
pub fn symbol_2_token(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
}
#[inline]
pub fn set_symbol_2_token(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(19usize, 1u8, val as u64)
}
}
#[inline]
pub fn scope_0_fallback(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
}
#[inline]
pub fn set_scope_0_fallback(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(20usize, 1u8, val as u64)
}
}
#[inline]
pub fn store_int64(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
}
#[inline]
pub fn set_store_int64(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(21usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
case_sensitive: guint,
skip_comment_multi: guint,
skip_comment_single: guint,
scan_comment_multi: guint,
scan_identifier: guint,
scan_identifier_1char: guint,
scan_identifier_NULL: guint,
scan_symbols: guint,
scan_binary: guint,
scan_octal: guint,
scan_float: guint,
scan_hex: guint,
scan_hex_dollar: guint,
scan_string_sq: guint,
scan_string_dq: guint,
numbers_2_int: guint,
int_2_float: guint,
identifier_2_string: guint,
char_2_token: guint,
symbol_2_token: guint,
scope_0_fallback: guint,
store_int64: guint,
) -> __BindgenBitfieldUnit<[u8; 3usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let case_sensitive: u32 = unsafe { ::std::mem::transmute(case_sensitive) };
case_sensitive as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let skip_comment_multi: u32 = unsafe { ::std::mem::transmute(skip_comment_multi) };
skip_comment_multi as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let skip_comment_single: u32 = unsafe { ::std::mem::transmute(skip_comment_single) };
skip_comment_single as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let scan_comment_multi: u32 = unsafe { ::std::mem::transmute(scan_comment_multi) };
scan_comment_multi as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let scan_identifier: u32 = unsafe { ::std::mem::transmute(scan_identifier) };
scan_identifier as u64
});
__bindgen_bitfield_unit.set(5usize, 1u8, {
let scan_identifier_1char: u32 =
unsafe { ::std::mem::transmute(scan_identifier_1char) };
scan_identifier_1char as u64
});
__bindgen_bitfield_unit.set(6usize, 1u8, {
let scan_identifier_NULL: u32 = unsafe { ::std::mem::transmute(scan_identifier_NULL) };
scan_identifier_NULL as u64
});
__bindgen_bitfield_unit.set(7usize, 1u8, {
let scan_symbols: u32 = unsafe { ::std::mem::transmute(scan_symbols) };
scan_symbols as u64
});
__bindgen_bitfield_unit.set(8usize, 1u8, {
let scan_binary: u32 = unsafe { ::std::mem::transmute(scan_binary) };
scan_binary as u64
});
__bindgen_bitfield_unit.set(9usize, 1u8, {
let scan_octal: u32 = unsafe { ::std::mem::transmute(scan_octal) };
scan_octal as u64
});
__bindgen_bitfield_unit.set(10usize, 1u8, {
let scan_float: u32 = unsafe { ::std::mem::transmute(scan_float) };
scan_float as u64
});
__bindgen_bitfield_unit.set(11usize, 1u8, {
let scan_hex: u32 = unsafe { ::std::mem::transmute(scan_hex) };
scan_hex as u64
});
__bindgen_bitfield_unit.set(12usize, 1u8, {
let scan_hex_dollar: u32 = unsafe { ::std::mem::transmute(scan_hex_dollar) };
scan_hex_dollar as u64
});
__bindgen_bitfield_unit.set(13usize, 1u8, {
let scan_string_sq: u32 = unsafe { ::std::mem::transmute(scan_string_sq) };
scan_string_sq as u64
});
__bindgen_bitfield_unit.set(14usize, 1u8, {
let scan_string_dq: u32 = unsafe { ::std::mem::transmute(scan_string_dq) };
scan_string_dq as u64
});
__bindgen_bitfield_unit.set(15usize, 1u8, {
let numbers_2_int: u32 = unsafe { ::std::mem::transmute(numbers_2_int) };
numbers_2_int as u64
});
__bindgen_bitfield_unit.set(16usize, 1u8, {
let int_2_float: u32 = unsafe { ::std::mem::transmute(int_2_float) };
int_2_float as u64
});
__bindgen_bitfield_unit.set(17usize, 1u8, {
let identifier_2_string: u32 = unsafe { ::std::mem::transmute(identifier_2_string) };
identifier_2_string as u64
});
__bindgen_bitfield_unit.set(18usize, 1u8, {
let char_2_token: u32 = unsafe { ::std::mem::transmute(char_2_token) };
char_2_token as u64
});
__bindgen_bitfield_unit.set(19usize, 1u8, {
let symbol_2_token: u32 = unsafe { ::std::mem::transmute(symbol_2_token) };
symbol_2_token as u64
});
__bindgen_bitfield_unit.set(20usize, 1u8, {
let scope_0_fallback: u32 = unsafe { ::std::mem::transmute(scope_0_fallback) };
scope_0_fallback as u64
});
__bindgen_bitfield_unit.set(21usize, 1u8, {
let store_int64: u32 = unsafe { ::std::mem::transmute(store_int64) };
store_int64 as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _GScanner {
pub user_data: gpointer,
pub max_parse_errors: guint,
pub parse_errors: guint,
pub input_name: *const gchar,
pub qdata: *mut GData,
pub config: *mut GScannerConfig,
pub token: GTokenType,
pub value: GTokenValue,
pub line: guint,
pub position: guint,
pub next_token: GTokenType,
pub next_value: GTokenValue,
pub next_line: guint,
pub next_position: guint,
pub symbol_table: *mut GHashTable,
pub input_fd: gint,
pub text: *const gchar,
pub text_end: *const gchar,
pub buffer: *mut gchar,
pub scope_id: guint,
pub msg_handler: GScannerMsgFunc,
}
#[test]
fn bindgen_test_layout__GScanner() {
const UNINIT: ::std::mem::MaybeUninit<_GScanner> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GScanner>(),
144usize,
concat!("Size of: ", stringify!(_GScanner))
);
assert_eq!(
::std::mem::align_of::<_GScanner>(),
8usize,
concat!("Alignment of ", stringify!(_GScanner))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).user_data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(user_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_parse_errors) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(max_parse_errors)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parse_errors) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(parse_errors)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).input_name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(input_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qdata) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(qdata)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).config) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(config)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).token) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(token)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next_token) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(next_token)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next_value) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(next_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next_line) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(next_line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next_position) as usize - ptr as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(next_position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).symbol_table) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(symbol_table)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).input_fd) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(input_fd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(text)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).text_end) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(text_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(buffer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).scope_id) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(scope_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).msg_handler) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_GScanner),
"::",
stringify!(msg_handler)
)
);
}
impl Default for _GScanner {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GVariant {
_unused: [u8; 0],
}
pub type GVariant = _GVariant;
pub type GVariantDict = _GVariantDict;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _GVariantDict {
pub x: [gsize; 16usize],
}
#[test]
fn bindgen_test_layout__GVariantDict() {
const UNINIT: ::std::mem::MaybeUninit<_GVariantDict> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GVariantDict>(),
128usize,
concat!("Size of: ", stringify!(_GVariantDict))
);
assert_eq!(
::std::mem::align_of::<_GVariantDict>(),
8usize,
concat!("Alignment of ", stringify!(_GVariantDict))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GVariantDict),
"::",
stringify!(x)
)
);
}
pub type GType = gsize;
#[doc = " GValue:\n\n An opaque structure used to hold different types of values.\n The data within the structure has protected scope: it is accessible only\n to functions within a #GTypeValueTable structure, or implementations of\n the g_value_*() API. That is, code portions which implement new fundamental\n types.\n #GValue users cannot make any assumptions about how data is stored\n within the 2 element @data union, and the @g_type member should\n only be accessed through the G_VALUE_TYPE() macro."]
pub type GValue = _GValue;
#[doc = " GTypeClass:\n\n An opaque structure used as the base of all classes."]
pub type GTypeClass = _GTypeClass;
#[doc = " GTypeInstance:\n\n An opaque structure used as the base of all type instances."]
pub type GTypeInstance = _GTypeInstance;
#[doc = " GTypeClass:\n\n An opaque structure used as the base of all classes."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _GTypeClass {
pub g_type: GType,
}
#[test]
fn bindgen_test_layout__GTypeClass() {
const UNINIT: ::std::mem::MaybeUninit<_GTypeClass> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GTypeClass>(),
8usize,
concat!("Size of: ", stringify!(_GTypeClass))
);
assert_eq!(
::std::mem::align_of::<_GTypeClass>(),
8usize,
concat!("Alignment of ", stringify!(_GTypeClass))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).g_type) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GTypeClass),
"::",
stringify!(g_type)
)
);
}
#[doc = " GTypeInstance:\n\n An opaque structure used as the base of all type instances."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GTypeInstance {
pub g_class: *mut GTypeClass,
}
#[test]
fn bindgen_test_layout__GTypeInstance() {
const UNINIT: ::std::mem::MaybeUninit<_GTypeInstance> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GTypeInstance>(),
8usize,
concat!("Size of: ", stringify!(_GTypeInstance))
);
assert_eq!(
::std::mem::align_of::<_GTypeInstance>(),
8usize,
concat!("Alignment of ", stringify!(_GTypeInstance))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).g_class) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GTypeInstance),
"::",
stringify!(g_class)
)
);
}
impl Default for _GTypeInstance {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GValue:\n\n An opaque structure used to hold different types of values.\n The data within the structure has protected scope: it is accessible only\n to functions within a #GTypeValueTable structure, or implementations of\n the g_value_*() API. That is, code portions which implement new fundamental\n types.\n #GValue users cannot make any assumptions about how data is stored\n within the 2 element @data union, and the @g_type member should\n only be accessed through the G_VALUE_TYPE() macro."]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _GValue {
pub g_type: GType,
pub data: [_GValue__bindgen_ty_1; 2usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _GValue__bindgen_ty_1 {
pub v_int: gint,
pub v_uint: guint,
pub v_long: glong,
pub v_ulong: gulong,
pub v_int64: gint64,
pub v_uint64: guint64,
pub v_float: gfloat,
pub v_double: gdouble,
pub v_pointer: gpointer,
}
#[test]
fn bindgen_test_layout__GValue__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<_GValue__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GValue__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(_GValue__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<_GValue__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(_GValue__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_int) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GValue__bindgen_ty_1),
"::",
stringify!(v_int)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_uint) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GValue__bindgen_ty_1),
"::",
stringify!(v_uint)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_long) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GValue__bindgen_ty_1),
"::",
stringify!(v_long)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_ulong) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GValue__bindgen_ty_1),
"::",
stringify!(v_ulong)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_int64) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GValue__bindgen_ty_1),
"::",
stringify!(v_int64)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_uint64) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GValue__bindgen_ty_1),
"::",
stringify!(v_uint64)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_float) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GValue__bindgen_ty_1),
"::",
stringify!(v_float)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_double) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GValue__bindgen_ty_1),
"::",
stringify!(v_double)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_pointer) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GValue__bindgen_ty_1),
"::",
stringify!(v_pointer)
)
);
}
impl Default for _GValue__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[test]
fn bindgen_test_layout__GValue() {
const UNINIT: ::std::mem::MaybeUninit<_GValue> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GValue>(),
24usize,
concat!("Size of: ", stringify!(_GValue))
);
assert_eq!(
::std::mem::align_of::<_GValue>(),
8usize,
concat!("Alignment of ", stringify!(_GValue))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).g_type) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GValue),
"::",
stringify!(g_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GValue),
"::",
stringify!(data)
)
);
}
impl Default for _GValue {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const GParamFlags_G_PARAM_READABLE: GParamFlags = 1;
pub const GParamFlags_G_PARAM_WRITABLE: GParamFlags = 2;
pub const GParamFlags_G_PARAM_READWRITE: GParamFlags = 3;
pub const GParamFlags_G_PARAM_CONSTRUCT: GParamFlags = 4;
pub const GParamFlags_G_PARAM_CONSTRUCT_ONLY: GParamFlags = 8;
pub const GParamFlags_G_PARAM_LAX_VALIDATION: GParamFlags = 16;
pub const GParamFlags_G_PARAM_STATIC_NAME: GParamFlags = 32;
pub const GParamFlags_G_PARAM_PRIVATE: GParamFlags = 32;
pub const GParamFlags_G_PARAM_STATIC_NICK: GParamFlags = 64;
pub const GParamFlags_G_PARAM_STATIC_BLURB: GParamFlags = 128;
pub const GParamFlags_G_PARAM_EXPLICIT_NOTIFY: GParamFlags = 1073741824;
pub const GParamFlags_G_PARAM_DEPRECATED: GParamFlags = -2147483648;
#[doc = " GParamFlags:\n @G_PARAM_READABLE: the parameter is readable\n @G_PARAM_WRITABLE: the parameter is writable\n @G_PARAM_READWRITE: alias for %G_PARAM_READABLE | %G_PARAM_WRITABLE\n @G_PARAM_CONSTRUCT: the parameter will be set upon object construction\n @G_PARAM_CONSTRUCT_ONLY: the parameter will only be set upon object construction\n @G_PARAM_LAX_VALIDATION: upon parameter conversion (see g_param_value_convert())\n strict validation is not required\n @G_PARAM_STATIC_NAME: the string used as name when constructing the\n parameter is guaranteed to remain valid and\n unmodified for the lifetime of the parameter.\n Since 2.8\n @G_PARAM_STATIC_NICK: the string used as nick when constructing the\n parameter is guaranteed to remain valid and\n unmmodified for the lifetime of the parameter.\n Since 2.8\n @G_PARAM_STATIC_BLURB: the string used as blurb when constructing the\n parameter is guaranteed to remain valid and\n unmodified for the lifetime of the parameter.\n Since 2.8\n @G_PARAM_EXPLICIT_NOTIFY: calls to g_object_set_property() for this\n property will not automatically result in a \"notify\" signal being\n emitted: the implementation must call g_object_notify() themselves\n in case the property actually changes. Since: 2.42.\n @G_PARAM_PRIVATE: internal\n @G_PARAM_DEPRECATED: the parameter is deprecated and will be removed\n in a future version. A warning will be generated if it is used\n while running with G_ENABLE_DIAGNOSTIC=1.\n Since 2.26\n\n Through the #GParamFlags flag values, certain aspects of parameters\n can be configured. See also #G_PARAM_READWRITE and #G_PARAM_STATIC_STRINGS."]
pub type GParamFlags = ::std::os::raw::c_int;
#[doc = " GParamSpec:\n @g_type_instance: private #GTypeInstance portion\n @name: name of this parameter: always an interned string\n @flags: #GParamFlags flags for this parameter\n @value_type: the #GValue type for this parameter\n @owner_type: #GType type that uses (introduces) this parameter\n\n All other fields of the GParamSpec struct are private and\n should not be used directly."]
pub type GParamSpec = _GParamSpec;
#[doc = " GParameter:\n @name: the parameter name\n @value: the parameter value\n\n The GParameter struct is an auxiliary structure used\n to hand parameter name/value pairs to g_object_newv()."]
pub type GParameter = _GParameter;
#[doc = " GParamSpec:\n @g_type_instance: private #GTypeInstance portion\n @name: name of this parameter: always an interned string\n @flags: #GParamFlags flags for this parameter\n @value_type: the #GValue type for this parameter\n @owner_type: #GType type that uses (introduces) this parameter\n\n All other fields of the GParamSpec struct are private and\n should not be used directly."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GParamSpec {
pub g_type_instance: GTypeInstance,
pub name: *const gchar,
pub flags: GParamFlags,
pub value_type: GType,
pub owner_type: GType,
pub _nick: *mut gchar,
pub _blurb: *mut gchar,
pub qdata: *mut GData,
pub ref_count: guint,
pub param_id: guint,
}
#[test]
fn bindgen_test_layout__GParamSpec() {
const UNINIT: ::std::mem::MaybeUninit<_GParamSpec> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GParamSpec>(),
72usize,
concat!("Size of: ", stringify!(_GParamSpec))
);
assert_eq!(
::std::mem::align_of::<_GParamSpec>(),
8usize,
concat!("Alignment of ", stringify!(_GParamSpec))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).g_type_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GParamSpec),
"::",
stringify!(g_type_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GParamSpec),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GParamSpec),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value_type) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GParamSpec),
"::",
stringify!(value_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).owner_type) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GParamSpec),
"::",
stringify!(owner_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._nick) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GParamSpec),
"::",
stringify!(_nick)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._blurb) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GParamSpec),
"::",
stringify!(_blurb)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qdata) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GParamSpec),
"::",
stringify!(qdata)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ref_count) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GParamSpec),
"::",
stringify!(ref_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).param_id) as usize - ptr as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(_GParamSpec),
"::",
stringify!(param_id)
)
);
}
impl Default for _GParamSpec {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GParameter:\n @name: the parameter name\n @value: the parameter value\n\n The GParameter struct is an auxiliary structure used\n to hand parameter name/value pairs to g_object_newv()."]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _GParameter {
pub name: *const gchar,
pub value: GValue,
}
#[test]
fn bindgen_test_layout__GParameter() {
const UNINIT: ::std::mem::MaybeUninit<_GParameter> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GParameter>(),
32usize,
concat!("Size of: ", stringify!(_GParameter))
);
assert_eq!(
::std::mem::align_of::<_GParameter>(),
8usize,
concat!("Alignment of ", stringify!(_GParameter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GParameter),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GParameter),
"::",
stringify!(value)
)
);
}
impl Default for _GParameter {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GClosure:\n @in_marshal: Indicates whether the closure is currently being invoked with\n g_closure_invoke()\n @is_invalid: Indicates whether the closure has been invalidated by\n g_closure_invalidate()\n\n A #GClosure represents a callback supplied by the programmer."]
pub type GClosure = _GClosure;
pub type GClosureNotifyData = _GClosureNotifyData;
#[doc = " GCallback:\n\n The type used for callback functions in structure definitions and function\n signatures. This doesn't mean that all callback functions must take no\n parameters and return void. The required signature of a callback function\n is determined by the context in which is used (e.g. the signal to which it\n is connected). Use G_CALLBACK() to cast the callback function to a #GCallback."]
pub type GCallback = ::std::option::Option<unsafe extern "C" fn()>;
#[doc = " GClosureNotify:\n @data: data specified when registering the notification callback\n @closure: the #GClosure on which the notification is emitted\n\n The type used for the various notification callbacks which can be registered\n on closures."]
pub type GClosureNotify =
::std::option::Option<unsafe extern "C" fn(data: gpointer, closure: *mut GClosure)>;
#[doc = " GClosureMarshal:\n @closure: the #GClosure to which the marshaller belongs\n @return_value: (allow-none): a #GValue to store the return\n value. May be %NULL if the callback of @closure doesn't return a\n value.\n @n_param_values: the length of the @param_values array\n @param_values: (array length=n_param_values): an array of\n #GValues holding the arguments on which to invoke the\n callback of @closure\n @invocation_hint: (allow-none): the invocation hint given as the\n last argument to g_closure_invoke()\n @marshal_data: (allow-none): additional data specified when\n registering the marshaller, see g_closure_set_marshal() and\n g_closure_set_meta_marshal()\n\n The type used for marshaller functions."]
pub type GClosureMarshal = ::std::option::Option<
unsafe extern "C" fn(
closure: *mut GClosure,
return_value: *mut GValue,
n_param_values: guint,
param_values: *const GValue,
invocation_hint: gpointer,
marshal_data: gpointer,
),
>;
pub type GVaClosureMarshal = ::std::option::Option<
unsafe extern "C" fn(
closure: *mut GClosure,
return_value: *mut GValue,
instance: gpointer,
args: *mut __va_list_tag,
marshal_data: gpointer,
n_params: ::std::os::raw::c_int,
param_types: *mut GType,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GClosureNotifyData {
pub data: gpointer,
pub notify: GClosureNotify,
}
#[test]
fn bindgen_test_layout__GClosureNotifyData() {
const UNINIT: ::std::mem::MaybeUninit<_GClosureNotifyData> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GClosureNotifyData>(),
16usize,
concat!("Size of: ", stringify!(_GClosureNotifyData))
);
assert_eq!(
::std::mem::align_of::<_GClosureNotifyData>(),
8usize,
concat!("Alignment of ", stringify!(_GClosureNotifyData))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GClosureNotifyData),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).notify) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GClosureNotifyData),
"::",
stringify!(notify)
)
);
}
impl Default for _GClosureNotifyData {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GClosure:\n @in_marshal: Indicates whether the closure is currently being invoked with\n g_closure_invoke()\n @is_invalid: Indicates whether the closure has been invalidated by\n g_closure_invalidate()\n\n A #GClosure represents a callback supplied by the programmer."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GClosure {
pub _bitfield_align_1: [u16; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
pub marshal: ::std::option::Option<
unsafe extern "C" fn(
closure: *mut GClosure,
return_value: *mut GValue,
n_param_values: guint,
param_values: *const GValue,
invocation_hint: gpointer,
marshal_data: gpointer,
),
>,
pub data: gpointer,
pub notifiers: *mut GClosureNotifyData,
}
#[test]
fn bindgen_test_layout__GClosure() {
const UNINIT: ::std::mem::MaybeUninit<_GClosure> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GClosure>(),
32usize,
concat!("Size of: ", stringify!(_GClosure))
);
assert_eq!(
::std::mem::align_of::<_GClosure>(),
8usize,
concat!("Alignment of ", stringify!(_GClosure))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).marshal) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GClosure),
"::",
stringify!(marshal)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GClosure),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).notifiers) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GClosure),
"::",
stringify!(notifiers)
)
);
}
impl Default for _GClosure {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl _GClosure {
#[inline]
pub fn ref_count(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 15u8) as u32) }
}
#[inline]
pub fn set_ref_count(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 15u8, val as u64)
}
}
#[inline]
pub fn meta_marshal_nouse(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
}
#[inline]
pub fn set_meta_marshal_nouse(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(15usize, 1u8, val as u64)
}
}
#[inline]
pub fn n_guards(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
}
#[inline]
pub fn set_n_guards(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(16usize, 1u8, val as u64)
}
}
#[inline]
pub fn n_fnotifiers(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) }
}
#[inline]
pub fn set_n_fnotifiers(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(17usize, 2u8, val as u64)
}
}
#[inline]
pub fn n_inotifiers(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 8u8) as u32) }
}
#[inline]
pub fn set_n_inotifiers(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(19usize, 8u8, val as u64)
}
}
#[inline]
pub fn in_inotify(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
}
#[inline]
pub fn set_in_inotify(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(27usize, 1u8, val as u64)
}
}
#[inline]
pub fn floating(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
}
#[inline]
pub fn set_floating(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(28usize, 1u8, val as u64)
}
}
#[inline]
pub fn derivative_flag(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
}
#[inline]
pub fn set_derivative_flag(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(29usize, 1u8, val as u64)
}
}
#[inline]
pub fn in_marshal(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
}
#[inline]
pub fn set_in_marshal(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(30usize, 1u8, val as u64)
}
}
#[inline]
pub fn is_invalid(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
}
#[inline]
pub fn set_is_invalid(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(31usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
ref_count: guint,
meta_marshal_nouse: guint,
n_guards: guint,
n_fnotifiers: guint,
n_inotifiers: guint,
in_inotify: guint,
floating: guint,
derivative_flag: guint,
in_marshal: guint,
is_invalid: guint,
) -> __BindgenBitfieldUnit<[u8; 4usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 15u8, {
let ref_count: u32 = unsafe { ::std::mem::transmute(ref_count) };
ref_count as u64
});
__bindgen_bitfield_unit.set(15usize, 1u8, {
let meta_marshal_nouse: u32 = unsafe { ::std::mem::transmute(meta_marshal_nouse) };
meta_marshal_nouse as u64
});
__bindgen_bitfield_unit.set(16usize, 1u8, {
let n_guards: u32 = unsafe { ::std::mem::transmute(n_guards) };
n_guards as u64
});
__bindgen_bitfield_unit.set(17usize, 2u8, {
let n_fnotifiers: u32 = unsafe { ::std::mem::transmute(n_fnotifiers) };
n_fnotifiers as u64
});
__bindgen_bitfield_unit.set(19usize, 8u8, {
let n_inotifiers: u32 = unsafe { ::std::mem::transmute(n_inotifiers) };
n_inotifiers as u64
});
__bindgen_bitfield_unit.set(27usize, 1u8, {
let in_inotify: u32 = unsafe { ::std::mem::transmute(in_inotify) };
in_inotify as u64
});
__bindgen_bitfield_unit.set(28usize, 1u8, {
let floating: u32 = unsafe { ::std::mem::transmute(floating) };
floating as u64
});
__bindgen_bitfield_unit.set(29usize, 1u8, {
let derivative_flag: u32 = unsafe { ::std::mem::transmute(derivative_flag) };
derivative_flag as u64
});
__bindgen_bitfield_unit.set(30usize, 1u8, {
let in_marshal: u32 = unsafe { ::std::mem::transmute(in_marshal) };
in_marshal as u64
});
__bindgen_bitfield_unit.set(31usize, 1u8, {
let is_invalid: u32 = unsafe { ::std::mem::transmute(is_invalid) };
is_invalid as u64
});
__bindgen_bitfield_unit
}
}
extern "C" {
pub fn g_signal_type_cclosure_new(itype: GType, struct_offset: guint) -> *mut GClosure;
}
#[doc = " GSignalQuery:\n @signal_id: The signal id of the signal being queried, or 0 if the\n signal to be queried was unknown.\n @signal_name: The signal name.\n @itype: The interface/instance type that this signal can be emitted for.\n @signal_flags: The signal flags as passed in to g_signal_new().\n @return_type: The return type for user callbacks.\n @n_params: The number of parameters that user callbacks take.\n @param_types: (array length=n_params): The individual parameter types for\n user callbacks, note that the effective callback signature is:\n |[<!-- language=\"C\" -->\n @return_type callback (#gpointer data1,\n [param_types param_names,]\n gpointer data2);\n ]|\n\n A structure holding in-depth information for a specific signal. It is\n filled in by the g_signal_query() function."]
pub type GSignalQuery = _GSignalQuery;
#[doc = " GSignalInvocationHint:\n @signal_id: The signal id of the signal invoking the callback\n @detail: The detail passed on for this emission\n @run_type: The stage the signal emission is currently in, this\n field will contain one of %G_SIGNAL_RUN_FIRST,\n %G_SIGNAL_RUN_LAST or %G_SIGNAL_RUN_CLEANUP.\n\n The #GSignalInvocationHint structure is used to pass on additional information\n to callbacks during a signal emission."]
pub type GSignalInvocationHint = _GSignalInvocationHint;
#[doc = " GSignalCMarshaller:\n\n This is the signature of marshaller functions, required to marshall\n arrays of parameter values to signal emissions into C language callback\n invocations. It is merely an alias to #GClosureMarshal since the #GClosure\n mechanism takes over responsibility of actual function invocation for the\n signal system."]
pub type GSignalCMarshaller = GClosureMarshal;
#[doc = " GSignalCVaMarshaller:\n\n This is the signature of va_list marshaller functions, an optional\n marshaller that can be used in some situations to avoid\n marshalling the signal argument into GValues."]
pub type GSignalCVaMarshaller = GVaClosureMarshal;
#[doc = " GSignalEmissionHook:\n @ihint: Signal invocation hint, see #GSignalInvocationHint.\n @n_param_values: the number of parameters to the function, including\n the instance on which the signal was emitted.\n @param_values: (array length=n_param_values): the instance on which\n the signal was emitted, followed by the parameters of the emission.\n @data: user data associated with the hook.\n\n A simple function pointer to get invoked when the signal is emitted. This\n allows you to tie a hook to the signal type, so that it will trap all\n emissions of that signal, from any object.\n\n You may not attach these to signals created with the #G_SIGNAL_NO_HOOKS flag.\n\n Returns: whether it wants to stay connected. If it returns %FALSE, the signal\n hook is disconnected (and destroyed)."]
pub type GSignalEmissionHook = ::std::option::Option<
unsafe extern "C" fn(
ihint: *mut GSignalInvocationHint,
n_param_values: guint,
param_values: *const GValue,
data: gpointer,
) -> gboolean,
>;
#[doc = " GSignalAccumulator:\n @ihint: Signal invocation hint, see #GSignalInvocationHint.\n @return_accu: Accumulator to collect callback return values in, this\n is the return value of the current signal emission.\n @handler_return: A #GValue holding the return value of the signal handler.\n @data: Callback data that was specified when creating the signal.\n\n The signal accumulator is a special callback function that can be used\n to collect return values of the various callbacks that are called\n during a signal emission. The signal accumulator is specified at signal\n creation time, if it is left %NULL, no accumulation of callback return\n values is performed. The return value of signal emissions is then the\n value returned by the last callback.\n\n Returns: The accumulator function returns whether the signal emission\n should be aborted. Returning %FALSE means to abort the\n current emission and %TRUE is returned for continuation."]
pub type GSignalAccumulator = ::std::option::Option<
unsafe extern "C" fn(
ihint: *mut GSignalInvocationHint,
return_accu: *mut GValue,
handler_return: *const GValue,
data: gpointer,
) -> gboolean,
>;
pub const GSignalFlags_G_SIGNAL_RUN_FIRST: GSignalFlags = 1;
pub const GSignalFlags_G_SIGNAL_RUN_LAST: GSignalFlags = 2;
pub const GSignalFlags_G_SIGNAL_RUN_CLEANUP: GSignalFlags = 4;
pub const GSignalFlags_G_SIGNAL_NO_RECURSE: GSignalFlags = 8;
pub const GSignalFlags_G_SIGNAL_DETAILED: GSignalFlags = 16;
pub const GSignalFlags_G_SIGNAL_ACTION: GSignalFlags = 32;
pub const GSignalFlags_G_SIGNAL_NO_HOOKS: GSignalFlags = 64;
pub const GSignalFlags_G_SIGNAL_MUST_COLLECT: GSignalFlags = 128;
pub const GSignalFlags_G_SIGNAL_DEPRECATED: GSignalFlags = 256;
#[doc = " GSignalFlags:\n @G_SIGNAL_RUN_FIRST: Invoke the object method handler in the first emission stage.\n @G_SIGNAL_RUN_LAST: Invoke the object method handler in the third emission stage.\n @G_SIGNAL_RUN_CLEANUP: Invoke the object method handler in the last emission stage.\n @G_SIGNAL_NO_RECURSE: Signals being emitted for an object while currently being in\n emission for this very object will not be emitted recursively,\n but instead cause the first emission to be restarted.\n @G_SIGNAL_DETAILED: This signal supports \"::detail\" appendices to the signal name\n upon handler connections and emissions.\n @G_SIGNAL_ACTION: Action signals are signals that may freely be emitted on alive\n objects from user code via g_signal_emit() and friends, without\n the need of being embedded into extra code that performs pre or\n post emission adjustments on the object. They can also be thought\n of as object methods which can be called generically by\n third-party code.\n @G_SIGNAL_NO_HOOKS: No emissions hooks are supported for this signal.\n @G_SIGNAL_MUST_COLLECT: Varargs signal emission will always collect the\n arguments, even if there are no signal handlers connected. Since 2.30.\n @G_SIGNAL_DEPRECATED: The signal is deprecated and will be removed\n in a future version. A warning will be generated if it is connected while\n running with G_ENABLE_DIAGNOSTIC=1. Since 2.32.\n\n The signal flags are used to specify a signal's behaviour, the overall\n signal description outlines how especially the RUN flags control the\n stages of a signal emission."]
pub type GSignalFlags = ::std::os::raw::c_uint;
pub const GConnectFlags_G_CONNECT_AFTER: GConnectFlags = 1;
pub const GConnectFlags_G_CONNECT_SWAPPED: GConnectFlags = 2;
#[doc = " GConnectFlags:\n @G_CONNECT_AFTER: whether the handler should be called before or after the\n default handler of the signal.\n @G_CONNECT_SWAPPED: whether the instance and data should be swapped when\n calling the handler; see g_signal_connect_swapped() for an example.\n\n The connection flags are used to specify the behaviour of a signal's\n connection."]
pub type GConnectFlags = ::std::os::raw::c_uint;
pub const GSignalMatchType_G_SIGNAL_MATCH_ID: GSignalMatchType = 1;
pub const GSignalMatchType_G_SIGNAL_MATCH_DETAIL: GSignalMatchType = 2;
pub const GSignalMatchType_G_SIGNAL_MATCH_CLOSURE: GSignalMatchType = 4;
pub const GSignalMatchType_G_SIGNAL_MATCH_FUNC: GSignalMatchType = 8;
pub const GSignalMatchType_G_SIGNAL_MATCH_DATA: GSignalMatchType = 16;
pub const GSignalMatchType_G_SIGNAL_MATCH_UNBLOCKED: GSignalMatchType = 32;
#[doc = " GSignalMatchType:\n @G_SIGNAL_MATCH_ID: The signal id must be equal.\n @G_SIGNAL_MATCH_DETAIL: The signal detail be equal.\n @G_SIGNAL_MATCH_CLOSURE: The closure must be the same.\n @G_SIGNAL_MATCH_FUNC: The C closure callback must be the same.\n @G_SIGNAL_MATCH_DATA: The closure data must be the same.\n @G_SIGNAL_MATCH_UNBLOCKED: Only unblocked signals may matched.\n\n The match types specify what g_signal_handlers_block_matched(),\n g_signal_handlers_unblock_matched() and g_signal_handlers_disconnect_matched()\n match signals by."]
pub type GSignalMatchType = ::std::os::raw::c_uint;
#[doc = " GSignalInvocationHint:\n @signal_id: The signal id of the signal invoking the callback\n @detail: The detail passed on for this emission\n @run_type: The stage the signal emission is currently in, this\n field will contain one of %G_SIGNAL_RUN_FIRST,\n %G_SIGNAL_RUN_LAST or %G_SIGNAL_RUN_CLEANUP.\n\n The #GSignalInvocationHint structure is used to pass on additional information\n to callbacks during a signal emission."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GSignalInvocationHint {
pub signal_id: guint,
pub detail: GQuark,
pub run_type: GSignalFlags,
}
#[test]
fn bindgen_test_layout__GSignalInvocationHint() {
const UNINIT: ::std::mem::MaybeUninit<_GSignalInvocationHint> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GSignalInvocationHint>(),
12usize,
concat!("Size of: ", stringify!(_GSignalInvocationHint))
);
assert_eq!(
::std::mem::align_of::<_GSignalInvocationHint>(),
4usize,
concat!("Alignment of ", stringify!(_GSignalInvocationHint))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).signal_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GSignalInvocationHint),
"::",
stringify!(signal_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).detail) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_GSignalInvocationHint),
"::",
stringify!(detail)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).run_type) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GSignalInvocationHint),
"::",
stringify!(run_type)
)
);
}
impl Default for _GSignalInvocationHint {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GSignalQuery:\n @signal_id: The signal id of the signal being queried, or 0 if the\n signal to be queried was unknown.\n @signal_name: The signal name.\n @itype: The interface/instance type that this signal can be emitted for.\n @signal_flags: The signal flags as passed in to g_signal_new().\n @return_type: The return type for user callbacks.\n @n_params: The number of parameters that user callbacks take.\n @param_types: (array length=n_params): The individual parameter types for\n user callbacks, note that the effective callback signature is:\n |[<!-- language=\"C\" -->\n @return_type callback (#gpointer data1,\n [param_types param_names,]\n gpointer data2);\n ]|\n\n A structure holding in-depth information for a specific signal. It is\n filled in by the g_signal_query() function."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GSignalQuery {
pub signal_id: guint,
pub signal_name: *const gchar,
pub itype: GType,
pub signal_flags: GSignalFlags,
pub return_type: GType,
pub n_params: guint,
pub param_types: *const GType,
}
#[test]
fn bindgen_test_layout__GSignalQuery() {
const UNINIT: ::std::mem::MaybeUninit<_GSignalQuery> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GSignalQuery>(),
56usize,
concat!("Size of: ", stringify!(_GSignalQuery))
);
assert_eq!(
::std::mem::align_of::<_GSignalQuery>(),
8usize,
concat!("Alignment of ", stringify!(_GSignalQuery))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).signal_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GSignalQuery),
"::",
stringify!(signal_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).signal_name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GSignalQuery),
"::",
stringify!(signal_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).itype) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GSignalQuery),
"::",
stringify!(itype)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).signal_flags) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GSignalQuery),
"::",
stringify!(signal_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).return_type) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GSignalQuery),
"::",
stringify!(return_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).n_params) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GSignalQuery),
"::",
stringify!(n_params)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).param_types) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GSignalQuery),
"::",
stringify!(param_types)
)
);
}
impl Default for _GSignalQuery {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn g_signal_newv(
signal_name: *const gchar,
itype: GType,
signal_flags: GSignalFlags,
class_closure: *mut GClosure,
accumulator: GSignalAccumulator,
accu_data: gpointer,
c_marshaller: GSignalCMarshaller,
return_type: GType,
n_params: guint,
param_types: *mut GType,
) -> guint;
}
extern "C" {
pub fn g_signal_new(
signal_name: *const gchar,
itype: GType,
signal_flags: GSignalFlags,
class_offset: guint,
accumulator: GSignalAccumulator,
accu_data: gpointer,
c_marshaller: GSignalCMarshaller,
return_type: GType,
n_params: guint,
...
) -> guint;
}
extern "C" {
pub fn g_signal_new_class_handler(
signal_name: *const gchar,
itype: GType,
signal_flags: GSignalFlags,
class_handler: GCallback,
accumulator: GSignalAccumulator,
accu_data: gpointer,
c_marshaller: GSignalCMarshaller,
return_type: GType,
n_params: guint,
...
) -> guint;
}
extern "C" {
pub fn g_signal_set_va_marshaller(
signal_id: guint,
instance_type: GType,
va_marshaller: GSignalCVaMarshaller,
);
}
extern "C" {
pub fn g_signal_emitv(
instance_and_params: *const GValue,
signal_id: guint,
detail: GQuark,
return_value: *mut GValue,
);
}
extern "C" {
pub fn g_signal_emit(instance: gpointer, signal_id: guint, detail: GQuark, ...);
}
extern "C" {
pub fn g_signal_emit_by_name(instance: gpointer, detailed_signal: *const gchar, ...);
}
extern "C" {
pub fn g_signal_lookup(name: *const gchar, itype: GType) -> guint;
}
extern "C" {
pub fn g_signal_name(signal_id: guint) -> *const gchar;
}
extern "C" {
pub fn g_signal_query(signal_id: guint, query: *mut GSignalQuery);
}
extern "C" {
pub fn g_signal_list_ids(itype: GType, n_ids: *mut guint) -> *mut guint;
}
extern "C" {
pub fn g_signal_parse_name(
detailed_signal: *const gchar,
itype: GType,
signal_id_p: *mut guint,
detail_p: *mut GQuark,
force_detail_quark: gboolean,
) -> gboolean;
}
extern "C" {
pub fn g_signal_get_invocation_hint(instance: gpointer) -> *mut GSignalInvocationHint;
}
extern "C" {
pub fn g_signal_stop_emission(instance: gpointer, signal_id: guint, detail: GQuark);
}
extern "C" {
pub fn g_signal_stop_emission_by_name(instance: gpointer, detailed_signal: *const gchar);
}
extern "C" {
pub fn g_signal_add_emission_hook(
signal_id: guint,
detail: GQuark,
hook_func: GSignalEmissionHook,
hook_data: gpointer,
data_destroy: GDestroyNotify,
) -> gulong;
}
extern "C" {
pub fn g_signal_remove_emission_hook(signal_id: guint, hook_id: gulong);
}
extern "C" {
pub fn g_signal_has_handler_pending(
instance: gpointer,
signal_id: guint,
detail: GQuark,
may_be_blocked: gboolean,
) -> gboolean;
}
extern "C" {
pub fn g_signal_connect_closure_by_id(
instance: gpointer,
signal_id: guint,
detail: GQuark,
closure: *mut GClosure,
after: gboolean,
) -> gulong;
}
extern "C" {
pub fn g_signal_connect_closure(
instance: gpointer,
detailed_signal: *const gchar,
closure: *mut GClosure,
after: gboolean,
) -> gulong;
}
extern "C" {
pub fn g_signal_connect_data(
instance: gpointer,
detailed_signal: *const gchar,
c_handler: GCallback,
data: gpointer,
destroy_data: GClosureNotify,
connect_flags: GConnectFlags,
) -> gulong;
}
extern "C" {
pub fn g_signal_handler_block(instance: gpointer, handler_id: gulong);
}
extern "C" {
pub fn g_signal_handler_unblock(instance: gpointer, handler_id: gulong);
}
extern "C" {
pub fn g_signal_handler_disconnect(instance: gpointer, handler_id: gulong);
}
extern "C" {
pub fn g_signal_handler_is_connected(instance: gpointer, handler_id: gulong) -> gboolean;
}
extern "C" {
pub fn g_signal_handler_find(
instance: gpointer,
mask: GSignalMatchType,
signal_id: guint,
detail: GQuark,
closure: *mut GClosure,
func: gpointer,
data: gpointer,
) -> gulong;
}
extern "C" {
pub fn g_signal_handlers_block_matched(
instance: gpointer,
mask: GSignalMatchType,
signal_id: guint,
detail: GQuark,
closure: *mut GClosure,
func: gpointer,
data: gpointer,
) -> guint;
}
extern "C" {
pub fn g_signal_handlers_unblock_matched(
instance: gpointer,
mask: GSignalMatchType,
signal_id: guint,
detail: GQuark,
closure: *mut GClosure,
func: gpointer,
data: gpointer,
) -> guint;
}
extern "C" {
pub fn g_signal_handlers_disconnect_matched(
instance: gpointer,
mask: GSignalMatchType,
signal_id: guint,
detail: GQuark,
closure: *mut GClosure,
func: gpointer,
data: gpointer,
) -> guint;
}
extern "C" {
pub fn g_signal_override_class_closure(
signal_id: guint,
instance_type: GType,
class_closure: *mut GClosure,
);
}
extern "C" {
pub fn g_signal_override_class_handler(
signal_name: *const gchar,
instance_type: GType,
class_handler: GCallback,
);
}
extern "C" {
pub fn g_signal_chain_from_overridden(
instance_and_params: *const GValue,
return_value: *mut GValue,
);
}
extern "C" {
pub fn g_signal_chain_from_overridden_handler(instance: gpointer, ...);
}
extern "C" {
pub fn g_signal_accumulator_true_handled(
ihint: *mut GSignalInvocationHint,
return_accu: *mut GValue,
handler_return: *const GValue,
dummy: gpointer,
) -> gboolean;
}
extern "C" {
pub fn g_signal_accumulator_first_wins(
ihint: *mut GSignalInvocationHint,
return_accu: *mut GValue,
handler_return: *const GValue,
dummy: gpointer,
) -> gboolean;
}
extern "C" {
pub fn g_signal_handlers_destroy(instance: gpointer);
}
extern "C" {
pub fn g_main_context_get_type() -> GType;
}
#[doc = " GObject:\n\n All the fields in the GObject structure are private\n to the #GObject implementation and should never be accessed directly."]
pub type GObject = _GObject;
#[doc = " GObjectClass:\n @g_type_class: the parent class\n @constructor: the @constructor function is called by g_object_new () to\n complete the object initialization after all the construction properties are\n set. The first thing a @constructor implementation must do is chain up to the\n @constructor of the parent class. Overriding @constructor should be rarely\n needed, e.g. to handle construct properties, or to implement singletons.\n @set_property: the generic setter for all properties of this type. Should be\n overridden for every type with properties. If implementations of\n @set_property don't emit property change notification explicitly, this will\n be done implicitly by the type system. However, if the notify signal is\n emitted explicitly, the type system will not emit it a second time.\n @get_property: the generic getter for all properties of this type. Should be\n overridden for every type with properties.\n @dispose: the @dispose function is supposed to drop all references to other\n objects, but keep the instance otherwise intact, so that client method\n invocations still work. It may be run multiple times (due to reference\n loops). Before returning, @dispose should chain up to the @dispose method\n of the parent class.\n @finalize: instance finalization function, should finish the finalization of\n the instance begun in @dispose and chain up to the @finalize method of the\n parent class.\n @dispatch_properties_changed: emits property change notification for a bunch\n of properties. Overriding @dispatch_properties_changed should be rarely\n needed.\n @notify: the class closure for the notify signal\n @constructed: the @constructed function is called by g_object_new() as the\n final step of the object creation process. At the point of the call, all\n construction properties have been set on the object. The purpose of this\n call is to allow for object initialisation steps that can only be performed\n after construction properties have been set. @constructed implementors\n should chain up to the @constructed call of their parent class to allow it\n to complete its initialisation.\n\n The class structure for the GObject type.\n\n <example>\n <title>Implementing singletons using a constructor</title>\n <programlisting>\n static MySingleton *the_singleton = NULL;\n\n static GObject*\n my_singleton_constructor (GType type,\n guint n_construct_params,\n GObjectConstructParam *construct_params)\n {\n GObject *object;\n\n if (!the_singleton)\n {\n object = G_OBJECT_CLASS (parent_class)->constructor (type,\n n_construct_params,\n construct_params);\n the_singleton = MY_SINGLETON (object);\n }\n else\n object = g_object_ref (G_OBJECT (the_singleton));\n\n return object;\n }\n </programlisting></example>"]
pub type GObjectClass = _GObjectClass;
#[doc = " GObject:\n\n All the fields in the GObject structure are private\n to the #GObject implementation and should never be accessed directly."]
pub type GInitiallyUnowned = _GObject;
#[doc = " GObjectClass:\n @g_type_class: the parent class\n @constructor: the @constructor function is called by g_object_new () to\n complete the object initialization after all the construction properties are\n set. The first thing a @constructor implementation must do is chain up to the\n @constructor of the parent class. Overriding @constructor should be rarely\n needed, e.g. to handle construct properties, or to implement singletons.\n @set_property: the generic setter for all properties of this type. Should be\n overridden for every type with properties. If implementations of\n @set_property don't emit property change notification explicitly, this will\n be done implicitly by the type system. However, if the notify signal is\n emitted explicitly, the type system will not emit it a second time.\n @get_property: the generic getter for all properties of this type. Should be\n overridden for every type with properties.\n @dispose: the @dispose function is supposed to drop all references to other\n objects, but keep the instance otherwise intact, so that client method\n invocations still work. It may be run multiple times (due to reference\n loops). Before returning, @dispose should chain up to the @dispose method\n of the parent class.\n @finalize: instance finalization function, should finish the finalization of\n the instance begun in @dispose and chain up to the @finalize method of the\n parent class.\n @dispatch_properties_changed: emits property change notification for a bunch\n of properties. Overriding @dispatch_properties_changed should be rarely\n needed.\n @notify: the class closure for the notify signal\n @constructed: the @constructed function is called by g_object_new() as the\n final step of the object creation process. At the point of the call, all\n construction properties have been set on the object. The purpose of this\n call is to allow for object initialisation steps that can only be performed\n after construction properties have been set. @constructed implementors\n should chain up to the @constructed call of their parent class to allow it\n to complete its initialisation.\n\n The class structure for the GObject type.\n\n <example>\n <title>Implementing singletons using a constructor</title>\n <programlisting>\n static MySingleton *the_singleton = NULL;\n\n static GObject*\n my_singleton_constructor (GType type,\n guint n_construct_params,\n GObjectConstructParam *construct_params)\n {\n GObject *object;\n\n if (!the_singleton)\n {\n object = G_OBJECT_CLASS (parent_class)->constructor (type,\n n_construct_params,\n construct_params);\n the_singleton = MY_SINGLETON (object);\n }\n else\n object = g_object_ref (G_OBJECT (the_singleton));\n\n return object;\n }\n </programlisting></example>"]
pub type GInitiallyUnownedClass = _GObjectClass;
#[doc = " GObjectConstructParam:\n @pspec: the #GParamSpec of the construct parameter\n @value: the value to set the parameter to\n\n The GObjectConstructParam struct is an auxiliary\n structure used to hand #GParamSpec/#GValue pairs to the @constructor of\n a #GObjectClass."]
pub type GObjectConstructParam = _GObjectConstructParam;
#[doc = " GWeakNotify:\n @data: data that was provided when the weak reference was established\n @where_the_object_was: the object being finalized\n\n A #GWeakNotify function can be added to an object as a callback that gets\n triggered when the object is finalized. Since the object is already being\n finalized when the #GWeakNotify is called, there's not much you could do\n with the object, apart from e.g. using its address as hash-index or the like."]
pub type GWeakNotify =
::std::option::Option<unsafe extern "C" fn(data: gpointer, where_the_object_was: *mut GObject)>;
#[doc = " GObject:\n\n All the fields in the GObject structure are private\n to the #GObject implementation and should never be accessed directly."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GObject {
pub g_type_instance: GTypeInstance,
pub ref_count: guint,
pub qdata: *mut GData,
}
#[test]
fn bindgen_test_layout__GObject() {
const UNINIT: ::std::mem::MaybeUninit<_GObject> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GObject>(),
24usize,
concat!("Size of: ", stringify!(_GObject))
);
assert_eq!(
::std::mem::align_of::<_GObject>(),
8usize,
concat!("Alignment of ", stringify!(_GObject))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).g_type_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GObject),
"::",
stringify!(g_type_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ref_count) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GObject),
"::",
stringify!(ref_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qdata) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GObject),
"::",
stringify!(qdata)
)
);
}
impl Default for _GObject {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GObjectClass:\n @g_type_class: the parent class\n @constructor: the @constructor function is called by g_object_new () to\n complete the object initialization after all the construction properties are\n set. The first thing a @constructor implementation must do is chain up to the\n @constructor of the parent class. Overriding @constructor should be rarely\n needed, e.g. to handle construct properties, or to implement singletons.\n @set_property: the generic setter for all properties of this type. Should be\n overridden for every type with properties. If implementations of\n @set_property don't emit property change notification explicitly, this will\n be done implicitly by the type system. However, if the notify signal is\n emitted explicitly, the type system will not emit it a second time.\n @get_property: the generic getter for all properties of this type. Should be\n overridden for every type with properties.\n @dispose: the @dispose function is supposed to drop all references to other\n objects, but keep the instance otherwise intact, so that client method\n invocations still work. It may be run multiple times (due to reference\n loops). Before returning, @dispose should chain up to the @dispose method\n of the parent class.\n @finalize: instance finalization function, should finish the finalization of\n the instance begun in @dispose and chain up to the @finalize method of the\n parent class.\n @dispatch_properties_changed: emits property change notification for a bunch\n of properties. Overriding @dispatch_properties_changed should be rarely\n needed.\n @notify: the class closure for the notify signal\n @constructed: the @constructed function is called by g_object_new() as the\n final step of the object creation process. At the point of the call, all\n construction properties have been set on the object. The purpose of this\n call is to allow for object initialisation steps that can only be performed\n after construction properties have been set. @constructed implementors\n should chain up to the @constructed call of their parent class to allow it\n to complete its initialisation.\n\n The class structure for the GObject type.\n\n <example>\n <title>Implementing singletons using a constructor</title>\n <programlisting>\n static MySingleton *the_singleton = NULL;\n\n static GObject*\n my_singleton_constructor (GType type,\n guint n_construct_params,\n GObjectConstructParam *construct_params)\n {\n GObject *object;\n\n if (!the_singleton)\n {\n object = G_OBJECT_CLASS (parent_class)->constructor (type,\n n_construct_params,\n construct_params);\n the_singleton = MY_SINGLETON (object);\n }\n else\n object = g_object_ref (G_OBJECT (the_singleton));\n\n return object;\n }\n </programlisting></example>"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GObjectClass {
pub g_type_class: GTypeClass,
pub construct_properties: *mut GSList,
pub constructor: ::std::option::Option<
unsafe extern "C" fn(
type_: GType,
n_construct_properties: guint,
construct_properties: *mut GObjectConstructParam,
) -> *mut GObject,
>,
pub set_property: ::std::option::Option<
unsafe extern "C" fn(
object: *mut GObject,
property_id: guint,
value: *const GValue,
pspec: *mut GParamSpec,
),
>,
pub get_property: ::std::option::Option<
unsafe extern "C" fn(
object: *mut GObject,
property_id: guint,
value: *mut GValue,
pspec: *mut GParamSpec,
),
>,
pub dispose: ::std::option::Option<unsafe extern "C" fn(object: *mut GObject)>,
pub finalize: ::std::option::Option<unsafe extern "C" fn(object: *mut GObject)>,
pub dispatch_properties_changed: ::std::option::Option<
unsafe extern "C" fn(object: *mut GObject, n_pspecs: guint, pspecs: *mut *mut GParamSpec),
>,
pub notify:
::std::option::Option<unsafe extern "C" fn(object: *mut GObject, pspec: *mut GParamSpec)>,
pub constructed: ::std::option::Option<unsafe extern "C" fn(object: *mut GObject)>,
pub flags: gsize,
pub pdummy: [gpointer; 6usize],
}
#[test]
fn bindgen_test_layout__GObjectClass() {
const UNINIT: ::std::mem::MaybeUninit<_GObjectClass> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GObjectClass>(),
136usize,
concat!("Size of: ", stringify!(_GObjectClass))
);
assert_eq!(
::std::mem::align_of::<_GObjectClass>(),
8usize,
concat!("Alignment of ", stringify!(_GObjectClass))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).g_type_class) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GObjectClass),
"::",
stringify!(g_type_class)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).construct_properties) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GObjectClass),
"::",
stringify!(construct_properties)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).constructor) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GObjectClass),
"::",
stringify!(constructor)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).set_property) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GObjectClass),
"::",
stringify!(set_property)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_property) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GObjectClass),
"::",
stringify!(get_property)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dispose) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GObjectClass),
"::",
stringify!(dispose)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).finalize) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GObjectClass),
"::",
stringify!(finalize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dispatch_properties_changed) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GObjectClass),
"::",
stringify!(dispatch_properties_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).notify) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GObjectClass),
"::",
stringify!(notify)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).constructed) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_GObjectClass),
"::",
stringify!(constructed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_GObjectClass),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pdummy) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_GObjectClass),
"::",
stringify!(pdummy)
)
);
}
impl Default for _GObjectClass {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GObjectConstructParam:\n @pspec: the #GParamSpec of the construct parameter\n @value: the value to set the parameter to\n\n The GObjectConstructParam struct is an auxiliary\n structure used to hand #GParamSpec/#GValue pairs to the @constructor of\n a #GObjectClass."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GObjectConstructParam {
pub pspec: *mut GParamSpec,
pub value: *mut GValue,
}
#[test]
fn bindgen_test_layout__GObjectConstructParam() {
const UNINIT: ::std::mem::MaybeUninit<_GObjectConstructParam> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GObjectConstructParam>(),
16usize,
concat!("Size of: ", stringify!(_GObjectConstructParam))
);
assert_eq!(
::std::mem::align_of::<_GObjectConstructParam>(),
8usize,
concat!("Alignment of ", stringify!(_GObjectConstructParam))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pspec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GObjectConstructParam),
"::",
stringify!(pspec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GObjectConstructParam),
"::",
stringify!(value)
)
);
}
impl Default for _GObjectConstructParam {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn g_object_class_install_property(
oclass: *mut GObjectClass,
property_id: guint,
pspec: *mut GParamSpec,
);
}
extern "C" {
pub fn g_object_class_find_property(
oclass: *mut GObjectClass,
property_name: *const gchar,
) -> *mut GParamSpec;
}
extern "C" {
pub fn g_object_class_list_properties(
oclass: *mut GObjectClass,
n_properties: *mut guint,
) -> *mut *mut GParamSpec;
}
extern "C" {
pub fn g_object_class_override_property(
oclass: *mut GObjectClass,
property_id: guint,
name: *const gchar,
);
}
extern "C" {
pub fn g_object_class_install_properties(
oclass: *mut GObjectClass,
n_pspecs: guint,
pspecs: *mut *mut GParamSpec,
);
}
extern "C" {
pub fn g_object_interface_install_property(g_iface: gpointer, pspec: *mut GParamSpec);
}
extern "C" {
pub fn g_object_interface_find_property(
g_iface: gpointer,
property_name: *const gchar,
) -> *mut GParamSpec;
}
extern "C" {
pub fn g_object_interface_list_properties(
g_iface: gpointer,
n_properties_p: *mut guint,
) -> *mut *mut GParamSpec;
}
extern "C" {
pub fn g_object_get_type() -> GType;
}
extern "C" {
pub fn g_object_new(object_type: GType, first_property_name: *const gchar, ...) -> gpointer;
}
extern "C" {
pub fn g_object_newv(
object_type: GType,
n_parameters: guint,
parameters: *mut GParameter,
) -> gpointer;
}
extern "C" {
pub fn g_object_set(object: gpointer, first_property_name: *const gchar, ...);
}
extern "C" {
pub fn g_object_get(object: gpointer, first_property_name: *const gchar, ...);
}
extern "C" {
pub fn g_object_connect(object: gpointer, signal_spec: *const gchar, ...) -> gpointer;
}
extern "C" {
pub fn g_object_disconnect(object: gpointer, signal_spec: *const gchar, ...);
}
extern "C" {
pub fn g_object_set_property(
object: *mut GObject,
property_name: *const gchar,
value: *const GValue,
);
}
extern "C" {
pub fn g_object_get_property(
object: *mut GObject,
property_name: *const gchar,
value: *mut GValue,
);
}
extern "C" {
pub fn g_object_freeze_notify(object: *mut GObject);
}
extern "C" {
pub fn g_object_notify(object: *mut GObject, property_name: *const gchar);
}
extern "C" {
pub fn g_object_notify_by_pspec(object: *mut GObject, pspec: *mut GParamSpec);
}
extern "C" {
pub fn g_object_thaw_notify(object: *mut GObject);
}
extern "C" {
pub fn g_object_is_floating(object: gpointer) -> gboolean;
}
extern "C" {
pub fn g_object_ref_sink(object: gpointer) -> gpointer;
}
extern "C" {
pub fn g_object_ref(object: gpointer) -> gpointer;
}
extern "C" {
pub fn g_object_unref(object: gpointer);
}
extern "C" {
pub fn g_object_weak_ref(object: *mut GObject, notify: GWeakNotify, data: gpointer);
}
extern "C" {
pub fn g_object_weak_unref(object: *mut GObject, notify: GWeakNotify, data: gpointer);
}
extern "C" {
pub fn g_object_add_weak_pointer(object: *mut GObject, weak_pointer_location: *mut gpointer);
}
extern "C" {
pub fn g_object_remove_weak_pointer(object: *mut GObject, weak_pointer_location: *mut gpointer);
}
#[doc = " GToggleNotify:\n @data: Callback data passed to g_object_add_toggle_ref()\n @object: The object on which g_object_add_toggle_ref() was called.\n @is_last_ref: %TRUE if the toggle reference is now the\n last reference to the object. %FALSE if the toggle\n reference was the last reference and there are now other\n references.\n\n A callback function used for notification when the state\n of a toggle reference changes. See g_object_add_toggle_ref()."]
pub type GToggleNotify = ::std::option::Option<
unsafe extern "C" fn(data: gpointer, object: *mut GObject, is_last_ref: gboolean),
>;
extern "C" {
pub fn g_object_add_toggle_ref(object: *mut GObject, notify: GToggleNotify, data: gpointer);
}
extern "C" {
pub fn g_object_remove_toggle_ref(object: *mut GObject, notify: GToggleNotify, data: gpointer);
}
extern "C" {
pub fn g_object_get_qdata(object: *mut GObject, quark: GQuark) -> gpointer;
}
extern "C" {
pub fn g_object_set_qdata(object: *mut GObject, quark: GQuark, data: gpointer);
}
extern "C" {
pub fn g_object_set_qdata_full(
object: *mut GObject,
quark: GQuark,
data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn g_object_steal_qdata(object: *mut GObject, quark: GQuark) -> gpointer;
}
extern "C" {
pub fn g_object_dup_qdata(
object: *mut GObject,
quark: GQuark,
dup_func: GDuplicateFunc,
user_data: gpointer,
) -> gpointer;
}
extern "C" {
pub fn g_object_replace_qdata(
object: *mut GObject,
quark: GQuark,
oldval: gpointer,
newval: gpointer,
destroy: GDestroyNotify,
old_destroy: *mut GDestroyNotify,
) -> gboolean;
}
extern "C" {
pub fn g_object_get_data(object: *mut GObject, key: *const gchar) -> gpointer;
}
extern "C" {
pub fn g_object_set_data(object: *mut GObject, key: *const gchar, data: gpointer);
}
extern "C" {
pub fn g_object_set_data_full(
object: *mut GObject,
key: *const gchar,
data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn g_object_steal_data(object: *mut GObject, key: *const gchar) -> gpointer;
}
extern "C" {
pub fn g_object_dup_data(
object: *mut GObject,
key: *const gchar,
dup_func: GDuplicateFunc,
user_data: gpointer,
) -> gpointer;
}
extern "C" {
pub fn g_object_replace_data(
object: *mut GObject,
key: *const gchar,
oldval: gpointer,
newval: gpointer,
destroy: GDestroyNotify,
old_destroy: *mut GDestroyNotify,
) -> gboolean;
}
extern "C" {
pub fn g_object_watch_closure(object: *mut GObject, closure: *mut GClosure);
}
extern "C" {
pub fn g_signal_connect_object(
instance: gpointer,
detailed_signal: *const gchar,
c_handler: GCallback,
gobject: gpointer,
connect_flags: GConnectFlags,
) -> gulong;
}
extern "C" {
pub fn g_object_force_floating(object: *mut GObject);
}
extern "C" {
pub fn g_object_run_dispose(object: *mut GObject);
}
extern "C" {
pub fn g_object_compat_control(what: gsize, data: gpointer) -> gsize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GBinding {
_unused: [u8; 0],
}
#[doc = " GBinding:\n\n GBinding is an opaque structure whose members\n cannot be accessed directly.\n\n Since: 2.26"]
pub type GBinding = _GBinding;
#[doc = " GBindingTransformFunc:\n @binding: a #GBinding\n @from_value: the #GValue containing the value to transform\n @to_value: the #GValue in which to store the transformed value\n @user_data: data passed to the transform function\n\n A function to be called to transform @from_value to @to_value. If\n this is the @transform_to function of a binding, then @from_value\n is the @source_property on the @source object, and @to_value is the\n @target_property on the @target object. If this is the\n @transform_from function of a %G_BINDING_BIDIRECTIONAL binding,\n then those roles are reversed.\n\n Returns: %TRUE if the transformation was successful, and %FALSE\n otherwise\n\n Since: 2.26"]
pub type GBindingTransformFunc = ::std::option::Option<
unsafe extern "C" fn(
binding: *mut GBinding,
from_value: *const GValue,
to_value: *mut GValue,
user_data: gpointer,
) -> gboolean,
>;
pub const GBindingFlags_G_BINDING_DEFAULT: GBindingFlags = 0;
pub const GBindingFlags_G_BINDING_BIDIRECTIONAL: GBindingFlags = 1;
pub const GBindingFlags_G_BINDING_SYNC_CREATE: GBindingFlags = 2;
pub const GBindingFlags_G_BINDING_INVERT_BOOLEAN: GBindingFlags = 4;
#[doc = " GBindingFlags:\n @G_BINDING_DEFAULT: The default binding; if the source property\n changes, the target property is updated with its value.\n @G_BINDING_BIDIRECTIONAL: Bidirectional binding; if either the\n property of the source or the property of the target changes,\n the other is updated.\n @G_BINDING_SYNC_CREATE: Synchronize the values of the source and\n target properties when creating the binding; the direction of\n the synchronization is always from the source to the target.\n @G_BINDING_INVERT_BOOLEAN: If the two properties being bound are\n booleans, setting one to %TRUE will result in the other being\n set to %FALSE and vice versa. This flag will only work for\n boolean properties, and cannot be used when passing custom\n transformation functions to g_object_bind_property_full().\n\n Flags to be passed to g_object_bind_property() or\n g_object_bind_property_full().\n\n This enumeration can be extended at later date.\n\n Since: 2.26"]
pub type GBindingFlags = ::std::os::raw::c_uint;
extern "C" {
pub fn g_object_bind_property(
source: gpointer,
source_property: *const gchar,
target: gpointer,
target_property: *const gchar,
flags: GBindingFlags,
) -> *mut GBinding;
}
extern "C" {
pub fn g_object_bind_property_full(
source: gpointer,
source_property: *const gchar,
target: gpointer,
target_property: *const gchar,
flags: GBindingFlags,
transform_to: GBindingTransformFunc,
transform_from: GBindingTransformFunc,
user_data: gpointer,
notify: GDestroyNotify,
) -> *mut GBinding;
}
extern "C" {
pub fn g_object_bind_property_with_closures(
source: gpointer,
source_property: *const gchar,
target: gpointer,
target_property: *const gchar,
flags: GBindingFlags,
transform_to: *mut GClosure,
transform_from: *mut GClosure,
) -> *mut GBinding;
}
pub const GApplicationFlags_G_APPLICATION_FLAGS_NONE: GApplicationFlags = 0;
pub const GApplicationFlags_G_APPLICATION_IS_SERVICE: GApplicationFlags = 1;
pub const GApplicationFlags_G_APPLICATION_IS_LAUNCHER: GApplicationFlags = 2;
pub const GApplicationFlags_G_APPLICATION_HANDLES_OPEN: GApplicationFlags = 4;
pub const GApplicationFlags_G_APPLICATION_HANDLES_COMMAND_LINE: GApplicationFlags = 8;
pub const GApplicationFlags_G_APPLICATION_SEND_ENVIRONMENT: GApplicationFlags = 16;
pub const GApplicationFlags_G_APPLICATION_NON_UNIQUE: GApplicationFlags = 32;
#[doc = " GApplicationFlags:\n @G_APPLICATION_FLAGS_NONE: Default\n @G_APPLICATION_IS_SERVICE: Run as a service. In this mode, registration\n fails if the service is already running, and the application\n will initially wait up to 10 seconds for an initial activation\n message to arrive.\n @G_APPLICATION_IS_LAUNCHER: Don't try to become the primary instance.\n @G_APPLICATION_HANDLES_OPEN: This application handles opening files (in\n the primary instance). Note that this flag only affects the default\n implementation of local_command_line(), and has no effect if\n %G_APPLICATION_HANDLES_COMMAND_LINE is given.\n See g_application_run() for details.\n @G_APPLICATION_HANDLES_COMMAND_LINE: This application handles command line\n arguments (in the primary instance). Note that this flag only affect\n the default implementation of local_command_line().\n See g_application_run() for details.\n @G_APPLICATION_SEND_ENVIRONMENT: Send the environment of the\n launching process to the primary instance. Set this flag if your\n application is expected to behave differently depending on certain\n environment variables. For instance, an editor might be expected\n to use the <envar>GIT_COMMITTER_NAME</envar> environment variable\n when editing a git commit message. The environment is available\n to the #GApplication::command-line signal handler, via\n g_application_command_line_getenv().\n @G_APPLICATION_NON_UNIQUE: Make no attempts to do any of the typical\n single-instance application negotiation, even if the application\n ID is given. The application neither attempts to become the\n owner of the application ID nor does it check if an existing\n owner already exists. Everything occurs in the local process.\n Since: 2.30.\n\n Flags used to define the behaviour of a #GApplication.\n\n Since: 2.28"]
pub type GApplicationFlags = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GAppInfo {
_unused: [u8; 0],
}
pub type GAppInfo = _GAppInfo;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GAsyncResult {
_unused: [u8; 0],
}
pub type GAsyncResult = _GAsyncResult;
pub type GCancellable = _GCancellable;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GActionGroup {
_unused: [u8; 0],
}
pub type GActionGroup = _GActionGroup;
#[doc = " GApplication:\n\n Since: 2.28"]
pub type GApplication = _GApplication;
pub type GApplicationCommandLine = _GApplicationCommandLine;
pub type GPermission = _GPermission;
pub type GMenuModel = _GMenuModel;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GNotification {
_unused: [u8; 0],
}
pub type GNotification = _GNotification;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GFile {
_unused: [u8; 0],
}
#[doc = " GFile:\n\n A handle to an object implementing the #GFileIface interface.\n Generally stores a location within the file system. Handles do not\n necessarily represent files or directories that currently exist."]
pub type GFile = _GFile;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GIcon {
_unused: [u8; 0],
}
pub type GIcon = _GIcon;
pub type GInputStream = _GInputStream;
pub type GMemoryInputStream = _GMemoryInputStream;
pub type GMountOperation = _GMountOperation;
#[doc = " GAsyncReadyCallback:\n @source_object: the object the asynchronous operation was started with.\n @res: a #GAsyncResult.\n @user_data: user data passed to the callback.\n\n Type definition for a function that will be called back when an asynchronous\n operation within GIO has been completed."]
pub type GAsyncReadyCallback = ::std::option::Option<
unsafe extern "C" fn(source_object: *mut GObject, res: *mut GAsyncResult, user_data: gpointer),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GDBusConnection {
_unused: [u8; 0],
}
pub type GDBusConnection = _GDBusConnection;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GApplicationPrivate {
_unused: [u8; 0],
}
pub type GApplicationPrivate = _GApplicationPrivate;
#[doc = " GApplication:\n\n Since: 2.28"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GApplication {
pub parent_instance: GObject,
pub priv_: *mut GApplicationPrivate,
}
#[test]
fn bindgen_test_layout__GApplication() {
const UNINIT: ::std::mem::MaybeUninit<_GApplication> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GApplication>(),
32usize,
concat!("Size of: ", stringify!(_GApplication))
);
assert_eq!(
::std::mem::align_of::<_GApplication>(),
8usize,
concat!("Alignment of ", stringify!(_GApplication))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GApplication),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GApplication),
"::",
stringify!(priv_)
)
);
}
impl Default for _GApplication {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn g_application_get_type() -> GType;
}
extern "C" {
pub fn g_application_id_is_valid(application_id: *const gchar) -> gboolean;
}
extern "C" {
pub fn g_application_new(
application_id: *const gchar,
flags: GApplicationFlags,
) -> *mut GApplication;
}
extern "C" {
pub fn g_application_get_application_id(application: *mut GApplication) -> *const gchar;
}
extern "C" {
pub fn g_application_set_application_id(
application: *mut GApplication,
application_id: *const gchar,
);
}
extern "C" {
pub fn g_application_get_dbus_connection(
application: *mut GApplication,
) -> *mut GDBusConnection;
}
extern "C" {
pub fn g_application_get_dbus_object_path(application: *mut GApplication) -> *const gchar;
}
extern "C" {
pub fn g_application_get_inactivity_timeout(application: *mut GApplication) -> guint;
}
extern "C" {
pub fn g_application_set_inactivity_timeout(
application: *mut GApplication,
inactivity_timeout: guint,
);
}
extern "C" {
pub fn g_application_get_flags(application: *mut GApplication) -> GApplicationFlags;
}
extern "C" {
pub fn g_application_set_flags(application: *mut GApplication, flags: GApplicationFlags);
}
extern "C" {
pub fn g_application_get_resource_base_path(application: *mut GApplication) -> *const gchar;
}
extern "C" {
pub fn g_application_set_resource_base_path(
application: *mut GApplication,
resource_path: *const gchar,
);
}
extern "C" {
pub fn g_application_set_action_group(
application: *mut GApplication,
action_group: *mut GActionGroup,
);
}
extern "C" {
pub fn g_application_add_main_option_entries(
application: *mut GApplication,
entries: *const GOptionEntry,
);
}
extern "C" {
pub fn g_application_add_main_option(
application: *mut GApplication,
long_name: *const ::std::os::raw::c_char,
short_name: ::std::os::raw::c_char,
flags: GOptionFlags,
arg: GOptionArg,
description: *const ::std::os::raw::c_char,
arg_description: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn g_application_add_option_group(application: *mut GApplication, group: *mut GOptionGroup);
}
extern "C" {
pub fn g_application_get_is_registered(application: *mut GApplication) -> gboolean;
}
extern "C" {
pub fn g_application_get_is_remote(application: *mut GApplication) -> gboolean;
}
extern "C" {
pub fn g_application_register(
application: *mut GApplication,
cancellable: *mut GCancellable,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn g_application_hold(application: *mut GApplication);
}
extern "C" {
pub fn g_application_release(application: *mut GApplication);
}
extern "C" {
pub fn g_application_activate(application: *mut GApplication);
}
extern "C" {
pub fn g_application_open(
application: *mut GApplication,
files: *mut *mut GFile,
n_files: gint,
hint: *const gchar,
);
}
extern "C" {
pub fn g_application_run(
application: *mut GApplication,
argc: ::std::os::raw::c_int,
argv: *mut *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn g_application_quit(application: *mut GApplication);
}
extern "C" {
pub fn g_application_get_default() -> *mut GApplication;
}
extern "C" {
pub fn g_application_set_default(application: *mut GApplication);
}
extern "C" {
pub fn g_application_mark_busy(application: *mut GApplication);
}
extern "C" {
pub fn g_application_unmark_busy(application: *mut GApplication);
}
extern "C" {
pub fn g_application_send_notification(
application: *mut GApplication,
id: *const gchar,
notification: *mut GNotification,
);
}
extern "C" {
pub fn g_application_withdraw_notification(application: *mut GApplication, id: *const gchar);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GApplicationCommandLinePrivate {
_unused: [u8; 0],
}
pub type GApplicationCommandLinePrivate = _GApplicationCommandLinePrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GApplicationCommandLine {
pub parent_instance: GObject,
pub priv_: *mut GApplicationCommandLinePrivate,
}
#[test]
fn bindgen_test_layout__GApplicationCommandLine() {
const UNINIT: ::std::mem::MaybeUninit<_GApplicationCommandLine> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GApplicationCommandLine>(),
32usize,
concat!("Size of: ", stringify!(_GApplicationCommandLine))
);
assert_eq!(
::std::mem::align_of::<_GApplicationCommandLine>(),
8usize,
concat!("Alignment of ", stringify!(_GApplicationCommandLine))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GApplicationCommandLine),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GApplicationCommandLine),
"::",
stringify!(priv_)
)
);
}
impl Default for _GApplicationCommandLine {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn g_application_command_line_get_type() -> GType;
}
extern "C" {
pub fn g_application_command_line_get_arguments(
cmdline: *mut GApplicationCommandLine,
argc: *mut ::std::os::raw::c_int,
) -> *mut *mut gchar;
}
extern "C" {
pub fn g_application_command_line_get_options_dict(
cmdline: *mut GApplicationCommandLine,
) -> *mut GVariantDict;
}
extern "C" {
pub fn g_application_command_line_get_stdin(
cmdline: *mut GApplicationCommandLine,
) -> *mut GInputStream;
}
extern "C" {
pub fn g_application_command_line_get_environ(
cmdline: *mut GApplicationCommandLine,
) -> *const *const gchar;
}
extern "C" {
pub fn g_application_command_line_getenv(
cmdline: *mut GApplicationCommandLine,
name: *const gchar,
) -> *const gchar;
}
extern "C" {
pub fn g_application_command_line_get_cwd(
cmdline: *mut GApplicationCommandLine,
) -> *const gchar;
}
extern "C" {
pub fn g_application_command_line_get_is_remote(
cmdline: *mut GApplicationCommandLine,
) -> gboolean;
}
extern "C" {
pub fn g_application_command_line_print(
cmdline: *mut GApplicationCommandLine,
format: *const gchar,
...
);
}
extern "C" {
pub fn g_application_command_line_printerr(
cmdline: *mut GApplicationCommandLine,
format: *const gchar,
...
);
}
extern "C" {
pub fn g_application_command_line_get_exit_status(
cmdline: *mut GApplicationCommandLine,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn g_application_command_line_set_exit_status(
cmdline: *mut GApplicationCommandLine,
exit_status: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn g_application_command_line_get_platform_data(
cmdline: *mut GApplicationCommandLine,
) -> *mut GVariant;
}
extern "C" {
pub fn g_application_command_line_create_file_for_arg(
cmdline: *mut GApplicationCommandLine,
arg: *const gchar,
) -> *mut GFile;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GInputStreamPrivate {
_unused: [u8; 0],
}
pub type GInputStreamPrivate = _GInputStreamPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GInputStream {
pub parent_instance: GObject,
pub priv_: *mut GInputStreamPrivate,
}
#[test]
fn bindgen_test_layout__GInputStream() {
const UNINIT: ::std::mem::MaybeUninit<_GInputStream> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GInputStream>(),
32usize,
concat!("Size of: ", stringify!(_GInputStream))
);
assert_eq!(
::std::mem::align_of::<_GInputStream>(),
8usize,
concat!("Alignment of ", stringify!(_GInputStream))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GInputStream),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GInputStream),
"::",
stringify!(priv_)
)
);
}
impl Default for _GInputStream {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GCancellablePrivate {
_unused: [u8; 0],
}
pub type GCancellablePrivate = _GCancellablePrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GCancellable {
pub parent_instance: GObject,
pub priv_: *mut GCancellablePrivate,
}
#[test]
fn bindgen_test_layout__GCancellable() {
const UNINIT: ::std::mem::MaybeUninit<_GCancellable> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GCancellable>(),
32usize,
concat!("Size of: ", stringify!(_GCancellable))
);
assert_eq!(
::std::mem::align_of::<_GCancellable>(),
8usize,
concat!("Alignment of ", stringify!(_GCancellable))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GCancellable),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GCancellable),
"::",
stringify!(priv_)
)
);
}
impl Default for _GCancellable {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GEmblemedIcon:\n\n An implementation of #GIcon for icons with emblems."]
pub type GEmblemedIcon = _GEmblemedIcon;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GEmblemedIconPrivate {
_unused: [u8; 0],
}
pub type GEmblemedIconPrivate = _GEmblemedIconPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GEmblemedIcon {
pub parent_instance: GObject,
pub priv_: *mut GEmblemedIconPrivate,
}
#[test]
fn bindgen_test_layout__GEmblemedIcon() {
const UNINIT: ::std::mem::MaybeUninit<_GEmblemedIcon> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GEmblemedIcon>(),
32usize,
concat!("Size of: ", stringify!(_GEmblemedIcon))
);
assert_eq!(
::std::mem::align_of::<_GEmblemedIcon>(),
8usize,
concat!("Alignment of ", stringify!(_GEmblemedIcon))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GEmblemedIcon),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GEmblemedIcon),
"::",
stringify!(priv_)
)
);
}
impl Default for _GEmblemedIcon {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn g_application_flags_get_type() -> GType;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GMemoryInputStreamPrivate {
_unused: [u8; 0],
}
pub type GMemoryInputStreamPrivate = _GMemoryInputStreamPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GMemoryInputStream {
pub parent_instance: GInputStream,
pub priv_: *mut GMemoryInputStreamPrivate,
}
#[test]
fn bindgen_test_layout__GMemoryInputStream() {
const UNINIT: ::std::mem::MaybeUninit<_GMemoryInputStream> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GMemoryInputStream>(),
40usize,
concat!("Size of: ", stringify!(_GMemoryInputStream))
);
assert_eq!(
::std::mem::align_of::<_GMemoryInputStream>(),
8usize,
concat!("Alignment of ", stringify!(_GMemoryInputStream))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GMemoryInputStream),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GMemoryInputStream),
"::",
stringify!(priv_)
)
);
}
impl Default for _GMemoryInputStream {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn g_memory_input_stream_get_type() -> GType;
}
extern "C" {
pub fn g_memory_input_stream_new() -> *mut GInputStream;
}
extern "C" {
pub fn g_memory_input_stream_new_from_data(
data: *const ::std::os::raw::c_void,
len: gssize,
destroy: GDestroyNotify,
) -> *mut GInputStream;
}
extern "C" {
pub fn g_memory_input_stream_new_from_bytes(bytes: *mut GBytes) -> *mut GInputStream;
}
extern "C" {
pub fn g_memory_input_stream_add_data(
stream: *mut GMemoryInputStream,
data: *const ::std::os::raw::c_void,
len: gssize,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn g_memory_input_stream_add_bytes(stream: *mut GMemoryInputStream, bytes: *mut GBytes);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GMountOperationPrivate {
_unused: [u8; 0],
}
pub type GMountOperationPrivate = _GMountOperationPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GMountOperation {
pub parent_instance: GObject,
pub priv_: *mut GMountOperationPrivate,
}
#[test]
fn bindgen_test_layout__GMountOperation() {
const UNINIT: ::std::mem::MaybeUninit<_GMountOperation> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GMountOperation>(),
32usize,
concat!("Size of: ", stringify!(_GMountOperation))
);
assert_eq!(
::std::mem::align_of::<_GMountOperation>(),
8usize,
concat!("Alignment of ", stringify!(_GMountOperation))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GMountOperation),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GMountOperation),
"::",
stringify!(priv_)
)
);
}
impl Default for _GMountOperation {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GPermissionPrivate {
_unused: [u8; 0],
}
pub type GPermissionPrivate = _GPermissionPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GPermission {
pub parent_instance: GObject,
pub priv_: *mut GPermissionPrivate,
}
#[test]
fn bindgen_test_layout__GPermission() {
const UNINIT: ::std::mem::MaybeUninit<_GPermission> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GPermission>(),
32usize,
concat!("Size of: ", stringify!(_GPermission))
);
assert_eq!(
::std::mem::align_of::<_GPermission>(),
8usize,
concat!("Alignment of ", stringify!(_GPermission))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GPermission),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GPermission),
"::",
stringify!(priv_)
)
);
}
impl Default for _GPermission {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GMenuModelPrivate {
_unused: [u8; 0],
}
pub type GMenuModelPrivate = _GMenuModelPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GMenuModel {
pub parent_instance: GObject,
pub priv_: *mut GMenuModelPrivate,
}
#[test]
fn bindgen_test_layout__GMenuModel() {
const UNINIT: ::std::mem::MaybeUninit<_GMenuModel> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GMenuModel>(),
32usize,
concat!("Size of: ", stringify!(_GMenuModel))
);
assert_eq!(
::std::mem::align_of::<_GMenuModel>(),
8usize,
concat!("Alignment of ", stringify!(_GMenuModel))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GMenuModel),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GMenuModel),
"::",
stringify!(priv_)
)
);
}
impl Default for _GMenuModel {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GMenu {
_unused: [u8; 0],
}
pub type GMenu = _GMenu;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _PangoFontMap {
_unused: [u8; 0],
}
pub type PangoFontMap = _PangoFontMap;
#[doc = " PangoRectangle:\n @x: X coordinate of the left side of the rectangle.\n @y: Y coordinate of the the top side of the rectangle.\n @width: width of the rectangle.\n @height: height of the rectangle.\n\n The #PangoRectangle structure represents a rectangle. It is frequently\n used to represent the logical or ink extents of a single glyph or section\n of text. (See, for instance, pango_font_get_glyph_extents())\n"]
pub type PangoRectangle = _PangoRectangle;
#[doc = " PangoRectangle:\n @x: X coordinate of the left side of the rectangle.\n @y: Y coordinate of the the top side of the rectangle.\n @width: width of the rectangle.\n @height: height of the rectangle.\n\n The #PangoRectangle structure represents a rectangle. It is frequently\n used to represent the logical or ink extents of a single glyph or section\n of text. (See, for instance, pango_font_get_glyph_extents())\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _PangoRectangle {
pub x: ::std::os::raw::c_int,
pub y: ::std::os::raw::c_int,
pub width: ::std::os::raw::c_int,
pub height: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__PangoRectangle() {
const UNINIT: ::std::mem::MaybeUninit<_PangoRectangle> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_PangoRectangle>(),
16usize,
concat!("Size of: ", stringify!(_PangoRectangle))
);
assert_eq!(
::std::mem::align_of::<_PangoRectangle>(),
4usize,
concat!("Alignment of ", stringify!(_PangoRectangle))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_PangoRectangle),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_PangoRectangle),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_PangoRectangle),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_PangoRectangle),
"::",
stringify!(height)
)
);
}
pub const PangoGravity_PANGO_GRAVITY_SOUTH: PangoGravity = 0;
pub const PangoGravity_PANGO_GRAVITY_EAST: PangoGravity = 1;
pub const PangoGravity_PANGO_GRAVITY_NORTH: PangoGravity = 2;
pub const PangoGravity_PANGO_GRAVITY_WEST: PangoGravity = 3;
pub const PangoGravity_PANGO_GRAVITY_AUTO: PangoGravity = 4;
#[doc = " PangoGravity:\n @PANGO_GRAVITY_SOUTH: Glyphs stand upright (default)\n @PANGO_GRAVITY_EAST: Glyphs are rotated 90 degrees clockwise\n @PANGO_GRAVITY_NORTH: Glyphs are upside-down\n @PANGO_GRAVITY_WEST: Glyphs are rotated 90 degrees counter-clockwise\n @PANGO_GRAVITY_AUTO: Gravity is resolved from the context matrix\n\n The #PangoGravity type represents the orientation of glyphs in a segment\n of text. This is useful when rendering vertical text layouts. In\n those situations, the layout is rotated using a non-identity PangoMatrix,\n and then glyph orientation is controlled using #PangoGravity.\n Not every value in this enumeration makes sense for every usage of\n #PangoGravity; for example, %PANGO_GRAVITY_AUTO only can be passed to\n pango_context_set_base_gravity() and can only be returned by\n pango_context_get_base_gravity().\n\n See also: #PangoGravityHint\n\n Since: 1.16"]
pub type PangoGravity = ::std::os::raw::c_uint;
pub const PangoGravityHint_PANGO_GRAVITY_HINT_NATURAL: PangoGravityHint = 0;
pub const PangoGravityHint_PANGO_GRAVITY_HINT_STRONG: PangoGravityHint = 1;
pub const PangoGravityHint_PANGO_GRAVITY_HINT_LINE: PangoGravityHint = 2;
#[doc = " PangoGravityHint:\n @PANGO_GRAVITY_HINT_NATURAL: scripts will take their natural gravity based\n on the base gravity and the script. This is the default.\n @PANGO_GRAVITY_HINT_STRONG: always use the base gravity set, regardless of\n the script.\n @PANGO_GRAVITY_HINT_LINE: for scripts not in their natural direction (eg.\n Latin in East gravity), choose per-script gravity such that every script\n respects the line progression. This means, Latin and Arabic will take\n opposite gravities and both flow top-to-bottom for example.\n\n The #PangoGravityHint defines how horizontal scripts should behave in a\n vertical context. That is, English excerpt in a vertical paragraph for\n example.\n\n See #PangoGravity.\n\n Since: 1.16"]
pub type PangoGravityHint = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _PangoLanguage {
_unused: [u8; 0],
}
pub type PangoLanguage = _PangoLanguage;
pub const PangoDirection_PANGO_DIRECTION_LTR: PangoDirection = 0;
pub const PangoDirection_PANGO_DIRECTION_RTL: PangoDirection = 1;
pub const PangoDirection_PANGO_DIRECTION_TTB_LTR: PangoDirection = 2;
pub const PangoDirection_PANGO_DIRECTION_TTB_RTL: PangoDirection = 3;
pub const PangoDirection_PANGO_DIRECTION_WEAK_LTR: PangoDirection = 4;
pub const PangoDirection_PANGO_DIRECTION_WEAK_RTL: PangoDirection = 5;
pub const PangoDirection_PANGO_DIRECTION_NEUTRAL: PangoDirection = 6;
#[doc = " PangoDirection:\n @PANGO_DIRECTION_LTR: A strong left-to-right direction\n @PANGO_DIRECTION_RTL: A strong right-to-left direction\n @PANGO_DIRECTION_TTB_LTR: Deprecated value; treated the\n same as %PANGO_DIRECTION_RTL.\n @PANGO_DIRECTION_TTB_RTL: Deprecated value; treated the\n same as %PANGO_DIRECTION_LTR\n @PANGO_DIRECTION_WEAK_LTR: A weak left-to-right direction\n @PANGO_DIRECTION_WEAK_RTL: A weak right-to-left direction\n @PANGO_DIRECTION_NEUTRAL: No direction specified\n\n The #PangoDirection type represents a direction in the\n Unicode bidirectional algorithm; not every value in this\n enumeration makes sense for every usage of #PangoDirection;\n for example, the return value of pango_unichar_direction()\n and pango_find_base_dir() cannot be %PANGO_DIRECTION_WEAK_LTR\n or %PANGO_DIRECTION_WEAK_RTL, since every character is either\n neutral or has a strong direction; on the other hand\n %PANGO_DIRECTION_NEUTRAL doesn't make sense to pass\n to pango_itemize_with_base_dir().\n\n The %PANGO_DIRECTION_TTB_LTR, %PANGO_DIRECTION_TTB_RTL\n values come from an earlier interpretation of this\n enumeration as the writing direction of a block of\n text and are no longer used; See #PangoGravity for how\n vertical text is handled in Pango."]
pub type PangoDirection = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _PangoFontDescription {
_unused: [u8; 0],
}
#[doc = " PangoFontDescription:\n\n The #PangoFontDescription structure represents the description\n of an ideal font. These structures are used both to list\n what fonts are available on the system and also for specifying\n the characteristics of a font to load."]
pub type PangoFontDescription = _PangoFontDescription;
pub const PangoStyle_PANGO_STYLE_NORMAL: PangoStyle = 0;
pub const PangoStyle_PANGO_STYLE_OBLIQUE: PangoStyle = 1;
pub const PangoStyle_PANGO_STYLE_ITALIC: PangoStyle = 2;
#[doc = " PangoStyle:\n @PANGO_STYLE_NORMAL: the font is upright.\n @PANGO_STYLE_OBLIQUE: the font is slanted, but in a roman style.\n @PANGO_STYLE_ITALIC: the font is slanted in an italic style.\n\n An enumeration specifying the various slant styles possible for a font."]
pub type PangoStyle = ::std::os::raw::c_uint;
pub const PangoVariant_PANGO_VARIANT_NORMAL: PangoVariant = 0;
pub const PangoVariant_PANGO_VARIANT_SMALL_CAPS: PangoVariant = 1;
#[doc = " PangoVariant:\n @PANGO_VARIANT_NORMAL: A normal font.\n @PANGO_VARIANT_SMALL_CAPS: A font with the lower case characters\n replaced by smaller variants of the capital characters.\n\n An enumeration specifying capitalization variant of the font."]
pub type PangoVariant = ::std::os::raw::c_uint;
pub const PangoWeight_PANGO_WEIGHT_THIN: PangoWeight = 100;
pub const PangoWeight_PANGO_WEIGHT_ULTRALIGHT: PangoWeight = 200;
pub const PangoWeight_PANGO_WEIGHT_LIGHT: PangoWeight = 300;
pub const PangoWeight_PANGO_WEIGHT_SEMILIGHT: PangoWeight = 350;
pub const PangoWeight_PANGO_WEIGHT_BOOK: PangoWeight = 380;
pub const PangoWeight_PANGO_WEIGHT_NORMAL: PangoWeight = 400;
pub const PangoWeight_PANGO_WEIGHT_MEDIUM: PangoWeight = 500;
pub const PangoWeight_PANGO_WEIGHT_SEMIBOLD: PangoWeight = 600;
pub const PangoWeight_PANGO_WEIGHT_BOLD: PangoWeight = 700;
pub const PangoWeight_PANGO_WEIGHT_ULTRABOLD: PangoWeight = 800;
pub const PangoWeight_PANGO_WEIGHT_HEAVY: PangoWeight = 900;
pub const PangoWeight_PANGO_WEIGHT_ULTRAHEAVY: PangoWeight = 1000;
#[doc = " PangoWeight:\n @PANGO_WEIGHT_THIN: the thin weight (= 100; Since: 1.24)\n @PANGO_WEIGHT_ULTRALIGHT: the ultralight weight (= 200)\n @PANGO_WEIGHT_LIGHT: the light weight (= 300)\n @PANGO_WEIGHT_SEMILIGHT: the semilight weight (= 350; Since: 1.36.7)\n @PANGO_WEIGHT_BOOK: the book weight (= 380; Since: 1.24)\n @PANGO_WEIGHT_NORMAL: the default weight (= 400)\n @PANGO_WEIGHT_MEDIUM: the normal weight (= 500; Since: 1.24)\n @PANGO_WEIGHT_SEMIBOLD: the semibold weight (= 600)\n @PANGO_WEIGHT_BOLD: the bold weight (= 700)\n @PANGO_WEIGHT_ULTRABOLD: the ultrabold weight (= 800)\n @PANGO_WEIGHT_HEAVY: the heavy weight (= 900)\n @PANGO_WEIGHT_ULTRAHEAVY: the ultraheavy weight (= 1000; Since: 1.24)\n\n An enumeration specifying the weight (boldness) of a font. This is a numerical\n value ranging from 100 to 1000, but there are some predefined values:"]
pub type PangoWeight = ::std::os::raw::c_uint;
pub const PangoStretch_PANGO_STRETCH_ULTRA_CONDENSED: PangoStretch = 0;
pub const PangoStretch_PANGO_STRETCH_EXTRA_CONDENSED: PangoStretch = 1;
pub const PangoStretch_PANGO_STRETCH_CONDENSED: PangoStretch = 2;
pub const PangoStretch_PANGO_STRETCH_SEMI_CONDENSED: PangoStretch = 3;
pub const PangoStretch_PANGO_STRETCH_NORMAL: PangoStretch = 4;
pub const PangoStretch_PANGO_STRETCH_SEMI_EXPANDED: PangoStretch = 5;
pub const PangoStretch_PANGO_STRETCH_EXPANDED: PangoStretch = 6;
pub const PangoStretch_PANGO_STRETCH_EXTRA_EXPANDED: PangoStretch = 7;
pub const PangoStretch_PANGO_STRETCH_ULTRA_EXPANDED: PangoStretch = 8;
#[doc = " PangoStretch:\n @PANGO_STRETCH_ULTRA_CONDENSED: ultra condensed width\n @PANGO_STRETCH_EXTRA_CONDENSED: extra condensed width\n @PANGO_STRETCH_CONDENSED: condensed width\n @PANGO_STRETCH_SEMI_CONDENSED: semi condensed width\n @PANGO_STRETCH_NORMAL: the normal width\n @PANGO_STRETCH_SEMI_EXPANDED: semi expanded width\n @PANGO_STRETCH_EXPANDED: expanded width\n @PANGO_STRETCH_EXTRA_EXPANDED: extra expanded width\n @PANGO_STRETCH_ULTRA_EXPANDED: ultra expanded width\n\n An enumeration specifying the width of the font relative to other designs\n within a family."]
pub type PangoStretch = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _PangoFontFamily {
_unused: [u8; 0],
}
pub type PangoFontFamily = _PangoFontFamily;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _PangoFontFace {
_unused: [u8; 0],
}
pub type PangoFontFace = _PangoFontFace;
#[doc = " PangoAttribute:\n @klass: the class structure holding information about the type of the attribute\n @start_index: the start index of the range (in bytes).\n @end_index: end index of the range (in bytes). The character at this index\n is not included in the range.\n\n The #PangoAttribute structure represents the common portions of all\n attributes. Particular types of attributes include this structure\n as their initial portion. The common portion of the attribute holds\n the range to which the value in the type-specific part of the attribute\n applies and should be initialized using pango_attribute_init().\n By default an attribute will have an all-inclusive range of [0,%G_MAXUINT]."]
pub type PangoAttribute = _PangoAttribute;
#[doc = " PangoAttrClass:\n @type: the type ID for this attribute\n @copy: function to duplicate an attribute of this type (see pango_attribute_copy())\n @destroy: function to free an attribute of this type (see pango_attribute_destroy())\n @equal: function to check two attributes of this type for equality (see pango_attribute_equal())\n\n The #PangoAttrClass structure stores the type and operations for\n a particular type of attribute. The functions in this structure should\n not be called directly. Instead, one should use the wrapper functions\n provided for #PangoAttribute."]
pub type PangoAttrClass = _PangoAttrClass;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _PangoAttrList {
_unused: [u8; 0],
}
#[doc = " PangoAttrIterator:\n\n The #PangoAttrIterator structure is used to represent an\n iterator through a #PangoAttrList. A new iterator is created\n with pango_attr_list_get_iterator(). Once the iterator\n is created, it can be advanced through the style changes\n in the text using pango_attr_iterator_next(). At each\n style change, the range of the current style segment and the\n attributes currently in effect can be queried.\n/\n/**\n PangoAttrList:\n\n The #PangoAttrList structure represents a list of attributes\n that apply to a section of text. The attributes are, in general,\n allowed to overlap in an arbitrary fashion, however, if the\n attributes are manipulated only through pango_attr_list_change(),\n the overlap between properties will meet stricter criteria.\n\n Since the #PangoAttrList structure is stored as a linear list,\n it is not suitable for storing attributes for large amounts\n of text. In general, you should not use a single #PangoAttrList\n for more than one paragraph of text."]
pub type PangoAttrList = _PangoAttrList;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _PangoAttrIterator {
_unused: [u8; 0],
}
pub type PangoAttrIterator = _PangoAttrIterator;
pub const PangoAttrType_PANGO_ATTR_INVALID: PangoAttrType = 0;
pub const PangoAttrType_PANGO_ATTR_LANGUAGE: PangoAttrType = 1;
pub const PangoAttrType_PANGO_ATTR_FAMILY: PangoAttrType = 2;
pub const PangoAttrType_PANGO_ATTR_STYLE: PangoAttrType = 3;
pub const PangoAttrType_PANGO_ATTR_WEIGHT: PangoAttrType = 4;
pub const PangoAttrType_PANGO_ATTR_VARIANT: PangoAttrType = 5;
pub const PangoAttrType_PANGO_ATTR_STRETCH: PangoAttrType = 6;
pub const PangoAttrType_PANGO_ATTR_SIZE: PangoAttrType = 7;
pub const PangoAttrType_PANGO_ATTR_FONT_DESC: PangoAttrType = 8;
pub const PangoAttrType_PANGO_ATTR_FOREGROUND: PangoAttrType = 9;
pub const PangoAttrType_PANGO_ATTR_BACKGROUND: PangoAttrType = 10;
pub const PangoAttrType_PANGO_ATTR_UNDERLINE: PangoAttrType = 11;
pub const PangoAttrType_PANGO_ATTR_STRIKETHROUGH: PangoAttrType = 12;
pub const PangoAttrType_PANGO_ATTR_RISE: PangoAttrType = 13;
pub const PangoAttrType_PANGO_ATTR_SHAPE: PangoAttrType = 14;
pub const PangoAttrType_PANGO_ATTR_SCALE: PangoAttrType = 15;
pub const PangoAttrType_PANGO_ATTR_FALLBACK: PangoAttrType = 16;
pub const PangoAttrType_PANGO_ATTR_LETTER_SPACING: PangoAttrType = 17;
pub const PangoAttrType_PANGO_ATTR_UNDERLINE_COLOR: PangoAttrType = 18;
pub const PangoAttrType_PANGO_ATTR_STRIKETHROUGH_COLOR: PangoAttrType = 19;
pub const PangoAttrType_PANGO_ATTR_ABSOLUTE_SIZE: PangoAttrType = 20;
pub const PangoAttrType_PANGO_ATTR_GRAVITY: PangoAttrType = 21;
pub const PangoAttrType_PANGO_ATTR_GRAVITY_HINT: PangoAttrType = 22;
#[doc = " PangoAttrType:\n @PANGO_ATTR_INVALID: does not happen\n @PANGO_ATTR_LANGUAGE: language (#PangoAttrLanguage)\n @PANGO_ATTR_FAMILY: font family name list (#PangoAttrString)\n @PANGO_ATTR_STYLE: font slant style (#PangoAttrInt)\n @PANGO_ATTR_WEIGHT: font weight (#PangoAttrInt)\n @PANGO_ATTR_VARIANT: font variant (normal or small caps) (#PangoAttrInt)\n @PANGO_ATTR_STRETCH: font stretch (#PangoAttrInt)\n @PANGO_ATTR_SIZE: font size in points scaled by %PANGO_SCALE (#PangoAttrInt)\n @PANGO_ATTR_FONT_DESC: font description (#PangoAttrFontDesc)\n @PANGO_ATTR_FOREGROUND: foreground color (#PangoAttrColor)\n @PANGO_ATTR_BACKGROUND: background color (#PangoAttrColor)\n @PANGO_ATTR_UNDERLINE: whether the text has an underline (#PangoAttrInt)\n @PANGO_ATTR_STRIKETHROUGH: whether the text is struck-through (#PangoAttrInt)\n @PANGO_ATTR_RISE: baseline displacement (#PangoAttrInt)\n @PANGO_ATTR_SHAPE: shape (#PangoAttrShape)\n @PANGO_ATTR_SCALE: font size scale factor (#PangoAttrFloat)\n @PANGO_ATTR_FALLBACK: whether fallback is enabled (#PangoAttrInt)\n @PANGO_ATTR_LETTER_SPACING: letter spacing (#PangoAttrInt)\n @PANGO_ATTR_UNDERLINE_COLOR: underline color (#PangoAttrColor)\n @PANGO_ATTR_STRIKETHROUGH_COLOR: strikethrough color (#PangoAttrColor)\n @PANGO_ATTR_ABSOLUTE_SIZE: font size in pixels scaled by %PANGO_SCALE (#PangoAttrInt)\n @PANGO_ATTR_GRAVITY: base text gravity (#PangoAttrInt)\n @PANGO_ATTR_GRAVITY_HINT: gravity hint (#PangoAttrInt)\n\n The #PangoAttrType\n distinguishes between different types of attributes. Along with the\n predefined values, it is possible to allocate additional values\n for custom attributes using pango_attr_type_register(). The predefined\n values are given below. The type of structure used to store the\n attribute is listed in parentheses after the description."]
pub type PangoAttrType = ::std::os::raw::c_uint;
pub const PangoUnderline_PANGO_UNDERLINE_NONE: PangoUnderline = 0;
pub const PangoUnderline_PANGO_UNDERLINE_SINGLE: PangoUnderline = 1;
pub const PangoUnderline_PANGO_UNDERLINE_DOUBLE: PangoUnderline = 2;
pub const PangoUnderline_PANGO_UNDERLINE_LOW: PangoUnderline = 3;
pub const PangoUnderline_PANGO_UNDERLINE_ERROR: PangoUnderline = 4;
#[doc = " PangoUnderline:\n @PANGO_UNDERLINE_NONE: no underline should be drawn\n @PANGO_UNDERLINE_SINGLE: a single underline should be drawn\n @PANGO_UNDERLINE_DOUBLE: a double underline should be drawn\n @PANGO_UNDERLINE_LOW: a single underline should be drawn at a position\n beneath the ink extents of the text being\n underlined. This should be used only for underlining\n single characters, such as for keyboard\n accelerators. %PANGO_UNDERLINE_SINGLE should\n be used for extended portions of text.\n @PANGO_UNDERLINE_ERROR: a wavy underline should be drawn below.\n This underline is typically used to indicate\n an error such as a possilble mispelling; in some\n cases a contrasting color may automatically\n be used. This type of underlining is available since Pango 1.4.\n\n The #PangoUnderline enumeration is used to specify\n whether text should be underlined, and if so, the type\n of underlining."]
pub type PangoUnderline = ::std::os::raw::c_uint;
#[doc = " PangoAttribute:\n @klass: the class structure holding information about the type of the attribute\n @start_index: the start index of the range (in bytes).\n @end_index: end index of the range (in bytes). The character at this index\n is not included in the range.\n\n The #PangoAttribute structure represents the common portions of all\n attributes. Particular types of attributes include this structure\n as their initial portion. The common portion of the attribute holds\n the range to which the value in the type-specific part of the attribute\n applies and should be initialized using pango_attribute_init().\n By default an attribute will have an all-inclusive range of [0,%G_MAXUINT]."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _PangoAttribute {
pub klass: *const PangoAttrClass,
pub start_index: guint,
pub end_index: guint,
}
#[test]
fn bindgen_test_layout__PangoAttribute() {
const UNINIT: ::std::mem::MaybeUninit<_PangoAttribute> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_PangoAttribute>(),
16usize,
concat!("Size of: ", stringify!(_PangoAttribute))
);
assert_eq!(
::std::mem::align_of::<_PangoAttribute>(),
8usize,
concat!("Alignment of ", stringify!(_PangoAttribute))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).klass) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_PangoAttribute),
"::",
stringify!(klass)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).start_index) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_PangoAttribute),
"::",
stringify!(start_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).end_index) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_PangoAttribute),
"::",
stringify!(end_index)
)
);
}
impl Default for _PangoAttribute {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " PangoAttrFilterFunc:\n @attribute: a Pango attribute\n @user_data: user data passed to the function\n\n Type of a function filtering a list of attributes.\n\n Return value: %TRUE if the attribute should be selected for\n filtering, %FALSE otherwise."]
pub type PangoAttrFilterFunc = ::std::option::Option<
unsafe extern "C" fn(attribute: *mut PangoAttribute, user_data: gpointer) -> gboolean,
>;
#[doc = " PangoAttrDataCopyFunc:\n @user_data: user data to copy\n\n Type of a function that can duplicate user data for an attribute.\n\n Return value: new copy of @user_data."]
pub type PangoAttrDataCopyFunc =
::std::option::Option<unsafe extern "C" fn(user_data: gconstpointer) -> gpointer>;
#[doc = " PangoAttrClass:\n @type: the type ID for this attribute\n @copy: function to duplicate an attribute of this type (see pango_attribute_copy())\n @destroy: function to free an attribute of this type (see pango_attribute_destroy())\n @equal: function to check two attributes of this type for equality (see pango_attribute_equal())\n\n The #PangoAttrClass structure stores the type and operations for\n a particular type of attribute. The functions in this structure should\n not be called directly. Instead, one should use the wrapper functions\n provided for #PangoAttribute."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _PangoAttrClass {
pub type_: PangoAttrType,
pub copy: ::std::option::Option<
unsafe extern "C" fn(attr: *const PangoAttribute) -> *mut PangoAttribute,
>,
pub destroy: ::std::option::Option<unsafe extern "C" fn(attr: *mut PangoAttribute)>,
pub equal: ::std::option::Option<
unsafe extern "C" fn(
attr1: *const PangoAttribute,
attr2: *const PangoAttribute,
) -> gboolean,
>,
}
#[test]
fn bindgen_test_layout__PangoAttrClass() {
const UNINIT: ::std::mem::MaybeUninit<_PangoAttrClass> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_PangoAttrClass>(),
32usize,
concat!("Size of: ", stringify!(_PangoAttrClass))
);
assert_eq!(
::std::mem::align_of::<_PangoAttrClass>(),
8usize,
concat!("Alignment of ", stringify!(_PangoAttrClass))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_PangoAttrClass),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).copy) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_PangoAttrClass),
"::",
stringify!(copy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).destroy) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_PangoAttrClass),
"::",
stringify!(destroy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).equal) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_PangoAttrClass),
"::",
stringify!(equal)
)
);
}
impl Default for _PangoAttrClass {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn pango_attr_type_register(name: *const gchar) -> PangoAttrType;
}
extern "C" {
pub fn pango_attr_type_get_name(type_: PangoAttrType) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn pango_attr_language_new(language: *mut PangoLanguage) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_family_new(family: *const ::std::os::raw::c_char) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_foreground_new(
red: guint16,
green: guint16,
blue: guint16,
) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_background_new(
red: guint16,
green: guint16,
blue: guint16,
) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_size_new(size: ::std::os::raw::c_int) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_size_new_absolute(size: ::std::os::raw::c_int) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_style_new(style: PangoStyle) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_weight_new(weight: PangoWeight) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_variant_new(variant: PangoVariant) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_stretch_new(stretch: PangoStretch) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_font_desc_new(desc: *const PangoFontDescription) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_underline_new(underline: PangoUnderline) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_underline_color_new(
red: guint16,
green: guint16,
blue: guint16,
) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_strikethrough_new(strikethrough: gboolean) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_strikethrough_color_new(
red: guint16,
green: guint16,
blue: guint16,
) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_rise_new(rise: ::std::os::raw::c_int) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_scale_new(scale_factor: f64) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_fallback_new(enable_fallback: gboolean) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_letter_spacing_new(
letter_spacing: ::std::os::raw::c_int,
) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_shape_new(
ink_rect: *const PangoRectangle,
logical_rect: *const PangoRectangle,
) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_shape_new_with_data(
ink_rect: *const PangoRectangle,
logical_rect: *const PangoRectangle,
data: gpointer,
copy_func: PangoAttrDataCopyFunc,
destroy_func: GDestroyNotify,
) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_gravity_new(gravity: PangoGravity) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_gravity_hint_new(hint: PangoGravityHint) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_list_get_type() -> GType;
}
extern "C" {
pub fn pango_attr_list_new() -> *mut PangoAttrList;
}
extern "C" {
pub fn pango_attr_list_ref(list: *mut PangoAttrList) -> *mut PangoAttrList;
}
extern "C" {
pub fn pango_attr_list_unref(list: *mut PangoAttrList);
}
extern "C" {
pub fn pango_attr_list_copy(list: *mut PangoAttrList) -> *mut PangoAttrList;
}
extern "C" {
pub fn pango_attr_list_insert(list: *mut PangoAttrList, attr: *mut PangoAttribute);
}
extern "C" {
pub fn pango_attr_list_insert_before(list: *mut PangoAttrList, attr: *mut PangoAttribute);
}
extern "C" {
pub fn pango_attr_list_change(list: *mut PangoAttrList, attr: *mut PangoAttribute);
}
extern "C" {
pub fn pango_attr_list_splice(
list: *mut PangoAttrList,
other: *mut PangoAttrList,
pos: gint,
len: gint,
);
}
extern "C" {
pub fn pango_attr_list_filter(
list: *mut PangoAttrList,
func: PangoAttrFilterFunc,
data: gpointer,
) -> *mut PangoAttrList;
}
extern "C" {
pub fn pango_attr_list_get_iterator(list: *mut PangoAttrList) -> *mut PangoAttrIterator;
}
extern "C" {
pub fn pango_attr_iterator_range(
iterator: *mut PangoAttrIterator,
start: *mut gint,
end: *mut gint,
);
}
extern "C" {
pub fn pango_attr_iterator_next(iterator: *mut PangoAttrIterator) -> gboolean;
}
extern "C" {
pub fn pango_attr_iterator_copy(iterator: *mut PangoAttrIterator) -> *mut PangoAttrIterator;
}
extern "C" {
pub fn pango_attr_iterator_destroy(iterator: *mut PangoAttrIterator);
}
extern "C" {
pub fn pango_attr_iterator_get(
iterator: *mut PangoAttrIterator,
type_: PangoAttrType,
) -> *mut PangoAttribute;
}
extern "C" {
pub fn pango_attr_iterator_get_font(
iterator: *mut PangoAttrIterator,
desc: *mut PangoFontDescription,
language: *mut *mut PangoLanguage,
extra_attrs: *mut *mut GSList,
);
}
extern "C" {
pub fn pango_attr_iterator_get_attrs(iterator: *mut PangoAttrIterator) -> *mut GSList;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _PangoContext {
_unused: [u8; 0],
}
pub type PangoContext = _PangoContext;
extern "C" {
pub fn pango_attr_type_get_type() -> GType;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _PangoTabArray {
_unused: [u8; 0],
}
pub type PangoTabArray = _PangoTabArray;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _PangoLayout {
_unused: [u8; 0],
}
pub type PangoLayout = _PangoLayout;
pub const PangoWrapMode_PANGO_WRAP_WORD: PangoWrapMode = 0;
pub const PangoWrapMode_PANGO_WRAP_CHAR: PangoWrapMode = 1;
pub const PangoWrapMode_PANGO_WRAP_WORD_CHAR: PangoWrapMode = 2;
#[doc = " PangoWrapMode:\n @PANGO_WRAP_WORD: wrap lines at word boundaries.\n @PANGO_WRAP_CHAR: wrap lines at character boundaries.\n @PANGO_WRAP_WORD_CHAR: wrap lines at word boundaries, but fall back to character boundaries if there is not\n enough space for a full word.\n\n A #PangoWrapMode describes how to wrap the lines of a #PangoLayout to the desired width."]
pub type PangoWrapMode = ::std::os::raw::c_uint;
pub const PangoEllipsizeMode_PANGO_ELLIPSIZE_NONE: PangoEllipsizeMode = 0;
pub const PangoEllipsizeMode_PANGO_ELLIPSIZE_START: PangoEllipsizeMode = 1;
pub const PangoEllipsizeMode_PANGO_ELLIPSIZE_MIDDLE: PangoEllipsizeMode = 2;
pub const PangoEllipsizeMode_PANGO_ELLIPSIZE_END: PangoEllipsizeMode = 3;
#[doc = " PangoEllipsizeMode:\n @PANGO_ELLIPSIZE_NONE: No ellipsization\n @PANGO_ELLIPSIZE_START: Omit characters at the start of the text\n @PANGO_ELLIPSIZE_MIDDLE: Omit characters in the middle of the text\n @PANGO_ELLIPSIZE_END: Omit characters at the end of the text\n\n The #PangoEllipsizeMode type describes what sort of (if any)\n ellipsization should be applied to a line of text. In\n the ellipsization process characters are removed from the\n text in order to make it fit to a given width and replaced\n with an ellipsis."]
pub type PangoEllipsizeMode = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _cairo {
_unused: [u8; 0],
}
#[doc = " cairo_t:\n\n A #cairo_t contains the current state of the rendering device,\n including coordinates of yet to be drawn shapes.\n\n Cairo contexts, as #cairo_t objects are named, are central to\n cairo and all drawing with cairo is always done to a #cairo_t\n object.\n\n Memory management of #cairo_t is done with\n cairo_reference() and cairo_destroy().\n\n Since: 1.0"]
pub type cairo_t = _cairo;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _cairo_surface {
_unused: [u8; 0],
}
#[doc = " cairo_surface_t:\n\n A #cairo_surface_t represents an image, either as the destination\n of a drawing operation or as source when drawing onto another\n surface. To draw to a #cairo_surface_t, create a cairo context\n with the surface as the target, using cairo_create().\n\n There are different subtypes of #cairo_surface_t for\n different drawing backends; for example, cairo_image_surface_create()\n creates a bitmap image in memory.\n The type of a surface can be queried with cairo_surface_get_type().\n\n The initial contents of a surface after creation depend upon the manner\n of its creation. If cairo creates the surface and backing storage for\n the user, it will be initially cleared; for example,\n cairo_image_surface_create() and cairo_surface_create_similar().\n Alternatively, if the user passes in a reference to some backing storage\n and asks cairo to wrap that in a #cairo_surface_t, then the contents are\n not modified; for example, cairo_image_surface_create_for_data() and\n cairo_xlib_surface_create().\n\n Memory management of #cairo_surface_t is done with\n cairo_surface_reference() and cairo_surface_destroy().\n\n Since: 1.0"]
pub type cairo_surface_t = _cairo_surface;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _cairo_pattern {
_unused: [u8; 0],
}
#[doc = " cairo_pattern_t:\n\n A #cairo_pattern_t represents a source when drawing onto a\n surface. There are different subtypes of #cairo_pattern_t,\n for different types of sources; for example,\n cairo_pattern_create_rgb() creates a pattern for a solid\n opaque color.\n\n Other than various\n <function>cairo_pattern_create_<emphasis>type</emphasis>()</function>\n functions, some of the pattern types can be implicitly created using various\n <function>cairo_set_source_<emphasis>type</emphasis>()</function> functions;\n for example cairo_set_source_rgb().\n\n The type of a pattern can be queried with cairo_pattern_get_type().\n\n Memory management of #cairo_pattern_t is done with\n cairo_pattern_reference() and cairo_pattern_destroy().\n\n Since: 1.0"]
pub type cairo_pattern_t = _cairo_pattern;
#[doc = " cairo_rectangle_int_t:\n @x: X coordinate of the left side of the rectangle\n @y: Y coordinate of the the top side of the rectangle\n @width: width of the rectangle\n @height: height of the rectangle\n\n A data structure for holding a rectangle with integer coordinates.\n\n Since: 1.10"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _cairo_rectangle_int {
pub x: ::std::os::raw::c_int,
pub y: ::std::os::raw::c_int,
pub width: ::std::os::raw::c_int,
pub height: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__cairo_rectangle_int() {
const UNINIT: ::std::mem::MaybeUninit<_cairo_rectangle_int> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_cairo_rectangle_int>(),
16usize,
concat!("Size of: ", stringify!(_cairo_rectangle_int))
);
assert_eq!(
::std::mem::align_of::<_cairo_rectangle_int>(),
4usize,
concat!("Alignment of ", stringify!(_cairo_rectangle_int))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_cairo_rectangle_int),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_cairo_rectangle_int),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_cairo_rectangle_int),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_cairo_rectangle_int),
"::",
stringify!(height)
)
);
}
#[doc = " cairo_rectangle_int_t:\n @x: X coordinate of the left side of the rectangle\n @y: Y coordinate of the the top side of the rectangle\n @width: width of the rectangle\n @height: height of the rectangle\n\n A data structure for holding a rectangle with integer coordinates.\n\n Since: 1.10"]
pub type cairo_rectangle_int_t = _cairo_rectangle_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _cairo_region {
_unused: [u8; 0],
}
#[doc = " cairo_region_t:\n\n A #cairo_region_t represents a set of integer-aligned rectangles.\n\n It allows set-theoretical operations like cairo_region_union() and\n cairo_region_intersect() to be performed on them.\n\n Memory management of #cairo_region_t is done with\n cairo_region_reference() and cairo_region_destroy().\n\n Since: 1.10"]
pub type cairo_region_t = _cairo_region;
#[doc = " GdkPoint:\n @x: the x coordinate of the point.\n @y: the y coordinate of the point.\n\n Defines the x and y coordinates of a point."]
pub type GdkPoint = _GdkPoint;
#[doc = " GdkRectangle:\n\n Defines the position and size of a rectangle. It is identical to\n #cairo_rectangle_int_t."]
pub type GdkRectangle = cairo_rectangle_int_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkAtom {
_unused: [u8; 0],
}
#[doc = " GdkAtom:\n\n An opaque type representing a string as an index into a table\n of strings on the X server."]
pub type GdkAtom = *mut _GdkAtom;
#[doc = " GdkColor:\n @pixel: For allocated colors, the pixel value used to\n draw this color on the screen. Not used anymore.\n @red: The red component of the color. This is\n a value between 0 and 65535, with 65535 indicating\n full intensity\n @green: The green component of the color\n @blue: The blue component of the color\n\n A #GdkColor is used to describe a color,\n similar to the XColor struct used in the X11 drawing API.\n\n Deprecated: 3.14: Use #GdkRGBA"]
pub type GdkColor = _GdkColor;
pub type GdkRGBA = _GdkRGBA;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkVisual {
_unused: [u8; 0],
}
pub type GdkVisual = _GdkVisual;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkDevice {
_unused: [u8; 0],
}
pub type GdkDevice = _GdkDevice;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkDragContext {
_unused: [u8; 0],
}
pub type GdkDragContext = _GdkDragContext;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkDisplay {
_unused: [u8; 0],
}
pub type GdkDisplay = _GdkDisplay;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkScreen {
_unused: [u8; 0],
}
pub type GdkScreen = _GdkScreen;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkWindow {
_unused: [u8; 0],
}
pub type GdkWindow = _GdkWindow;
pub const GdkModifierType_GDK_SHIFT_MASK: GdkModifierType = 1;
pub const GdkModifierType_GDK_LOCK_MASK: GdkModifierType = 2;
pub const GdkModifierType_GDK_CONTROL_MASK: GdkModifierType = 4;
pub const GdkModifierType_GDK_MOD1_MASK: GdkModifierType = 8;
pub const GdkModifierType_GDK_MOD2_MASK: GdkModifierType = 16;
pub const GdkModifierType_GDK_MOD3_MASK: GdkModifierType = 32;
pub const GdkModifierType_GDK_MOD4_MASK: GdkModifierType = 64;
pub const GdkModifierType_GDK_MOD5_MASK: GdkModifierType = 128;
pub const GdkModifierType_GDK_BUTTON1_MASK: GdkModifierType = 256;
pub const GdkModifierType_GDK_BUTTON2_MASK: GdkModifierType = 512;
pub const GdkModifierType_GDK_BUTTON3_MASK: GdkModifierType = 1024;
pub const GdkModifierType_GDK_BUTTON4_MASK: GdkModifierType = 2048;
pub const GdkModifierType_GDK_BUTTON5_MASK: GdkModifierType = 4096;
pub const GdkModifierType_GDK_MODIFIER_RESERVED_13_MASK: GdkModifierType = 8192;
pub const GdkModifierType_GDK_MODIFIER_RESERVED_14_MASK: GdkModifierType = 16384;
pub const GdkModifierType_GDK_MODIFIER_RESERVED_15_MASK: GdkModifierType = 32768;
pub const GdkModifierType_GDK_MODIFIER_RESERVED_16_MASK: GdkModifierType = 65536;
pub const GdkModifierType_GDK_MODIFIER_RESERVED_17_MASK: GdkModifierType = 131072;
pub const GdkModifierType_GDK_MODIFIER_RESERVED_18_MASK: GdkModifierType = 262144;
pub const GdkModifierType_GDK_MODIFIER_RESERVED_19_MASK: GdkModifierType = 524288;
pub const GdkModifierType_GDK_MODIFIER_RESERVED_20_MASK: GdkModifierType = 1048576;
pub const GdkModifierType_GDK_MODIFIER_RESERVED_21_MASK: GdkModifierType = 2097152;
pub const GdkModifierType_GDK_MODIFIER_RESERVED_22_MASK: GdkModifierType = 4194304;
pub const GdkModifierType_GDK_MODIFIER_RESERVED_23_MASK: GdkModifierType = 8388608;
pub const GdkModifierType_GDK_MODIFIER_RESERVED_24_MASK: GdkModifierType = 16777216;
pub const GdkModifierType_GDK_MODIFIER_RESERVED_25_MASK: GdkModifierType = 33554432;
pub const GdkModifierType_GDK_SUPER_MASK: GdkModifierType = 67108864;
pub const GdkModifierType_GDK_HYPER_MASK: GdkModifierType = 134217728;
pub const GdkModifierType_GDK_META_MASK: GdkModifierType = 268435456;
pub const GdkModifierType_GDK_MODIFIER_RESERVED_29_MASK: GdkModifierType = 536870912;
pub const GdkModifierType_GDK_RELEASE_MASK: GdkModifierType = 1073741824;
pub const GdkModifierType_GDK_MODIFIER_MASK: GdkModifierType = 1543512063;
#[doc = " GdkModifierType:\n @GDK_SHIFT_MASK: the Shift key.\n @GDK_LOCK_MASK: a Lock key (depending on the modifier mapping of the\n X server this may either be CapsLock or ShiftLock).\n @GDK_CONTROL_MASK: the Control key.\n @GDK_MOD1_MASK: the fourth modifier key (it depends on the modifier\n mapping of the X server which key is interpreted as this modifier, but\n normally it is the Alt key).\n @GDK_MOD2_MASK: the fifth modifier key (it depends on the modifier\n mapping of the X server which key is interpreted as this modifier).\n @GDK_MOD3_MASK: the sixth modifier key (it depends on the modifier\n mapping of the X server which key is interpreted as this modifier).\n @GDK_MOD4_MASK: the seventh modifier key (it depends on the modifier\n mapping of the X server which key is interpreted as this modifier).\n @GDK_MOD5_MASK: the eighth modifier key (it depends on the modifier\n mapping of the X server which key is interpreted as this modifier).\n @GDK_BUTTON1_MASK: the first mouse button.\n @GDK_BUTTON2_MASK: the second mouse button.\n @GDK_BUTTON3_MASK: the third mouse button.\n @GDK_BUTTON4_MASK: the fourth mouse button.\n @GDK_BUTTON5_MASK: the fifth mouse button.\n @GDK_MODIFIER_RESERVED_13_MASK: A reserved bit flag; do not use in your own code\n @GDK_MODIFIER_RESERVED_14_MASK: A reserved bit flag; do not use in your own code\n @GDK_MODIFIER_RESERVED_15_MASK: A reserved bit flag; do not use in your own code\n @GDK_MODIFIER_RESERVED_16_MASK: A reserved bit flag; do not use in your own code\n @GDK_MODIFIER_RESERVED_17_MASK: A reserved bit flag; do not use in your own code\n @GDK_MODIFIER_RESERVED_18_MASK: A reserved bit flag; do not use in your own code\n @GDK_MODIFIER_RESERVED_19_MASK: A reserved bit flag; do not use in your own code\n @GDK_MODIFIER_RESERVED_20_MASK: A reserved bit flag; do not use in your own code\n @GDK_MODIFIER_RESERVED_21_MASK: A reserved bit flag; do not use in your own code\n @GDK_MODIFIER_RESERVED_22_MASK: A reserved bit flag; do not use in your own code\n @GDK_MODIFIER_RESERVED_23_MASK: A reserved bit flag; do not use in your own code\n @GDK_MODIFIER_RESERVED_24_MASK: A reserved bit flag; do not use in your own code\n @GDK_MODIFIER_RESERVED_25_MASK: A reserved bit flag; do not use in your own code\n @GDK_SUPER_MASK: the Super modifier. Since 2.10\n @GDK_HYPER_MASK: the Hyper modifier. Since 2.10\n @GDK_META_MASK: the Meta modifier. Since 2.10\n @GDK_MODIFIER_RESERVED_29_MASK: A reserved bit flag; do not use in your own code\n @GDK_RELEASE_MASK: not used in GDK itself. GTK+ uses it to differentiate\n between (keyval, modifiers) pairs from key press and release events.\n @GDK_MODIFIER_MASK: a mask covering all modifier types.\n\n A set of bit-flags to indicate the state of modifier keys and mouse buttons\n in various event types. Typical modifier keys are Shift, Control, Meta,\n Super, Hyper, Alt, Compose, Apple, CapsLock or ShiftLock.\n\n Like the X Window System, GDK supports 8 modifier keys and 5 mouse buttons.\n\n Since 2.10, GDK recognizes which of the Meta, Super or Hyper keys are mapped\n to Mod2 - Mod5, and indicates this by setting %GDK_SUPER_MASK,\n %GDK_HYPER_MASK or %GDK_META_MASK in the state field of key events.\n\n Note that GDK may add internal values to events which include\n reserved values such as %GDK_MODIFIER_RESERVED_13_MASK. Your code\n should preserve and ignore them. You can use %GDK_MODIFIER_MASK to\n remove all reserved values."]
pub type GdkModifierType = ::std::os::raw::c_uint;
pub const GdkModifierIntent_GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR: GdkModifierIntent = 0;
pub const GdkModifierIntent_GDK_MODIFIER_INTENT_CONTEXT_MENU: GdkModifierIntent = 1;
pub const GdkModifierIntent_GDK_MODIFIER_INTENT_EXTEND_SELECTION: GdkModifierIntent = 2;
pub const GdkModifierIntent_GDK_MODIFIER_INTENT_MODIFY_SELECTION: GdkModifierIntent = 3;
pub const GdkModifierIntent_GDK_MODIFIER_INTENT_NO_TEXT_INPUT: GdkModifierIntent = 4;
pub const GdkModifierIntent_GDK_MODIFIER_INTENT_SHIFT_GROUP: GdkModifierIntent = 5;
#[doc = " GdkModifierIntent:\n @GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR: the primary modifier used to invoke\n menu accelerators.\n @GDK_MODIFIER_INTENT_CONTEXT_MENU: the modifier used to invoke context menus.\n Note that mouse button 3 always triggers context menus. When this modifier\n is not 0, it additionally triggers context menus when used with mouse button 1.\n @GDK_MODIFIER_INTENT_EXTEND_SELECTION: the modifier used to extend selections\n using `modifier`-click or `modifier`-cursor-key\n @GDK_MODIFIER_INTENT_MODIFY_SELECTION: the modifier used to modify selections,\n which in most cases means toggling the clicked item into or out of the selection.\n @GDK_MODIFIER_INTENT_NO_TEXT_INPUT: when any of these modifiers is pressed, the\n key event cannot produce a symbol directly. This is meant to be used for\n input methods, and for use cases like typeahead search.\n @GDK_MODIFIER_INTENT_SHIFT_GROUP: the modifier that switches between keyboard\n groups (AltGr on X11/Windows and Option/Alt on OS X).\n\n This enum is used with gdk_keymap_get_modifier_mask()\n in order to determine what modifiers the\n currently used windowing system backend uses for particular\n purposes. For example, on X11/Windows, the Control key is used for\n invoking menu shortcuts (accelerators), whereas on Apple computers\n it’s the Command key (which correspond to %GDK_CONTROL_MASK and\n %GDK_MOD2_MASK, respectively).\n\n Since: 3.4"]
pub type GdkModifierIntent = ::std::os::raw::c_uint;
pub const GdkEventMask_GDK_EXPOSURE_MASK: GdkEventMask = 2;
pub const GdkEventMask_GDK_POINTER_MOTION_MASK: GdkEventMask = 4;
pub const GdkEventMask_GDK_POINTER_MOTION_HINT_MASK: GdkEventMask = 8;
pub const GdkEventMask_GDK_BUTTON_MOTION_MASK: GdkEventMask = 16;
pub const GdkEventMask_GDK_BUTTON1_MOTION_MASK: GdkEventMask = 32;
pub const GdkEventMask_GDK_BUTTON2_MOTION_MASK: GdkEventMask = 64;
pub const GdkEventMask_GDK_BUTTON3_MOTION_MASK: GdkEventMask = 128;
pub const GdkEventMask_GDK_BUTTON_PRESS_MASK: GdkEventMask = 256;
pub const GdkEventMask_GDK_BUTTON_RELEASE_MASK: GdkEventMask = 512;
pub const GdkEventMask_GDK_KEY_PRESS_MASK: GdkEventMask = 1024;
pub const GdkEventMask_GDK_KEY_RELEASE_MASK: GdkEventMask = 2048;
pub const GdkEventMask_GDK_ENTER_NOTIFY_MASK: GdkEventMask = 4096;
pub const GdkEventMask_GDK_LEAVE_NOTIFY_MASK: GdkEventMask = 8192;
pub const GdkEventMask_GDK_FOCUS_CHANGE_MASK: GdkEventMask = 16384;
pub const GdkEventMask_GDK_STRUCTURE_MASK: GdkEventMask = 32768;
pub const GdkEventMask_GDK_PROPERTY_CHANGE_MASK: GdkEventMask = 65536;
pub const GdkEventMask_GDK_VISIBILITY_NOTIFY_MASK: GdkEventMask = 131072;
pub const GdkEventMask_GDK_PROXIMITY_IN_MASK: GdkEventMask = 262144;
pub const GdkEventMask_GDK_PROXIMITY_OUT_MASK: GdkEventMask = 524288;
pub const GdkEventMask_GDK_SUBSTRUCTURE_MASK: GdkEventMask = 1048576;
pub const GdkEventMask_GDK_SCROLL_MASK: GdkEventMask = 2097152;
pub const GdkEventMask_GDK_TOUCH_MASK: GdkEventMask = 4194304;
pub const GdkEventMask_GDK_SMOOTH_SCROLL_MASK: GdkEventMask = 8388608;
pub const GdkEventMask_GDK_ALL_EVENTS_MASK: GdkEventMask = 16777214;
#[doc = " GdkEventMask:\n @GDK_EXPOSURE_MASK: receive expose events\n @GDK_POINTER_MOTION_MASK: receive all pointer motion events\n @GDK_POINTER_MOTION_HINT_MASK: deprecated. see the explanation above\n @GDK_BUTTON_MOTION_MASK: receive pointer motion events while any button is pressed\n @GDK_BUTTON1_MOTION_MASK: receive pointer motion events while 1 button is pressed\n @GDK_BUTTON2_MOTION_MASK: receive pointer motion events while 2 button is pressed\n @GDK_BUTTON3_MOTION_MASK: receive pointer motion events while 3 button is pressed\n @GDK_BUTTON_PRESS_MASK: receive button press events\n @GDK_BUTTON_RELEASE_MASK: receive button release events\n @GDK_KEY_PRESS_MASK: receive key press events\n @GDK_KEY_RELEASE_MASK: receive key release events\n @GDK_ENTER_NOTIFY_MASK: receive window enter events\n @GDK_LEAVE_NOTIFY_MASK: receive window leave events\n @GDK_FOCUS_CHANGE_MASK: receive focus change events\n @GDK_STRUCTURE_MASK: receive events about window configuration change\n @GDK_PROPERTY_CHANGE_MASK: receive property change events\n @GDK_VISIBILITY_NOTIFY_MASK: receive visibility change events\n @GDK_PROXIMITY_IN_MASK: receive proximity in events\n @GDK_PROXIMITY_OUT_MASK: receive proximity out events\n @GDK_SUBSTRUCTURE_MASK: receive events about window configuration changes of\n child windows\n @GDK_SCROLL_MASK: receive scroll events\n @GDK_TOUCH_MASK: receive touch events. Since 3.4\n @GDK_SMOOTH_SCROLL_MASK: receive smooth scrolling events. Since 3.4\n @GDK_ALL_EVENTS_MASK: the combination of all the above event masks.\n\n A set of bit-flags to indicate which events a window is to receive.\n Most of these masks map onto one or more of the #GdkEventType event types\n above.\n\n %GDK_POINTER_MOTION_HINT_MASK is deprecated. It is a special mask\n to reduce the number of %GDK_MOTION_NOTIFY events received. When using\n %GDK_POINTER_MOTION_HINT_MASK, fewer %GDK_MOTION_NOTIFY events will\n be sent, some of which are marked as a hint (the is_hint member is\n %TRUE). To receive more motion events after a motion hint event,\n the application needs to asks for more, by calling\n gdk_event_request_motions().\n\n Since GTK 3.8, motion events are already compressed by default, independent\n of this mechanism. This compression can be disabled with\n gdk_window_set_event_compression(). See the documentation of that function\n for details.\n\n If %GDK_TOUCH_MASK is enabled, the window will receive touch events\n from touch-enabled devices. Those will come as sequences of #GdkEventTouch\n with type %GDK_TOUCH_UPDATE, enclosed by two events with\n type %GDK_TOUCH_BEGIN and %GDK_TOUCH_END (or %GDK_TOUCH_CANCEL).\n gdk_event_get_event_sequence() returns the event sequence for these\n events, so different sequences may be distinguished."]
pub type GdkEventMask = ::std::os::raw::c_uint;
#[doc = " GdkPoint:\n @x: the x coordinate of the point.\n @y: the y coordinate of the point.\n\n Defines the x and y coordinates of a point."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _GdkPoint {
pub x: gint,
pub y: gint,
}
#[test]
fn bindgen_test_layout__GdkPoint() {
const UNINIT: ::std::mem::MaybeUninit<_GdkPoint> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkPoint>(),
8usize,
concat!("Size of: ", stringify!(_GdkPoint))
);
assert_eq!(
::std::mem::align_of::<_GdkPoint>(),
4usize,
concat!("Alignment of ", stringify!(_GdkPoint))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkPoint),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_GdkPoint),
"::",
stringify!(y)
)
);
}
pub const GdkDragAction_GDK_ACTION_DEFAULT: GdkDragAction = 1;
pub const GdkDragAction_GDK_ACTION_COPY: GdkDragAction = 2;
pub const GdkDragAction_GDK_ACTION_MOVE: GdkDragAction = 4;
pub const GdkDragAction_GDK_ACTION_LINK: GdkDragAction = 8;
pub const GdkDragAction_GDK_ACTION_PRIVATE: GdkDragAction = 16;
pub const GdkDragAction_GDK_ACTION_ASK: GdkDragAction = 32;
#[doc = " GdkDragAction:\n @GDK_ACTION_DEFAULT: Means nothing, and should not be used.\n @GDK_ACTION_COPY: Copy the data.\n @GDK_ACTION_MOVE: Move the data, i.e. first copy it, then delete\n it from the source using the DELETE target of the X selection protocol.\n @GDK_ACTION_LINK: Add a link to the data. Note that this is only\n useful if source and destination agree on what it means.\n @GDK_ACTION_PRIVATE: Special action which tells the source that the\n destination will do something that the source doesn’t understand.\n @GDK_ACTION_ASK: Ask the user what to do with the data.\n\n Used in #GdkDragContext to indicate what the destination\n should do with the dropped data."]
pub type GdkDragAction = ::std::os::raw::c_uint;
pub const GdkDragProtocol_GDK_DRAG_PROTO_NONE: GdkDragProtocol = 0;
pub const GdkDragProtocol_GDK_DRAG_PROTO_MOTIF: GdkDragProtocol = 1;
pub const GdkDragProtocol_GDK_DRAG_PROTO_XDND: GdkDragProtocol = 2;
pub const GdkDragProtocol_GDK_DRAG_PROTO_ROOTWIN: GdkDragProtocol = 3;
pub const GdkDragProtocol_GDK_DRAG_PROTO_WIN32_DROPFILES: GdkDragProtocol = 4;
pub const GdkDragProtocol_GDK_DRAG_PROTO_OLE2: GdkDragProtocol = 5;
pub const GdkDragProtocol_GDK_DRAG_PROTO_LOCAL: GdkDragProtocol = 6;
pub const GdkDragProtocol_GDK_DRAG_PROTO_WAYLAND: GdkDragProtocol = 7;
#[doc = " GdkDragProtocol:\n @GDK_DRAG_PROTO_NONE: no protocol.\n @GDK_DRAG_PROTO_MOTIF: The Motif DND protocol. No longer supported\n @GDK_DRAG_PROTO_XDND: The Xdnd protocol.\n @GDK_DRAG_PROTO_ROOTWIN: An extension to the Xdnd protocol for\n unclaimed root window drops.\n @GDK_DRAG_PROTO_WIN32_DROPFILES: The simple WM_DROPFILES protocol.\n @GDK_DRAG_PROTO_OLE2: The complex OLE2 DND protocol (not implemented).\n @GDK_DRAG_PROTO_LOCAL: Intra-application DND.\n @GDK_DRAG_PROTO_WAYLAND: Wayland DND protocol.\n\n Used in #GdkDragContext to indicate the protocol according to\n which DND is done."]
pub type GdkDragProtocol = ::std::os::raw::c_uint;
#[doc = " GdkEventAny:\n @type: the type of the event.\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n\n Contains the fields which are common to all event structs.\n Any event pointer can safely be cast to a pointer to a #GdkEventAny to\n access these fields."]
pub type GdkEventAny = _GdkEventAny;
#[doc = " GdkEventExpose:\n @type: the type of the event (%GDK_EXPOSE or %GDK_DAMAGE).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @area: bounding box of @region.\n @region: the region that needs to be redrawn.\n @count: the number of contiguous %GDK_EXPOSE events following this one.\n The only use for this is “exposure compression”, i.e. handling all\n contiguous %GDK_EXPOSE events in one go, though GDK performs some\n exposure compression so this is not normally needed.\n\n Generated when all or part of a window becomes visible and needs to be\n redrawn."]
pub type GdkEventExpose = _GdkEventExpose;
#[doc = " GdkEventVisibility:\n @type: the type of the event (%GDK_VISIBILITY_NOTIFY).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @state: the new visibility state (%GDK_VISIBILITY_FULLY_OBSCURED,\n %GDK_VISIBILITY_PARTIAL or %GDK_VISIBILITY_UNOBSCURED).\n\n Generated when the window visibility status has changed.\n\n Deprecated: 3.12: Modern composited windowing systems with pervasive\n transparency make it impossible to track the visibility of a window\n reliably, so this event can not be guaranteed to provide useful\n information."]
pub type GdkEventVisibility = _GdkEventVisibility;
#[doc = " GdkEventMotion:\n @type: the type of the event.\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @time: the time of the event in milliseconds.\n @x: the x coordinate of the pointer relative to the window.\n @y: the y coordinate of the pointer relative to the window.\n @axes: @x, @y translated to the axes of @device, or %NULL if @device is\n the mouse.\n @state: (type GdkModifierType): a bit-mask representing the state of\n the modifier keys (e.g. Control, Shift and Alt) and the pointer\n buttons. See #GdkModifierType.\n @is_hint: set to 1 if this event is just a hint, see the\n %GDK_POINTER_MOTION_HINT_MASK value of #GdkEventMask.\n @device: the master device that the event originated from. Use\n gdk_event_get_source_device() to get the slave device.\n @x_root: the x coordinate of the pointer relative to the root of the\n screen.\n @y_root: the y coordinate of the pointer relative to the root of the\n screen.\n\n Generated when the pointer moves."]
pub type GdkEventMotion = _GdkEventMotion;
#[doc = " GdkEventButton:\n @type: the type of the event (%GDK_BUTTON_PRESS, %GDK_2BUTTON_PRESS,\n %GDK_3BUTTON_PRESS or %GDK_BUTTON_RELEASE).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @time: the time of the event in milliseconds.\n @x: the x coordinate of the pointer relative to the window.\n @y: the y coordinate of the pointer relative to the window.\n @axes: @x, @y translated to the axes of @device, or %NULL if @device is\n the mouse.\n @state: (type GdkModifierType): a bit-mask representing the state of\n the modifier keys (e.g. Control, Shift and Alt) and the pointer\n buttons. See #GdkModifierType.\n @button: the button which was pressed or released, numbered from 1 to 5.\n Normally button 1 is the left mouse button, 2 is the middle button,\n and 3 is the right button. On 2-button mice, the middle button can\n often be simulated by pressing both mouse buttons together.\n @device: the master device that the event originated from. Use\n gdk_event_get_source_device() to get the slave device.\n @x_root: the x coordinate of the pointer relative to the root of the\n screen.\n @y_root: the y coordinate of the pointer relative to the root of the\n screen.\n\n Used for button press and button release events. The\n @type field will be one of %GDK_BUTTON_PRESS,\n %GDK_2BUTTON_PRESS, %GDK_3BUTTON_PRESS or %GDK_BUTTON_RELEASE,\n\n Double and triple-clicks result in a sequence of events being received.\n For double-clicks the order of events will be:\n\n - %GDK_BUTTON_PRESS\n - %GDK_BUTTON_RELEASE\n - %GDK_BUTTON_PRESS\n - %GDK_2BUTTON_PRESS\n - %GDK_BUTTON_RELEASE\n\n Note that the first click is received just like a normal\n button press, while the second click results in a %GDK_2BUTTON_PRESS\n being received just after the %GDK_BUTTON_PRESS.\n\n Triple-clicks are very similar to double-clicks, except that\n %GDK_3BUTTON_PRESS is inserted after the third click. The order of the\n events is:\n\n - %GDK_BUTTON_PRESS\n - %GDK_BUTTON_RELEASE\n - %GDK_BUTTON_PRESS\n - %GDK_2BUTTON_PRESS\n - %GDK_BUTTON_RELEASE\n - %GDK_BUTTON_PRESS\n - %GDK_3BUTTON_PRESS\n - %GDK_BUTTON_RELEASE\n\n For a double click to occur, the second button press must occur within\n 1/4 of a second of the first. For a triple click to occur, the third\n button press must also occur within 1/2 second of the first button press."]
pub type GdkEventButton = _GdkEventButton;
#[doc = " GdkEventTouch:\n @type: the type of the event (%GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE,\n %GDK_TOUCH_END, %GDK_TOUCH_CANCEL)\n @window: the window which received the event\n @send_event: %TRUE if the event was sent explicitly.\n @time: the time of the event in milliseconds.\n @x: the x coordinate of the pointer relative to the window\n @y: the y coordinate of the pointer relative to the window\n @axes: @x, @y translated to the axes of @device, or %NULL if @device is\n the mouse\n @state: (type GdkModifierType): a bit-mask representing the state of\n the modifier keys (e.g. Control, Shift and Alt) and the pointer\n buttons. See #GdkModifierType\n @sequence: the event sequence that the event belongs to\n @emulating_pointer: whether the event should be used for emulating\n pointer event\n @device: the master device that the event originated from. Use\n gdk_event_get_source_device() to get the slave device.\n @x_root: the x coordinate of the pointer relative to the root of the\n screen\n @y_root: the y coordinate of the pointer relative to the root of the\n screen\n\n Used for touch events.\n @type field will be one of %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE,\n %GDK_TOUCH_END or %GDK_TOUCH_CANCEL.\n\n Touch events are grouped into sequences by means of the @sequence\n field, which can also be obtained with gdk_event_get_event_sequence().\n Each sequence begins with a %GDK_TOUCH_BEGIN event, followed by\n any number of %GDK_TOUCH_UPDATE events, and ends with a %GDK_TOUCH_END\n (or %GDK_TOUCH_CANCEL) event. With multitouch devices, there may be\n several active sequences at the same time."]
pub type GdkEventTouch = _GdkEventTouch;
#[doc = " GdkEventScroll:\n @type: the type of the event (%GDK_SCROLL).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @time: the time of the event in milliseconds.\n @x: the x coordinate of the pointer relative to the window.\n @y: the y coordinate of the pointer relative to the window.\n @state: (type GdkModifierType): a bit-mask representing the state of\n the modifier keys (e.g. Control, Shift and Alt) and the pointer\n buttons. See #GdkModifierType.\n @direction: the direction to scroll to (one of %GDK_SCROLL_UP,\n %GDK_SCROLL_DOWN, %GDK_SCROLL_LEFT, %GDK_SCROLL_RIGHT or\n %GDK_SCROLL_SMOOTH).\n @device: the master device that the event originated from. Use\n gdk_event_get_source_device() to get the slave device.\n @x_root: the x coordinate of the pointer relative to the root of the\n screen.\n @y_root: the y coordinate of the pointer relative to the root of the\n screen.\n @delta_x: the x coordinate of the scroll delta\n @delta_y: the y coordinate of the scroll delta\n\n Generated from button presses for the buttons 4 to 7. Wheel mice are\n usually configured to generate button press events for buttons 4 and 5\n when the wheel is turned.\n\n Some GDK backends can also generate “smooth” scroll events, which\n can be recognized by the %GDK_SCROLL_SMOOTH scroll direction. For\n these, the scroll deltas can be obtained with\n gdk_event_get_scroll_deltas()."]
pub type GdkEventScroll = _GdkEventScroll;
#[doc = " GdkEventKey:\n @type: the type of the event (%GDK_KEY_PRESS or %GDK_KEY_RELEASE).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @time: the time of the event in milliseconds.\n @state: (type GdkModifierType): a bit-mask representing the state of\n the modifier keys (e.g. Control, Shift and Alt) and the pointer\n buttons. See #GdkModifierType.\n @keyval: the key that was pressed or released. See the\n `gdk/gdkkeysyms.h` header file for a\n complete list of GDK key codes.\n @length: the length of @string.\n @string: a string containing an approximation of the text that\n would result from this keypress. The only correct way to handle text\n input of text is using input methods (see #GtkIMContext), so this\n field is deprecated and should never be used.\n (gdk_unicode_to_keyval() provides a non-deprecated way of getting\n an approximate translation for a key.) The string is encoded in the\n encoding of the current locale (Note: this for backwards compatibility:\n strings in GTK+ and GDK are typically in UTF-8.) and NUL-terminated.\n In some cases, the translation of the key code will be a single\n NUL byte, in which case looking at @length is necessary to distinguish\n it from the an empty translation.\n @hardware_keycode: the raw code of the key that was pressed or released.\n @group: the keyboard group.\n @is_modifier: a flag that indicates if @hardware_keycode is mapped to a\n modifier. Since 2.10\n\n Describes a key press or key release event."]
pub type GdkEventKey = _GdkEventKey;
#[doc = " GdkEventFocus:\n @type: the type of the event (%GDK_FOCUS_CHANGE).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @in: %TRUE if the window has gained the keyboard focus, %FALSE if\n it has lost the focus.\n\n Describes a change of keyboard focus."]
pub type GdkEventFocus = _GdkEventFocus;
#[doc = " GdkEventCrossing:\n @type: the type of the event (%GDK_ENTER_NOTIFY or %GDK_LEAVE_NOTIFY).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @subwindow: the window that was entered or left.\n @time: the time of the event in milliseconds.\n @x: the x coordinate of the pointer relative to the window.\n @y: the y coordinate of the pointer relative to the window.\n @x_root: the x coordinate of the pointer relative to the root of the screen.\n @y_root: the y coordinate of the pointer relative to the root of the screen.\n @mode: the crossing mode (%GDK_CROSSING_NORMAL, %GDK_CROSSING_GRAB,\n %GDK_CROSSING_UNGRAB, %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB or\n %GDK_CROSSING_STATE_CHANGED). %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB,\n and %GDK_CROSSING_STATE_CHANGED were added in 2.14 and are always synthesized,\n never native.\n @detail: the kind of crossing that happened (%GDK_NOTIFY_INFERIOR,\n %GDK_NOTIFY_ANCESTOR, %GDK_NOTIFY_VIRTUAL, %GDK_NOTIFY_NONLINEAR or\n %GDK_NOTIFY_NONLINEAR_VIRTUAL).\n @focus: %TRUE if @window is the focus window or an inferior.\n @state: (type GdkModifierType): a bit-mask representing the state of\n the modifier keys (e.g. Control, Shift and Alt) and the pointer\n buttons. See #GdkModifierType.\n\n Generated when the pointer enters or leaves a window."]
pub type GdkEventCrossing = _GdkEventCrossing;
#[doc = " GdkEventConfigure:\n @type: the type of the event (%GDK_CONFIGURE).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @x: the new x coordinate of the window, relative to its parent.\n @y: the new y coordinate of the window, relative to its parent.\n @width: the new width of the window.\n @height: the new height of the window.\n\n Generated when a window size or position has changed."]
pub type GdkEventConfigure = _GdkEventConfigure;
#[doc = " GdkEventProperty:\n @type: the type of the event (%GDK_PROPERTY_NOTIFY).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @atom: the property that was changed.\n @time: the time of the event in milliseconds.\n @state: (type GdkPropertyState): whether the property was changed\n (%GDK_PROPERTY_NEW_VALUE) or deleted (%GDK_PROPERTY_DELETE).\n\n Describes a property change on a window."]
pub type GdkEventProperty = _GdkEventProperty;
#[doc = " GdkEventSelection:\n @type: the type of the event (%GDK_SELECTION_CLEAR,\n %GDK_SELECTION_NOTIFY or %GDK_SELECTION_REQUEST).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @selection: the selection.\n @target: the target to which the selection should be converted.\n @property: the property in which to place the result of the conversion.\n @time: the time of the event in milliseconds.\n @requestor: the window on which to place @property or %NULL if none.\n\n Generated when a selection is requested or ownership of a selection\n is taken over by another client application."]
pub type GdkEventSelection = _GdkEventSelection;
#[doc = " GdkEventOwnerChange:\n @type: the type of the event (%GDK_OWNER_CHANGE).\n @window: the window which received the event\n @send_event: %TRUE if the event was sent explicitly.\n @owner: the new owner of the selection, or %NULL if there is none\n @reason: the reason for the ownership change as a #GdkOwnerChange value\n @selection: the atom identifying the selection\n @time: the timestamp of the event\n @selection_time: the time at which the selection ownership was taken\n over\n\n Generated when the owner of a selection changes. On X11, this\n information is only available if the X server supports the XFIXES\n extension.\n\n Since: 2.6"]
pub type GdkEventOwnerChange = _GdkEventOwnerChange;
#[doc = " GdkEventProximity:\n @type: the type of the event (%GDK_PROXIMITY_IN or %GDK_PROXIMITY_OUT).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @time: the time of the event in milliseconds.\n @device: the master device that the event originated from. Use\n gdk_event_get_source_device() to get the slave device.\n\n Proximity events are generated when using GDK’s wrapper for the\n XInput extension. The XInput extension is an add-on for standard X\n that allows you to use nonstandard devices such as graphics tablets.\n A proximity event indicates that the stylus has moved in or out of\n contact with the tablet, or perhaps that the user’s finger has moved\n in or out of contact with a touch screen.\n\n This event type will be used pretty rarely. It only is important for\n XInput aware programs that are drawing their own cursor."]
pub type GdkEventProximity = _GdkEventProximity;
#[doc = " GdkEventDND:\n @type: the type of the event (%GDK_DRAG_ENTER, %GDK_DRAG_LEAVE,\n %GDK_DRAG_MOTION, %GDK_DRAG_STATUS, %GDK_DROP_START or\n %GDK_DROP_FINISHED).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @context: the #GdkDragContext for the current DND operation.\n @time: the time of the event in milliseconds.\n @x_root: the x coordinate of the pointer relative to the root of the\n screen, only set for %GDK_DRAG_MOTION and %GDK_DROP_START.\n @y_root: the y coordinate of the pointer relative to the root of the\n screen, only set for %GDK_DRAG_MOTION and %GDK_DROP_START.\n\n Generated during DND operations."]
pub type GdkEventDND = _GdkEventDND;
#[doc = " GdkEventWindowState:\n @type: the type of the event (%GDK_WINDOW_STATE).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @changed_mask: mask specifying what flags have changed.\n @new_window_state: the new window state, a combination of\n #GdkWindowState bits.\n\n Generated when the state of a toplevel window changes."]
pub type GdkEventWindowState = _GdkEventWindowState;
#[doc = " GdkEventSetting:\n @type: the type of the event (%GDK_SETTING).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @action: what happened to the setting (%GDK_SETTING_ACTION_NEW,\n %GDK_SETTING_ACTION_CHANGED or %GDK_SETTING_ACTION_DELETED).\n @name: the name of the setting.\n\n Generated when a setting is modified."]
pub type GdkEventSetting = _GdkEventSetting;
#[doc = " GdkEventGrabBroken:\n @type: the type of the event (%GDK_GRAB_BROKEN)\n @window: the window which received the event, i.e. the window\n that previously owned the grab\n @send_event: %TRUE if the event was sent explicitly.\n @keyboard: %TRUE if a keyboard grab was broken, %FALSE if a pointer\n grab was broken\n @implicit: %TRUE if the broken grab was implicit\n @grab_window: If this event is caused by another grab in the same\n application, @grab_window contains the new grab window. Otherwise\n @grab_window is %NULL.\n\n Generated when a pointer or keyboard grab is broken. On X11, this happens\n when the grab window becomes unviewable (i.e. it or one of its ancestors\n is unmapped), or if the same application grabs the pointer or keyboard\n again. Note that implicit grabs (which are initiated by button presses)\n can also cause #GdkEventGrabBroken events.\n\n Since: 2.8"]
pub type GdkEventGrabBroken = _GdkEventGrabBroken;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventSequence {
_unused: [u8; 0],
}
pub type GdkEventSequence = _GdkEventSequence;
#[doc = " GdkEvent:\n @type: the #GdkEventType\n @any: a #GdkEventAny\n @expose: a #GdkEventExpose\n @visibility: a #GdkEventVisibility\n @motion: a #GdkEventMotion\n @button: a #GdkEventButton\n @touch: a #GdkEventTouch\n @scroll: a #GdkEventScroll\n @key: a #GdkEventKey\n @crossing: a #GdkEventCrossing\n @focus_change: a #GdkEventFocus\n @configure: a #GdkEventConfigure\n @property: a #GdkEventProperty\n @selection: a #GdkEventSelection\n @owner_change: a #GdkEventOwnerChange\n @proximity: a #GdkEventProximity\n @dnd: a #GdkEventDND\n @window_state: a #GdkEventWindowState\n @setting: a #GdkEventSetting\n @grab_broken: a #GdkEventGrabBroken\n\n A #GdkEvent contains a union of all of the event types,\n and allows access to the data fields in a number of ways.\n\n The event type is always the first field in all of the event types, and\n can always be accessed with the following code, no matter what type of\n event it is:\n |[<!-- language=\"C\" -->\n GdkEvent *event;\n GdkEventType type;\n\n type = event->type;\n ]|\n\n To access other fields of the event, the pointer to the event\n can be cast to the appropriate event type, or the union member\n name can be used. For example if the event type is %GDK_BUTTON_PRESS\n then the x coordinate of the button press can be accessed with:\n |[<!-- language=\"C\" -->\n GdkEvent *event;\n gdouble x;\n\n x = ((GdkEventButton*)event)->x;\n ]|\n or:\n |[<!-- language=\"C\" -->\n GdkEvent *event;\n gdouble x;\n\n x = event->button.x;\n ]|"]
pub type GdkEvent = _GdkEvent;
pub const GdkEventType_GDK_NOTHING: GdkEventType = -1;
pub const GdkEventType_GDK_DELETE: GdkEventType = 0;
pub const GdkEventType_GDK_DESTROY: GdkEventType = 1;
pub const GdkEventType_GDK_EXPOSE: GdkEventType = 2;
pub const GdkEventType_GDK_MOTION_NOTIFY: GdkEventType = 3;
pub const GdkEventType_GDK_BUTTON_PRESS: GdkEventType = 4;
pub const GdkEventType_GDK_2BUTTON_PRESS: GdkEventType = 5;
pub const GdkEventType_GDK_DOUBLE_BUTTON_PRESS: GdkEventType = 5;
pub const GdkEventType_GDK_3BUTTON_PRESS: GdkEventType = 6;
pub const GdkEventType_GDK_TRIPLE_BUTTON_PRESS: GdkEventType = 6;
pub const GdkEventType_GDK_BUTTON_RELEASE: GdkEventType = 7;
pub const GdkEventType_GDK_KEY_PRESS: GdkEventType = 8;
pub const GdkEventType_GDK_KEY_RELEASE: GdkEventType = 9;
pub const GdkEventType_GDK_ENTER_NOTIFY: GdkEventType = 10;
pub const GdkEventType_GDK_LEAVE_NOTIFY: GdkEventType = 11;
pub const GdkEventType_GDK_FOCUS_CHANGE: GdkEventType = 12;
pub const GdkEventType_GDK_CONFIGURE: GdkEventType = 13;
pub const GdkEventType_GDK_MAP: GdkEventType = 14;
pub const GdkEventType_GDK_UNMAP: GdkEventType = 15;
pub const GdkEventType_GDK_PROPERTY_NOTIFY: GdkEventType = 16;
pub const GdkEventType_GDK_SELECTION_CLEAR: GdkEventType = 17;
pub const GdkEventType_GDK_SELECTION_REQUEST: GdkEventType = 18;
pub const GdkEventType_GDK_SELECTION_NOTIFY: GdkEventType = 19;
pub const GdkEventType_GDK_PROXIMITY_IN: GdkEventType = 20;
pub const GdkEventType_GDK_PROXIMITY_OUT: GdkEventType = 21;
pub const GdkEventType_GDK_DRAG_ENTER: GdkEventType = 22;
pub const GdkEventType_GDK_DRAG_LEAVE: GdkEventType = 23;
pub const GdkEventType_GDK_DRAG_MOTION: GdkEventType = 24;
pub const GdkEventType_GDK_DRAG_STATUS: GdkEventType = 25;
pub const GdkEventType_GDK_DROP_START: GdkEventType = 26;
pub const GdkEventType_GDK_DROP_FINISHED: GdkEventType = 27;
pub const GdkEventType_GDK_CLIENT_EVENT: GdkEventType = 28;
pub const GdkEventType_GDK_VISIBILITY_NOTIFY: GdkEventType = 29;
pub const GdkEventType_GDK_SCROLL: GdkEventType = 31;
pub const GdkEventType_GDK_WINDOW_STATE: GdkEventType = 32;
pub const GdkEventType_GDK_SETTING: GdkEventType = 33;
pub const GdkEventType_GDK_OWNER_CHANGE: GdkEventType = 34;
pub const GdkEventType_GDK_GRAB_BROKEN: GdkEventType = 35;
pub const GdkEventType_GDK_DAMAGE: GdkEventType = 36;
pub const GdkEventType_GDK_TOUCH_BEGIN: GdkEventType = 37;
pub const GdkEventType_GDK_TOUCH_UPDATE: GdkEventType = 38;
pub const GdkEventType_GDK_TOUCH_END: GdkEventType = 39;
pub const GdkEventType_GDK_TOUCH_CANCEL: GdkEventType = 40;
pub const GdkEventType_GDK_EVENT_LAST: GdkEventType = 41;
#[doc = " GdkEventType:\n @GDK_NOTHING: a special code to indicate a null event.\n @GDK_DELETE: the window manager has requested that the toplevel window be\n hidden or destroyed, usually when the user clicks on a special icon in the\n title bar.\n @GDK_DESTROY: the window has been destroyed.\n @GDK_EXPOSE: all or part of the window has become visible and needs to be\n redrawn.\n @GDK_MOTION_NOTIFY: the pointer (usually a mouse) has moved.\n @GDK_BUTTON_PRESS: a mouse button has been pressed.\n @GDK_2BUTTON_PRESS: a mouse button has been double-clicked (clicked twice\n within a short period of time). Note that each click also generates a\n %GDK_BUTTON_PRESS event.\n @GDK_DOUBLE_BUTTON_PRESS: alias for %GDK_2BUTTON_PRESS, added in 3.6.\n @GDK_3BUTTON_PRESS: a mouse button has been clicked 3 times in a short period\n of time. Note that each click also generates a %GDK_BUTTON_PRESS event.\n @GDK_TRIPLE_BUTTON_PRESS: alias for %GDK_3BUTTON_PRESS, added in 3.6.\n @GDK_BUTTON_RELEASE: a mouse button has been released.\n @GDK_KEY_PRESS: a key has been pressed.\n @GDK_KEY_RELEASE: a key has been released.\n @GDK_ENTER_NOTIFY: the pointer has entered the window.\n @GDK_LEAVE_NOTIFY: the pointer has left the window.\n @GDK_FOCUS_CHANGE: the keyboard focus has entered or left the window.\n @GDK_CONFIGURE: the size, position or stacking order of the window has changed.\n Note that GTK+ discards these events for %GDK_WINDOW_CHILD windows.\n @GDK_MAP: the window has been mapped.\n @GDK_UNMAP: the window has been unmapped.\n @GDK_PROPERTY_NOTIFY: a property on the window has been changed or deleted.\n @GDK_SELECTION_CLEAR: the application has lost ownership of a selection.\n @GDK_SELECTION_REQUEST: another application has requested a selection.\n @GDK_SELECTION_NOTIFY: a selection has been received.\n @GDK_PROXIMITY_IN: an input device has moved into contact with a sensing\n surface (e.g. a touchscreen or graphics tablet).\n @GDK_PROXIMITY_OUT: an input device has moved out of contact with a sensing\n surface.\n @GDK_DRAG_ENTER: the mouse has entered the window while a drag is in progress.\n @GDK_DRAG_LEAVE: the mouse has left the window while a drag is in progress.\n @GDK_DRAG_MOTION: the mouse has moved in the window while a drag is in\n progress.\n @GDK_DRAG_STATUS: the status of the drag operation initiated by the window\n has changed.\n @GDK_DROP_START: a drop operation onto the window has started.\n @GDK_DROP_FINISHED: the drop operation initiated by the window has completed.\n @GDK_CLIENT_EVENT: a message has been received from another application.\n @GDK_VISIBILITY_NOTIFY: the window visibility status has changed.\n @GDK_SCROLL: the scroll wheel was turned\n @GDK_WINDOW_STATE: the state of a window has changed. See #GdkWindowState\n for the possible window states\n @GDK_SETTING: a setting has been modified.\n @GDK_OWNER_CHANGE: the owner of a selection has changed. This event type\n was added in 2.6\n @GDK_GRAB_BROKEN: a pointer or keyboard grab was broken. This event type\n was added in 2.8.\n @GDK_DAMAGE: the content of the window has been changed. This event type\n was added in 2.14.\n @GDK_TOUCH_BEGIN: A new touch event sequence has just started. This event\n type was added in 3.4.\n @GDK_TOUCH_UPDATE: A touch event sequence has been updated. This event type\n was added in 3.4.\n @GDK_TOUCH_END: A touch event sequence has finished. This event type\n was added in 3.4.\n @GDK_TOUCH_CANCEL: A touch event sequence has been canceled. This event type\n was added in 3.4.\n @GDK_EVENT_LAST: marks the end of the GdkEventType enumeration. Added in 2.18\n\n Specifies the type of the event.\n\n Do not confuse these events with the signals that GTK+ widgets emit.\n Although many of these events result in corresponding signals being emitted,\n the events are often transformed or filtered along the way.\n\n In some language bindings, the values %GDK_2BUTTON_PRESS and\n %GDK_3BUTTON_PRESS would translate into something syntactically\n invalid (eg `Gdk.EventType.2ButtonPress`, where a\n symbol is not allowed to start with a number). In that case, the\n aliases %GDK_DOUBLE_BUTTON_PRESS and %GDK_TRIPLE_BUTTON_PRESS can\n be used instead."]
pub type GdkEventType = ::std::os::raw::c_int;
pub const GdkVisibilityState_GDK_VISIBILITY_UNOBSCURED: GdkVisibilityState = 0;
pub const GdkVisibilityState_GDK_VISIBILITY_PARTIAL: GdkVisibilityState = 1;
pub const GdkVisibilityState_GDK_VISIBILITY_FULLY_OBSCURED: GdkVisibilityState = 2;
#[doc = " GdkVisibilityState:\n @GDK_VISIBILITY_UNOBSCURED: the window is completely visible.\n @GDK_VISIBILITY_PARTIAL: the window is partially visible.\n @GDK_VISIBILITY_FULLY_OBSCURED: the window is not visible at all.\n\n Specifies the visiblity status of a window for a #GdkEventVisibility."]
pub type GdkVisibilityState = ::std::os::raw::c_uint;
pub const GdkScrollDirection_GDK_SCROLL_UP: GdkScrollDirection = 0;
pub const GdkScrollDirection_GDK_SCROLL_DOWN: GdkScrollDirection = 1;
pub const GdkScrollDirection_GDK_SCROLL_LEFT: GdkScrollDirection = 2;
pub const GdkScrollDirection_GDK_SCROLL_RIGHT: GdkScrollDirection = 3;
pub const GdkScrollDirection_GDK_SCROLL_SMOOTH: GdkScrollDirection = 4;
#[doc = " GdkScrollDirection:\n @GDK_SCROLL_UP: the window is scrolled up.\n @GDK_SCROLL_DOWN: the window is scrolled down.\n @GDK_SCROLL_LEFT: the window is scrolled to the left.\n @GDK_SCROLL_RIGHT: the window is scrolled to the right.\n @GDK_SCROLL_SMOOTH: the scrolling is determined by the delta values\n in #GdkEventScroll. See gdk_event_get_scroll_deltas(). Since: 3.4\n\n Specifies the direction for #GdkEventScroll."]
pub type GdkScrollDirection = ::std::os::raw::c_uint;
pub const GdkNotifyType_GDK_NOTIFY_ANCESTOR: GdkNotifyType = 0;
pub const GdkNotifyType_GDK_NOTIFY_VIRTUAL: GdkNotifyType = 1;
pub const GdkNotifyType_GDK_NOTIFY_INFERIOR: GdkNotifyType = 2;
pub const GdkNotifyType_GDK_NOTIFY_NONLINEAR: GdkNotifyType = 3;
pub const GdkNotifyType_GDK_NOTIFY_NONLINEAR_VIRTUAL: GdkNotifyType = 4;
pub const GdkNotifyType_GDK_NOTIFY_UNKNOWN: GdkNotifyType = 5;
#[doc = " GdkNotifyType:\n @GDK_NOTIFY_ANCESTOR: the window is entered from an ancestor or\n left towards an ancestor.\n @GDK_NOTIFY_VIRTUAL: the pointer moves between an ancestor and an\n inferior of the window.\n @GDK_NOTIFY_INFERIOR: the window is entered from an inferior or\n left towards an inferior.\n @GDK_NOTIFY_NONLINEAR: the window is entered from or left towards\n a window which is neither an ancestor nor an inferior.\n @GDK_NOTIFY_NONLINEAR_VIRTUAL: the pointer moves between two windows\n which are not ancestors of each other and the window is part of\n the ancestor chain between one of these windows and their least\n common ancestor.\n @GDK_NOTIFY_UNKNOWN: an unknown type of enter/leave event occurred.\n\n Specifies the kind of crossing for #GdkEventCrossing.\n\n See the X11 protocol specification of LeaveNotify for\n full details of crossing event generation."]
pub type GdkNotifyType = ::std::os::raw::c_uint;
pub const GdkCrossingMode_GDK_CROSSING_NORMAL: GdkCrossingMode = 0;
pub const GdkCrossingMode_GDK_CROSSING_GRAB: GdkCrossingMode = 1;
pub const GdkCrossingMode_GDK_CROSSING_UNGRAB: GdkCrossingMode = 2;
pub const GdkCrossingMode_GDK_CROSSING_GTK_GRAB: GdkCrossingMode = 3;
pub const GdkCrossingMode_GDK_CROSSING_GTK_UNGRAB: GdkCrossingMode = 4;
pub const GdkCrossingMode_GDK_CROSSING_STATE_CHANGED: GdkCrossingMode = 5;
pub const GdkCrossingMode_GDK_CROSSING_TOUCH_BEGIN: GdkCrossingMode = 6;
pub const GdkCrossingMode_GDK_CROSSING_TOUCH_END: GdkCrossingMode = 7;
pub const GdkCrossingMode_GDK_CROSSING_DEVICE_SWITCH: GdkCrossingMode = 8;
#[doc = " GdkCrossingMode:\n @GDK_CROSSING_NORMAL: crossing because of pointer motion.\n @GDK_CROSSING_GRAB: crossing because a grab is activated.\n @GDK_CROSSING_UNGRAB: crossing because a grab is deactivated.\n @GDK_CROSSING_GTK_GRAB: crossing because a GTK+ grab is activated.\n @GDK_CROSSING_GTK_UNGRAB: crossing because a GTK+ grab is deactivated.\n @GDK_CROSSING_STATE_CHANGED: crossing because a GTK+ widget changed\n state (e.g. sensitivity).\n @GDK_CROSSING_TOUCH_BEGIN: crossing because a touch sequence has begun,\n this event is synthetic as the pointer might have not left the window.\n @GDK_CROSSING_TOUCH_END: crossing because a touch sequence has ended,\n this event is synthetic as the pointer might have not left the window.\n @GDK_CROSSING_DEVICE_SWITCH: crossing because of a device switch (i.e.\n a mouse taking control of the pointer after a touch device), this event\n is synthetic as the pointer didn’t leave the window.\n\n Specifies the crossing mode for #GdkEventCrossing."]
pub type GdkCrossingMode = ::std::os::raw::c_uint;
pub const GdkWindowState_GDK_WINDOW_STATE_WITHDRAWN: GdkWindowState = 1;
pub const GdkWindowState_GDK_WINDOW_STATE_ICONIFIED: GdkWindowState = 2;
pub const GdkWindowState_GDK_WINDOW_STATE_MAXIMIZED: GdkWindowState = 4;
pub const GdkWindowState_GDK_WINDOW_STATE_STICKY: GdkWindowState = 8;
pub const GdkWindowState_GDK_WINDOW_STATE_FULLSCREEN: GdkWindowState = 16;
pub const GdkWindowState_GDK_WINDOW_STATE_ABOVE: GdkWindowState = 32;
pub const GdkWindowState_GDK_WINDOW_STATE_BELOW: GdkWindowState = 64;
pub const GdkWindowState_GDK_WINDOW_STATE_FOCUSED: GdkWindowState = 128;
pub const GdkWindowState_GDK_WINDOW_STATE_TILED: GdkWindowState = 256;
#[doc = " GdkWindowState:\n @GDK_WINDOW_STATE_WITHDRAWN: the window is not shown.\n @GDK_WINDOW_STATE_ICONIFIED: the window is minimized.\n @GDK_WINDOW_STATE_MAXIMIZED: the window is maximized.\n @GDK_WINDOW_STATE_STICKY: the window is sticky.\n @GDK_WINDOW_STATE_FULLSCREEN: the window is maximized without\n decorations.\n @GDK_WINDOW_STATE_ABOVE: the window is kept above other windows.\n @GDK_WINDOW_STATE_BELOW: the window is kept below other windows.\n @GDK_WINDOW_STATE_FOCUSED: the window is presented as focused (with active decorations).\n @GDK_WINDOW_STATE_TILED: the window is in a tiled state, Since 3.10\n\n Specifies the state of a toplevel window."]
pub type GdkWindowState = ::std::os::raw::c_uint;
pub const GdkSettingAction_GDK_SETTING_ACTION_NEW: GdkSettingAction = 0;
pub const GdkSettingAction_GDK_SETTING_ACTION_CHANGED: GdkSettingAction = 1;
pub const GdkSettingAction_GDK_SETTING_ACTION_DELETED: GdkSettingAction = 2;
#[doc = " GdkSettingAction:\n @GDK_SETTING_ACTION_NEW: a setting was added.\n @GDK_SETTING_ACTION_CHANGED: a setting was changed.\n @GDK_SETTING_ACTION_DELETED: a setting was deleted.\n\n Specifies the kind of modification applied to a setting in a\n #GdkEventSetting."]
pub type GdkSettingAction = ::std::os::raw::c_uint;
pub const GdkOwnerChange_GDK_OWNER_CHANGE_NEW_OWNER: GdkOwnerChange = 0;
pub const GdkOwnerChange_GDK_OWNER_CHANGE_DESTROY: GdkOwnerChange = 1;
pub const GdkOwnerChange_GDK_OWNER_CHANGE_CLOSE: GdkOwnerChange = 2;
#[doc = " GdkOwnerChange:\n @GDK_OWNER_CHANGE_NEW_OWNER: some other app claimed the ownership\n @GDK_OWNER_CHANGE_DESTROY: the window was destroyed\n @GDK_OWNER_CHANGE_CLOSE: the client was closed\n\n Specifies why a selection ownership was changed."]
pub type GdkOwnerChange = ::std::os::raw::c_uint;
#[doc = " GdkEventAny:\n @type: the type of the event.\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n\n Contains the fields which are common to all event structs.\n Any event pointer can safely be cast to a pointer to a #GdkEventAny to\n access these fields."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventAny {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
}
#[test]
fn bindgen_test_layout__GdkEventAny() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventAny> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventAny>(),
24usize,
concat!("Size of: ", stringify!(_GdkEventAny))
);
assert_eq!(
::std::mem::align_of::<_GdkEventAny>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventAny))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventAny),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventAny),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventAny),
"::",
stringify!(send_event)
)
);
}
impl Default for _GdkEventAny {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventExpose:\n @type: the type of the event (%GDK_EXPOSE or %GDK_DAMAGE).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @area: bounding box of @region.\n @region: the region that needs to be redrawn.\n @count: the number of contiguous %GDK_EXPOSE events following this one.\n The only use for this is “exposure compression”, i.e. handling all\n contiguous %GDK_EXPOSE events in one go, though GDK performs some\n exposure compression so this is not normally needed.\n\n Generated when all or part of a window becomes visible and needs to be\n redrawn."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventExpose {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub area: GdkRectangle,
pub region: *mut cairo_region_t,
pub count: gint,
}
#[test]
fn bindgen_test_layout__GdkEventExpose() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventExpose> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventExpose>(),
56usize,
concat!("Size of: ", stringify!(_GdkEventExpose))
);
assert_eq!(
::std::mem::align_of::<_GdkEventExpose>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventExpose))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventExpose),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventExpose),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventExpose),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).area) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventExpose),
"::",
stringify!(area)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).region) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventExpose),
"::",
stringify!(region)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventExpose),
"::",
stringify!(count)
)
);
}
impl Default for _GdkEventExpose {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventVisibility:\n @type: the type of the event (%GDK_VISIBILITY_NOTIFY).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @state: the new visibility state (%GDK_VISIBILITY_FULLY_OBSCURED,\n %GDK_VISIBILITY_PARTIAL or %GDK_VISIBILITY_UNOBSCURED).\n\n Generated when the window visibility status has changed.\n\n Deprecated: 3.12: Modern composited windowing systems with pervasive\n transparency make it impossible to track the visibility of a window\n reliably, so this event can not be guaranteed to provide useful\n information."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventVisibility {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub state: GdkVisibilityState,
}
#[test]
fn bindgen_test_layout__GdkEventVisibility() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventVisibility> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventVisibility>(),
24usize,
concat!("Size of: ", stringify!(_GdkEventVisibility))
);
assert_eq!(
::std::mem::align_of::<_GdkEventVisibility>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventVisibility))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventVisibility),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventVisibility),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventVisibility),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventVisibility),
"::",
stringify!(state)
)
);
}
impl Default for _GdkEventVisibility {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventMotion:\n @type: the type of the event.\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @time: the time of the event in milliseconds.\n @x: the x coordinate of the pointer relative to the window.\n @y: the y coordinate of the pointer relative to the window.\n @axes: @x, @y translated to the axes of @device, or %NULL if @device is\n the mouse.\n @state: (type GdkModifierType): a bit-mask representing the state of\n the modifier keys (e.g. Control, Shift and Alt) and the pointer\n buttons. See #GdkModifierType.\n @is_hint: set to 1 if this event is just a hint, see the\n %GDK_POINTER_MOTION_HINT_MASK value of #GdkEventMask.\n @device: the master device that the event originated from. Use\n gdk_event_get_source_device() to get the slave device.\n @x_root: the x coordinate of the pointer relative to the root of the\n screen.\n @y_root: the y coordinate of the pointer relative to the root of the\n screen.\n\n Generated when the pointer moves."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventMotion {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub time: guint32,
pub x: gdouble,
pub y: gdouble,
pub axes: *mut gdouble,
pub state: guint,
pub is_hint: gint16,
pub device: *mut GdkDevice,
pub x_root: gdouble,
pub y_root: gdouble,
}
#[test]
fn bindgen_test_layout__GdkEventMotion() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventMotion> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventMotion>(),
80usize,
concat!("Size of: ", stringify!(_GdkEventMotion))
);
assert_eq!(
::std::mem::align_of::<_GdkEventMotion>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventMotion))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventMotion),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventMotion),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventMotion),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventMotion),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventMotion),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventMotion),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).axes) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventMotion),
"::",
stringify!(axes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventMotion),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_hint) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventMotion),
"::",
stringify!(is_hint)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).device) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventMotion),
"::",
stringify!(device)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_root) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventMotion),
"::",
stringify!(x_root)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_root) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventMotion),
"::",
stringify!(y_root)
)
);
}
impl Default for _GdkEventMotion {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventButton:\n @type: the type of the event (%GDK_BUTTON_PRESS, %GDK_2BUTTON_PRESS,\n %GDK_3BUTTON_PRESS or %GDK_BUTTON_RELEASE).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @time: the time of the event in milliseconds.\n @x: the x coordinate of the pointer relative to the window.\n @y: the y coordinate of the pointer relative to the window.\n @axes: @x, @y translated to the axes of @device, or %NULL if @device is\n the mouse.\n @state: (type GdkModifierType): a bit-mask representing the state of\n the modifier keys (e.g. Control, Shift and Alt) and the pointer\n buttons. See #GdkModifierType.\n @button: the button which was pressed or released, numbered from 1 to 5.\n Normally button 1 is the left mouse button, 2 is the middle button,\n and 3 is the right button. On 2-button mice, the middle button can\n often be simulated by pressing both mouse buttons together.\n @device: the master device that the event originated from. Use\n gdk_event_get_source_device() to get the slave device.\n @x_root: the x coordinate of the pointer relative to the root of the\n screen.\n @y_root: the y coordinate of the pointer relative to the root of the\n screen.\n\n Used for button press and button release events. The\n @type field will be one of %GDK_BUTTON_PRESS,\n %GDK_2BUTTON_PRESS, %GDK_3BUTTON_PRESS or %GDK_BUTTON_RELEASE,\n\n Double and triple-clicks result in a sequence of events being received.\n For double-clicks the order of events will be:\n\n - %GDK_BUTTON_PRESS\n - %GDK_BUTTON_RELEASE\n - %GDK_BUTTON_PRESS\n - %GDK_2BUTTON_PRESS\n - %GDK_BUTTON_RELEASE\n\n Note that the first click is received just like a normal\n button press, while the second click results in a %GDK_2BUTTON_PRESS\n being received just after the %GDK_BUTTON_PRESS.\n\n Triple-clicks are very similar to double-clicks, except that\n %GDK_3BUTTON_PRESS is inserted after the third click. The order of the\n events is:\n\n - %GDK_BUTTON_PRESS\n - %GDK_BUTTON_RELEASE\n - %GDK_BUTTON_PRESS\n - %GDK_2BUTTON_PRESS\n - %GDK_BUTTON_RELEASE\n - %GDK_BUTTON_PRESS\n - %GDK_3BUTTON_PRESS\n - %GDK_BUTTON_RELEASE\n\n For a double click to occur, the second button press must occur within\n 1/4 of a second of the first. For a triple click to occur, the third\n button press must also occur within 1/2 second of the first button press."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventButton {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub time: guint32,
pub x: gdouble,
pub y: gdouble,
pub axes: *mut gdouble,
pub state: guint,
pub button: guint,
pub device: *mut GdkDevice,
pub x_root: gdouble,
pub y_root: gdouble,
}
#[test]
fn bindgen_test_layout__GdkEventButton() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventButton>(),
80usize,
concat!("Size of: ", stringify!(_GdkEventButton))
);
assert_eq!(
::std::mem::align_of::<_GdkEventButton>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventButton),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventButton),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventButton),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventButton),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventButton),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventButton),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).axes) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventButton),
"::",
stringify!(axes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventButton),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventButton),
"::",
stringify!(button)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).device) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventButton),
"::",
stringify!(device)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_root) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventButton),
"::",
stringify!(x_root)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_root) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventButton),
"::",
stringify!(y_root)
)
);
}
impl Default for _GdkEventButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventTouch:\n @type: the type of the event (%GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE,\n %GDK_TOUCH_END, %GDK_TOUCH_CANCEL)\n @window: the window which received the event\n @send_event: %TRUE if the event was sent explicitly.\n @time: the time of the event in milliseconds.\n @x: the x coordinate of the pointer relative to the window\n @y: the y coordinate of the pointer relative to the window\n @axes: @x, @y translated to the axes of @device, or %NULL if @device is\n the mouse\n @state: (type GdkModifierType): a bit-mask representing the state of\n the modifier keys (e.g. Control, Shift and Alt) and the pointer\n buttons. See #GdkModifierType\n @sequence: the event sequence that the event belongs to\n @emulating_pointer: whether the event should be used for emulating\n pointer event\n @device: the master device that the event originated from. Use\n gdk_event_get_source_device() to get the slave device.\n @x_root: the x coordinate of the pointer relative to the root of the\n screen\n @y_root: the y coordinate of the pointer relative to the root of the\n screen\n\n Used for touch events.\n @type field will be one of %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE,\n %GDK_TOUCH_END or %GDK_TOUCH_CANCEL.\n\n Touch events are grouped into sequences by means of the @sequence\n field, which can also be obtained with gdk_event_get_event_sequence().\n Each sequence begins with a %GDK_TOUCH_BEGIN event, followed by\n any number of %GDK_TOUCH_UPDATE events, and ends with a %GDK_TOUCH_END\n (or %GDK_TOUCH_CANCEL) event. With multitouch devices, there may be\n several active sequences at the same time."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventTouch {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub time: guint32,
pub x: gdouble,
pub y: gdouble,
pub axes: *mut gdouble,
pub state: guint,
pub sequence: *mut GdkEventSequence,
pub emulating_pointer: gboolean,
pub device: *mut GdkDevice,
pub x_root: gdouble,
pub y_root: gdouble,
}
#[test]
fn bindgen_test_layout__GdkEventTouch() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventTouch> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventTouch>(),
96usize,
concat!("Size of: ", stringify!(_GdkEventTouch))
);
assert_eq!(
::std::mem::align_of::<_GdkEventTouch>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventTouch))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventTouch),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventTouch),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventTouch),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventTouch),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventTouch),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventTouch),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).axes) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventTouch),
"::",
stringify!(axes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventTouch),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sequence) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventTouch),
"::",
stringify!(sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).emulating_pointer) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventTouch),
"::",
stringify!(emulating_pointer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).device) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventTouch),
"::",
stringify!(device)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_root) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventTouch),
"::",
stringify!(x_root)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_root) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventTouch),
"::",
stringify!(y_root)
)
);
}
impl Default for _GdkEventTouch {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventScroll:\n @type: the type of the event (%GDK_SCROLL).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @time: the time of the event in milliseconds.\n @x: the x coordinate of the pointer relative to the window.\n @y: the y coordinate of the pointer relative to the window.\n @state: (type GdkModifierType): a bit-mask representing the state of\n the modifier keys (e.g. Control, Shift and Alt) and the pointer\n buttons. See #GdkModifierType.\n @direction: the direction to scroll to (one of %GDK_SCROLL_UP,\n %GDK_SCROLL_DOWN, %GDK_SCROLL_LEFT, %GDK_SCROLL_RIGHT or\n %GDK_SCROLL_SMOOTH).\n @device: the master device that the event originated from. Use\n gdk_event_get_source_device() to get the slave device.\n @x_root: the x coordinate of the pointer relative to the root of the\n screen.\n @y_root: the y coordinate of the pointer relative to the root of the\n screen.\n @delta_x: the x coordinate of the scroll delta\n @delta_y: the y coordinate of the scroll delta\n\n Generated from button presses for the buttons 4 to 7. Wheel mice are\n usually configured to generate button press events for buttons 4 and 5\n when the wheel is turned.\n\n Some GDK backends can also generate “smooth” scroll events, which\n can be recognized by the %GDK_SCROLL_SMOOTH scroll direction. For\n these, the scroll deltas can be obtained with\n gdk_event_get_scroll_deltas()."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventScroll {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub time: guint32,
pub x: gdouble,
pub y: gdouble,
pub state: guint,
pub direction: GdkScrollDirection,
pub device: *mut GdkDevice,
pub x_root: gdouble,
pub y_root: gdouble,
pub delta_x: gdouble,
pub delta_y: gdouble,
}
#[test]
fn bindgen_test_layout__GdkEventScroll() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventScroll> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventScroll>(),
88usize,
concat!("Size of: ", stringify!(_GdkEventScroll))
);
assert_eq!(
::std::mem::align_of::<_GdkEventScroll>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventScroll))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventScroll),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventScroll),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventScroll),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventScroll),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventScroll),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventScroll),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventScroll),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventScroll),
"::",
stringify!(direction)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).device) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventScroll),
"::",
stringify!(device)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_root) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventScroll),
"::",
stringify!(x_root)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_root) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventScroll),
"::",
stringify!(y_root)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).delta_x) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventScroll),
"::",
stringify!(delta_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).delta_y) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventScroll),
"::",
stringify!(delta_y)
)
);
}
impl Default for _GdkEventScroll {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventKey:\n @type: the type of the event (%GDK_KEY_PRESS or %GDK_KEY_RELEASE).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @time: the time of the event in milliseconds.\n @state: (type GdkModifierType): a bit-mask representing the state of\n the modifier keys (e.g. Control, Shift and Alt) and the pointer\n buttons. See #GdkModifierType.\n @keyval: the key that was pressed or released. See the\n `gdk/gdkkeysyms.h` header file for a\n complete list of GDK key codes.\n @length: the length of @string.\n @string: a string containing an approximation of the text that\n would result from this keypress. The only correct way to handle text\n input of text is using input methods (see #GtkIMContext), so this\n field is deprecated and should never be used.\n (gdk_unicode_to_keyval() provides a non-deprecated way of getting\n an approximate translation for a key.) The string is encoded in the\n encoding of the current locale (Note: this for backwards compatibility:\n strings in GTK+ and GDK are typically in UTF-8.) and NUL-terminated.\n In some cases, the translation of the key code will be a single\n NUL byte, in which case looking at @length is necessary to distinguish\n it from the an empty translation.\n @hardware_keycode: the raw code of the key that was pressed or released.\n @group: the keyboard group.\n @is_modifier: a flag that indicates if @hardware_keycode is mapped to a\n modifier. Since 2.10\n\n Describes a key press or key release event."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventKey {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub time: guint32,
pub state: guint,
pub keyval: guint,
pub length: gint,
pub string: *mut gchar,
pub hardware_keycode: guint16,
pub group: guint8,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub __bindgen_padding_0: u32,
}
#[test]
fn bindgen_test_layout__GdkEventKey() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventKey> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventKey>(),
56usize,
concat!("Size of: ", stringify!(_GdkEventKey))
);
assert_eq!(
::std::mem::align_of::<_GdkEventKey>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventKey))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventKey),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventKey),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventKey),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventKey),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventKey),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).keyval) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventKey),
"::",
stringify!(keyval)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventKey),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).string) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventKey),
"::",
stringify!(string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hardware_keycode) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventKey),
"::",
stringify!(hardware_keycode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).group) as usize - ptr as usize },
50usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventKey),
"::",
stringify!(group)
)
);
}
impl Default for _GdkEventKey {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl _GdkEventKey {
#[inline]
pub fn is_modifier(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
}
#[inline]
pub fn set_is_modifier(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(is_modifier: guint) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let is_modifier: u32 = unsafe { ::std::mem::transmute(is_modifier) };
is_modifier as u64
});
__bindgen_bitfield_unit
}
}
#[doc = " GdkEventCrossing:\n @type: the type of the event (%GDK_ENTER_NOTIFY or %GDK_LEAVE_NOTIFY).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @subwindow: the window that was entered or left.\n @time: the time of the event in milliseconds.\n @x: the x coordinate of the pointer relative to the window.\n @y: the y coordinate of the pointer relative to the window.\n @x_root: the x coordinate of the pointer relative to the root of the screen.\n @y_root: the y coordinate of the pointer relative to the root of the screen.\n @mode: the crossing mode (%GDK_CROSSING_NORMAL, %GDK_CROSSING_GRAB,\n %GDK_CROSSING_UNGRAB, %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB or\n %GDK_CROSSING_STATE_CHANGED). %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB,\n and %GDK_CROSSING_STATE_CHANGED were added in 2.14 and are always synthesized,\n never native.\n @detail: the kind of crossing that happened (%GDK_NOTIFY_INFERIOR,\n %GDK_NOTIFY_ANCESTOR, %GDK_NOTIFY_VIRTUAL, %GDK_NOTIFY_NONLINEAR or\n %GDK_NOTIFY_NONLINEAR_VIRTUAL).\n @focus: %TRUE if @window is the focus window or an inferior.\n @state: (type GdkModifierType): a bit-mask representing the state of\n the modifier keys (e.g. Control, Shift and Alt) and the pointer\n buttons. See #GdkModifierType.\n\n Generated when the pointer enters or leaves a window."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventCrossing {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub subwindow: *mut GdkWindow,
pub time: guint32,
pub x: gdouble,
pub y: gdouble,
pub x_root: gdouble,
pub y_root: gdouble,
pub mode: GdkCrossingMode,
pub detail: GdkNotifyType,
pub focus: gboolean,
pub state: guint,
}
#[test]
fn bindgen_test_layout__GdkEventCrossing() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventCrossing> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventCrossing>(),
88usize,
concat!("Size of: ", stringify!(_GdkEventCrossing))
);
assert_eq!(
::std::mem::align_of::<_GdkEventCrossing>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventCrossing))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventCrossing),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventCrossing),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventCrossing),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subwindow) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventCrossing),
"::",
stringify!(subwindow)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventCrossing),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventCrossing),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventCrossing),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_root) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventCrossing),
"::",
stringify!(x_root)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_root) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventCrossing),
"::",
stringify!(y_root)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventCrossing),
"::",
stringify!(mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).detail) as usize - ptr as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventCrossing),
"::",
stringify!(detail)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).focus) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventCrossing),
"::",
stringify!(focus)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventCrossing),
"::",
stringify!(state)
)
);
}
impl Default for _GdkEventCrossing {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventFocus:\n @type: the type of the event (%GDK_FOCUS_CHANGE).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @in: %TRUE if the window has gained the keyboard focus, %FALSE if\n it has lost the focus.\n\n Describes a change of keyboard focus."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventFocus {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub in_: gint16,
}
#[test]
fn bindgen_test_layout__GdkEventFocus() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventFocus> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventFocus>(),
24usize,
concat!("Size of: ", stringify!(_GdkEventFocus))
);
assert_eq!(
::std::mem::align_of::<_GdkEventFocus>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventFocus))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventFocus),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventFocus),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventFocus),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).in_) as usize - ptr as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventFocus),
"::",
stringify!(in_)
)
);
}
impl Default for _GdkEventFocus {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventConfigure:\n @type: the type of the event (%GDK_CONFIGURE).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @x: the new x coordinate of the window, relative to its parent.\n @y: the new y coordinate of the window, relative to its parent.\n @width: the new width of the window.\n @height: the new height of the window.\n\n Generated when a window size or position has changed."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventConfigure {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub x: gint,
pub y: gint,
pub width: gint,
pub height: gint,
}
#[test]
fn bindgen_test_layout__GdkEventConfigure() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventConfigure> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventConfigure>(),
40usize,
concat!("Size of: ", stringify!(_GdkEventConfigure))
);
assert_eq!(
::std::mem::align_of::<_GdkEventConfigure>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventConfigure))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventConfigure),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventConfigure),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventConfigure),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventConfigure),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventConfigure),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventConfigure),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventConfigure),
"::",
stringify!(height)
)
);
}
impl Default for _GdkEventConfigure {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventProperty:\n @type: the type of the event (%GDK_PROPERTY_NOTIFY).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @atom: the property that was changed.\n @time: the time of the event in milliseconds.\n @state: (type GdkPropertyState): whether the property was changed\n (%GDK_PROPERTY_NEW_VALUE) or deleted (%GDK_PROPERTY_DELETE).\n\n Describes a property change on a window."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventProperty {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub atom: GdkAtom,
pub time: guint32,
pub state: guint,
}
#[test]
fn bindgen_test_layout__GdkEventProperty() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventProperty> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventProperty>(),
40usize,
concat!("Size of: ", stringify!(_GdkEventProperty))
);
assert_eq!(
::std::mem::align_of::<_GdkEventProperty>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventProperty))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventProperty),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventProperty),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventProperty),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).atom) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventProperty),
"::",
stringify!(atom)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventProperty),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventProperty),
"::",
stringify!(state)
)
);
}
impl Default for _GdkEventProperty {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventSelection:\n @type: the type of the event (%GDK_SELECTION_CLEAR,\n %GDK_SELECTION_NOTIFY or %GDK_SELECTION_REQUEST).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @selection: the selection.\n @target: the target to which the selection should be converted.\n @property: the property in which to place the result of the conversion.\n @time: the time of the event in milliseconds.\n @requestor: the window on which to place @property or %NULL if none.\n\n Generated when a selection is requested or ownership of a selection\n is taken over by another client application."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventSelection {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub selection: GdkAtom,
pub target: GdkAtom,
pub property: GdkAtom,
pub time: guint32,
pub requestor: *mut GdkWindow,
}
#[test]
fn bindgen_test_layout__GdkEventSelection() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventSelection> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventSelection>(),
64usize,
concat!("Size of: ", stringify!(_GdkEventSelection))
);
assert_eq!(
::std::mem::align_of::<_GdkEventSelection>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventSelection))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventSelection),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventSelection),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventSelection),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).selection) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventSelection),
"::",
stringify!(selection)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventSelection),
"::",
stringify!(target)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).property) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventSelection),
"::",
stringify!(property)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventSelection),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).requestor) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventSelection),
"::",
stringify!(requestor)
)
);
}
impl Default for _GdkEventSelection {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventOwnerChange:\n @type: the type of the event (%GDK_OWNER_CHANGE).\n @window: the window which received the event\n @send_event: %TRUE if the event was sent explicitly.\n @owner: the new owner of the selection, or %NULL if there is none\n @reason: the reason for the ownership change as a #GdkOwnerChange value\n @selection: the atom identifying the selection\n @time: the timestamp of the event\n @selection_time: the time at which the selection ownership was taken\n over\n\n Generated when the owner of a selection changes. On X11, this\n information is only available if the X server supports the XFIXES\n extension.\n\n Since: 2.6"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventOwnerChange {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub owner: *mut GdkWindow,
pub reason: GdkOwnerChange,
pub selection: GdkAtom,
pub time: guint32,
pub selection_time: guint32,
}
#[test]
fn bindgen_test_layout__GdkEventOwnerChange() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventOwnerChange> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventOwnerChange>(),
56usize,
concat!("Size of: ", stringify!(_GdkEventOwnerChange))
);
assert_eq!(
::std::mem::align_of::<_GdkEventOwnerChange>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventOwnerChange))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventOwnerChange),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventOwnerChange),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventOwnerChange),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).owner) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventOwnerChange),
"::",
stringify!(owner)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reason) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventOwnerChange),
"::",
stringify!(reason)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).selection) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventOwnerChange),
"::",
stringify!(selection)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventOwnerChange),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).selection_time) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventOwnerChange),
"::",
stringify!(selection_time)
)
);
}
impl Default for _GdkEventOwnerChange {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventProximity:\n @type: the type of the event (%GDK_PROXIMITY_IN or %GDK_PROXIMITY_OUT).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @time: the time of the event in milliseconds.\n @device: the master device that the event originated from. Use\n gdk_event_get_source_device() to get the slave device.\n\n Proximity events are generated when using GDK’s wrapper for the\n XInput extension. The XInput extension is an add-on for standard X\n that allows you to use nonstandard devices such as graphics tablets.\n A proximity event indicates that the stylus has moved in or out of\n contact with the tablet, or perhaps that the user’s finger has moved\n in or out of contact with a touch screen.\n\n This event type will be used pretty rarely. It only is important for\n XInput aware programs that are drawing their own cursor."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventProximity {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub time: guint32,
pub device: *mut GdkDevice,
}
#[test]
fn bindgen_test_layout__GdkEventProximity() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventProximity> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventProximity>(),
32usize,
concat!("Size of: ", stringify!(_GdkEventProximity))
);
assert_eq!(
::std::mem::align_of::<_GdkEventProximity>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventProximity))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventProximity),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventProximity),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventProximity),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventProximity),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).device) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventProximity),
"::",
stringify!(device)
)
);
}
impl Default for _GdkEventProximity {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventSetting:\n @type: the type of the event (%GDK_SETTING).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @action: what happened to the setting (%GDK_SETTING_ACTION_NEW,\n %GDK_SETTING_ACTION_CHANGED or %GDK_SETTING_ACTION_DELETED).\n @name: the name of the setting.\n\n Generated when a setting is modified."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventSetting {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub action: GdkSettingAction,
pub name: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__GdkEventSetting() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventSetting> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventSetting>(),
32usize,
concat!("Size of: ", stringify!(_GdkEventSetting))
);
assert_eq!(
::std::mem::align_of::<_GdkEventSetting>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventSetting))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventSetting),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventSetting),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventSetting),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).action) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventSetting),
"::",
stringify!(action)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventSetting),
"::",
stringify!(name)
)
);
}
impl Default for _GdkEventSetting {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventWindowState:\n @type: the type of the event (%GDK_WINDOW_STATE).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @changed_mask: mask specifying what flags have changed.\n @new_window_state: the new window state, a combination of\n #GdkWindowState bits.\n\n Generated when the state of a toplevel window changes."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventWindowState {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub changed_mask: GdkWindowState,
pub new_window_state: GdkWindowState,
}
#[test]
fn bindgen_test_layout__GdkEventWindowState() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventWindowState> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventWindowState>(),
32usize,
concat!("Size of: ", stringify!(_GdkEventWindowState))
);
assert_eq!(
::std::mem::align_of::<_GdkEventWindowState>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventWindowState))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventWindowState),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventWindowState),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventWindowState),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).changed_mask) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventWindowState),
"::",
stringify!(changed_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).new_window_state) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventWindowState),
"::",
stringify!(new_window_state)
)
);
}
impl Default for _GdkEventWindowState {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventGrabBroken:\n @type: the type of the event (%GDK_GRAB_BROKEN)\n @window: the window which received the event, i.e. the window\n that previously owned the grab\n @send_event: %TRUE if the event was sent explicitly.\n @keyboard: %TRUE if a keyboard grab was broken, %FALSE if a pointer\n grab was broken\n @implicit: %TRUE if the broken grab was implicit\n @grab_window: If this event is caused by another grab in the same\n application, @grab_window contains the new grab window. Otherwise\n @grab_window is %NULL.\n\n Generated when a pointer or keyboard grab is broken. On X11, this happens\n when the grab window becomes unviewable (i.e. it or one of its ancestors\n is unmapped), or if the same application grabs the pointer or keyboard\n again. Note that implicit grabs (which are initiated by button presses)\n can also cause #GdkEventGrabBroken events.\n\n Since: 2.8"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventGrabBroken {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub keyboard: gboolean,
pub implicit: gboolean,
pub grab_window: *mut GdkWindow,
}
#[test]
fn bindgen_test_layout__GdkEventGrabBroken() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventGrabBroken> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventGrabBroken>(),
40usize,
concat!("Size of: ", stringify!(_GdkEventGrabBroken))
);
assert_eq!(
::std::mem::align_of::<_GdkEventGrabBroken>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventGrabBroken))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventGrabBroken),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventGrabBroken),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventGrabBroken),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).keyboard) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventGrabBroken),
"::",
stringify!(keyboard)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).implicit) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventGrabBroken),
"::",
stringify!(implicit)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).grab_window) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventGrabBroken),
"::",
stringify!(grab_window)
)
);
}
impl Default for _GdkEventGrabBroken {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEventDND:\n @type: the type of the event (%GDK_DRAG_ENTER, %GDK_DRAG_LEAVE,\n %GDK_DRAG_MOTION, %GDK_DRAG_STATUS, %GDK_DROP_START or\n %GDK_DROP_FINISHED).\n @window: the window which received the event.\n @send_event: %TRUE if the event was sent explicitly.\n @context: the #GdkDragContext for the current DND operation.\n @time: the time of the event in milliseconds.\n @x_root: the x coordinate of the pointer relative to the root of the\n screen, only set for %GDK_DRAG_MOTION and %GDK_DROP_START.\n @y_root: the y coordinate of the pointer relative to the root of the\n screen, only set for %GDK_DRAG_MOTION and %GDK_DROP_START.\n\n Generated during DND operations."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkEventDND {
pub type_: GdkEventType,
pub window: *mut GdkWindow,
pub send_event: gint8,
pub context: *mut GdkDragContext,
pub time: guint32,
pub x_root: gshort,
pub y_root: gshort,
}
#[test]
fn bindgen_test_layout__GdkEventDND() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEventDND> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEventDND>(),
40usize,
concat!("Size of: ", stringify!(_GdkEventDND))
);
assert_eq!(
::std::mem::align_of::<_GdkEventDND>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEventDND))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventDND),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventDND),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventDND),
"::",
stringify!(send_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventDND),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventDND),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_root) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventDND),
"::",
stringify!(x_root)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_root) as usize - ptr as usize },
38usize,
concat!(
"Offset of field: ",
stringify!(_GdkEventDND),
"::",
stringify!(y_root)
)
);
}
impl Default for _GdkEventDND {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkEvent:\n @type: the #GdkEventType\n @any: a #GdkEventAny\n @expose: a #GdkEventExpose\n @visibility: a #GdkEventVisibility\n @motion: a #GdkEventMotion\n @button: a #GdkEventButton\n @touch: a #GdkEventTouch\n @scroll: a #GdkEventScroll\n @key: a #GdkEventKey\n @crossing: a #GdkEventCrossing\n @focus_change: a #GdkEventFocus\n @configure: a #GdkEventConfigure\n @property: a #GdkEventProperty\n @selection: a #GdkEventSelection\n @owner_change: a #GdkEventOwnerChange\n @proximity: a #GdkEventProximity\n @dnd: a #GdkEventDND\n @window_state: a #GdkEventWindowState\n @setting: a #GdkEventSetting\n @grab_broken: a #GdkEventGrabBroken\n\n A #GdkEvent contains a union of all of the event types,\n and allows access to the data fields in a number of ways.\n\n The event type is always the first field in all of the event types, and\n can always be accessed with the following code, no matter what type of\n event it is:\n |[<!-- language=\"C\" -->\n GdkEvent *event;\n GdkEventType type;\n\n type = event->type;\n ]|\n\n To access other fields of the event, the pointer to the event\n can be cast to the appropriate event type, or the union member\n name can be used. For example if the event type is %GDK_BUTTON_PRESS\n then the x coordinate of the button press can be accessed with:\n |[<!-- language=\"C\" -->\n GdkEvent *event;\n gdouble x;\n\n x = ((GdkEventButton*)event)->x;\n ]|\n or:\n |[<!-- language=\"C\" -->\n GdkEvent *event;\n gdouble x;\n\n x = event->button.x;\n ]|"]
#[repr(C)]
#[derive(Copy, Clone)]
pub union _GdkEvent {
pub type_: GdkEventType,
pub any: GdkEventAny,
pub expose: GdkEventExpose,
pub visibility: GdkEventVisibility,
pub motion: GdkEventMotion,
pub button: GdkEventButton,
pub touch: GdkEventTouch,
pub scroll: GdkEventScroll,
pub key: GdkEventKey,
pub crossing: GdkEventCrossing,
pub focus_change: GdkEventFocus,
pub configure: GdkEventConfigure,
pub property: GdkEventProperty,
pub selection: GdkEventSelection,
pub owner_change: GdkEventOwnerChange,
pub proximity: GdkEventProximity,
pub dnd: GdkEventDND,
pub window_state: GdkEventWindowState,
pub setting: GdkEventSetting,
pub grab_broken: GdkEventGrabBroken,
}
#[test]
fn bindgen_test_layout__GdkEvent() {
const UNINIT: ::std::mem::MaybeUninit<_GdkEvent> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkEvent>(),
96usize,
concat!("Size of: ", stringify!(_GdkEvent))
);
assert_eq!(
::std::mem::align_of::<_GdkEvent>(),
8usize,
concat!("Alignment of ", stringify!(_GdkEvent))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).any) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(any)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).expose) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(expose)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).visibility) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(visibility)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).motion) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(motion)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(button)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).touch) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(touch)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).scroll) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(scroll)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).crossing) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(crossing)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).focus_change) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(focus_change)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).configure) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(configure)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).property) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(property)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).selection) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(selection)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).owner_change) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(owner_change)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).proximity) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(proximity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dnd) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(dnd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window_state) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(window_state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).setting) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(setting)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).grab_broken) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkEvent),
"::",
stringify!(grab_broken)
)
);
}
impl Default for _GdkEvent {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GdkColor:\n @pixel: For allocated colors, the pixel value used to\n draw this color on the screen. Not used anymore.\n @red: The red component of the color. This is\n a value between 0 and 65535, with 65535 indicating\n full intensity\n @green: The green component of the color\n @blue: The blue component of the color\n\n A #GdkColor is used to describe a color,\n similar to the XColor struct used in the X11 drawing API.\n\n Deprecated: 3.14: Use #GdkRGBA"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _GdkColor {
pub pixel: guint32,
pub red: guint16,
pub green: guint16,
pub blue: guint16,
}
#[test]
fn bindgen_test_layout__GdkColor() {
const UNINIT: ::std::mem::MaybeUninit<_GdkColor> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkColor>(),
12usize,
concat!("Size of: ", stringify!(_GdkColor))
);
assert_eq!(
::std::mem::align_of::<_GdkColor>(),
4usize,
concat!("Alignment of ", stringify!(_GdkColor))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pixel) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkColor),
"::",
stringify!(pixel)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).red) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_GdkColor),
"::",
stringify!(red)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).green) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(_GdkColor),
"::",
stringify!(green)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).blue) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkColor),
"::",
stringify!(blue)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _GdkRGBA {
pub red: gdouble,
pub green: gdouble,
pub blue: gdouble,
pub alpha: gdouble,
}
#[test]
fn bindgen_test_layout__GdkRGBA() {
const UNINIT: ::std::mem::MaybeUninit<_GdkRGBA> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkRGBA>(),
32usize,
concat!("Size of: ", stringify!(_GdkRGBA))
);
assert_eq!(
::std::mem::align_of::<_GdkRGBA>(),
8usize,
concat!("Alignment of ", stringify!(_GdkRGBA))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).red) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkRGBA),
"::",
stringify!(red)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).green) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkRGBA),
"::",
stringify!(green)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).blue) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkRGBA),
"::",
stringify!(blue)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alpha) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkRGBA),
"::",
stringify!(alpha)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkPixbuf {
_unused: [u8; 0],
}
#[doc = " GdkPixbuf:\n\n This is the main structure in the gdk-pixbuf library. It is\n used to represent images. It contains information about the\n image's pixel data, its color space, bits per sample, width and\n height, and the rowstride (the number of bytes between the start of\n one row and the start of the next)."]
pub type GdkPixbuf = _GdkPixbuf;
extern "C" {
pub fn gdk_pixbuf_new_from_stream(
stream: *mut GInputStream,
cancellable: *mut GCancellable,
error: *mut *mut GError,
) -> *mut GdkPixbuf;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkPixbufAnimation {
_unused: [u8; 0],
}
#[doc = " GdkPixbufAnimation:\n\n An opaque struct representing an animation."]
pub type GdkPixbufAnimation = _GdkPixbufAnimation;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkFrameClock {
_unused: [u8; 0],
}
pub type GdkFrameClock = _GdkFrameClock;
#[doc = " GdkGeometry:\n @min_width: minimum width of window (or -1 to use requisition, with\n #GtkWindow only)\n @min_height: minimum height of window (or -1 to use requisition, with\n #GtkWindow only)\n @max_width: maximum width of window (or -1 to use requisition, with\n #GtkWindow only)\n @max_height: maximum height of window (or -1 to use requisition, with\n #GtkWindow only)\n @base_width: allowed window widths are @base_width + @width_inc * N where N\n is any integer (-1 allowed with #GtkWindow)\n @base_height: allowed window widths are @base_height + @height_inc * N where\n N is any integer (-1 allowed with #GtkWindow)\n @width_inc: width resize increment\n @height_inc: height resize increment\n @min_aspect: minimum width/height ratio\n @max_aspect: maximum width/height ratio\n @win_gravity: window gravity, see gtk_window_set_gravity()\n\n The #GdkGeometry struct gives the window manager information about\n a window’s geometry constraints. Normally you would set these on\n the GTK+ level using gtk_window_set_geometry_hints(). #GtkWindow\n then sets the hints on the #GdkWindow it creates.\n\n gdk_window_set_geometry_hints() expects the hints to be fully valid already\n and simply passes them to the window manager; in contrast,\n gtk_window_set_geometry_hints() performs some interpretation. For example,\n #GtkWindow will apply the hints to the geometry widget instead of the\n toplevel window, if you set a geometry widget. Also, the\n @min_width/@min_height/@max_width/@max_height fields may be set to -1, and\n #GtkWindow will substitute the size request of the window or geometry widget.\n If the minimum size hint is not provided, #GtkWindow will use its requisition\n as the minimum size. If the minimum size is provided and a geometry widget is\n set, #GtkWindow will take the minimum size as the minimum size of the\n geometry widget rather than the entire window. The base size is treated\n similarly.\n\n The canonical use-case for gtk_window_set_geometry_hints() is to get a\n terminal widget to resize properly. Here, the terminal text area should be\n the geometry widget; #GtkWindow will then automatically set the base size to\n the size of other widgets in the terminal window, such as the menubar and\n scrollbar. Then, the @width_inc and @height_inc fields should be set to the\n size of one character in the terminal. Finally, the base size should be set\n to the size of one character. The net effect is that the minimum size of the\n terminal will have a 1x1 character terminal area, and only terminal sizes on\n the “character grid” will be allowed.\n\n Here’s an example of how the terminal example would be implemented, assuming\n a terminal area widget called “terminal” and a toplevel window “toplevel”:\n\n |[<!-- language=\"C\" -->\n \tGdkGeometry hints;\n\n \thints.base_width = terminal->char_width;\n hints.base_height = terminal->char_height;\n hints.min_width = terminal->char_width;\n hints.min_height = terminal->char_height;\n hints.width_inc = terminal->char_width;\n hints.height_inc = terminal->char_height;\n\n gtk_window_set_geometry_hints (GTK_WINDOW (toplevel),\n GTK_WIDGET (terminal),\n &hints,\n GDK_HINT_RESIZE_INC |\n GDK_HINT_MIN_SIZE |\n GDK_HINT_BASE_SIZE);\n ]|\n\n The other useful fields are the @min_aspect and @max_aspect fields; these\n contain a width/height ratio as a floating point number. If a geometry widget\n is set, the aspect applies to the geometry widget rather than the entire\n window. The most common use of these hints is probably to set @min_aspect and\n @max_aspect to the same value, thus forcing the window to keep a constant\n aspect ratio."]
pub type GdkGeometry = _GdkGeometry;
pub const GdkWindowHints_GDK_HINT_POS: GdkWindowHints = 1;
pub const GdkWindowHints_GDK_HINT_MIN_SIZE: GdkWindowHints = 2;
pub const GdkWindowHints_GDK_HINT_MAX_SIZE: GdkWindowHints = 4;
pub const GdkWindowHints_GDK_HINT_BASE_SIZE: GdkWindowHints = 8;
pub const GdkWindowHints_GDK_HINT_ASPECT: GdkWindowHints = 16;
pub const GdkWindowHints_GDK_HINT_RESIZE_INC: GdkWindowHints = 32;
pub const GdkWindowHints_GDK_HINT_WIN_GRAVITY: GdkWindowHints = 64;
pub const GdkWindowHints_GDK_HINT_USER_POS: GdkWindowHints = 128;
pub const GdkWindowHints_GDK_HINT_USER_SIZE: GdkWindowHints = 256;
#[doc = " GdkWindowHints:\n @GDK_HINT_POS: indicates that the program has positioned the window\n @GDK_HINT_MIN_SIZE: min size fields are set\n @GDK_HINT_MAX_SIZE: max size fields are set\n @GDK_HINT_BASE_SIZE: base size fields are set\n @GDK_HINT_ASPECT: aspect ratio fields are set\n @GDK_HINT_RESIZE_INC: resize increment fields are set\n @GDK_HINT_WIN_GRAVITY: window gravity field is set\n @GDK_HINT_USER_POS: indicates that the window’s position was explicitly set\n by the user\n @GDK_HINT_USER_SIZE: indicates that the window’s size was explicitly set by\n the user\n\n Used to indicate which fields of a #GdkGeometry struct should be paid\n attention to. Also, the presence/absence of @GDK_HINT_POS,\n @GDK_HINT_USER_POS, and @GDK_HINT_USER_SIZE is significant, though they don't\n directly refer to #GdkGeometry fields. @GDK_HINT_USER_POS will be set\n automatically by #GtkWindow if you call gtk_window_move().\n @GDK_HINT_USER_POS and @GDK_HINT_USER_SIZE should be set if the user\n specified a size/position using a --geometry command-line argument;\n gtk_window_parse_geometry() automatically sets these flags."]
pub type GdkWindowHints = ::std::os::raw::c_uint;
pub const GdkWindowTypeHint_GDK_WINDOW_TYPE_HINT_NORMAL: GdkWindowTypeHint = 0;
pub const GdkWindowTypeHint_GDK_WINDOW_TYPE_HINT_DIALOG: GdkWindowTypeHint = 1;
pub const GdkWindowTypeHint_GDK_WINDOW_TYPE_HINT_MENU: GdkWindowTypeHint = 2;
pub const GdkWindowTypeHint_GDK_WINDOW_TYPE_HINT_TOOLBAR: GdkWindowTypeHint = 3;
pub const GdkWindowTypeHint_GDK_WINDOW_TYPE_HINT_SPLASHSCREEN: GdkWindowTypeHint = 4;
pub const GdkWindowTypeHint_GDK_WINDOW_TYPE_HINT_UTILITY: GdkWindowTypeHint = 5;
pub const GdkWindowTypeHint_GDK_WINDOW_TYPE_HINT_DOCK: GdkWindowTypeHint = 6;
pub const GdkWindowTypeHint_GDK_WINDOW_TYPE_HINT_DESKTOP: GdkWindowTypeHint = 7;
pub const GdkWindowTypeHint_GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU: GdkWindowTypeHint = 8;
pub const GdkWindowTypeHint_GDK_WINDOW_TYPE_HINT_POPUP_MENU: GdkWindowTypeHint = 9;
pub const GdkWindowTypeHint_GDK_WINDOW_TYPE_HINT_TOOLTIP: GdkWindowTypeHint = 10;
pub const GdkWindowTypeHint_GDK_WINDOW_TYPE_HINT_NOTIFICATION: GdkWindowTypeHint = 11;
pub const GdkWindowTypeHint_GDK_WINDOW_TYPE_HINT_COMBO: GdkWindowTypeHint = 12;
pub const GdkWindowTypeHint_GDK_WINDOW_TYPE_HINT_DND: GdkWindowTypeHint = 13;
#[doc = " GdkWindowTypeHint:\n @GDK_WINDOW_TYPE_HINT_NORMAL: Normal toplevel window.\n @GDK_WINDOW_TYPE_HINT_DIALOG: Dialog window.\n @GDK_WINDOW_TYPE_HINT_MENU: Window used to implement a menu; GTK+ uses\n this hint only for torn-off menus, see #GtkTearoffMenuItem.\n @GDK_WINDOW_TYPE_HINT_TOOLBAR: Window used to implement toolbars.\n @GDK_WINDOW_TYPE_HINT_SPLASHSCREEN: Window used to display a splash\n screen during application startup.\n @GDK_WINDOW_TYPE_HINT_UTILITY: Utility windows which are not detached\n toolbars or dialogs.\n @GDK_WINDOW_TYPE_HINT_DOCK: Used for creating dock or panel windows.\n @GDK_WINDOW_TYPE_HINT_DESKTOP: Used for creating the desktop background\n window.\n @GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU: A menu that belongs to a menubar.\n @GDK_WINDOW_TYPE_HINT_POPUP_MENU: A menu that does not belong to a menubar,\n e.g. a context menu.\n @GDK_WINDOW_TYPE_HINT_TOOLTIP: A tooltip.\n @GDK_WINDOW_TYPE_HINT_NOTIFICATION: A notification - typically a “bubble”\n that belongs to a status icon.\n @GDK_WINDOW_TYPE_HINT_COMBO: A popup from a combo box.\n @GDK_WINDOW_TYPE_HINT_DND: A window that is used to implement a DND cursor.\n\n These are hints for the window manager that indicate what type of function\n the window has. The window manager can use this when determining decoration\n and behaviour of the window. The hint must be set before mapping the window.\n\n See the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)\n specification for more details about window types."]
pub type GdkWindowTypeHint = ::std::os::raw::c_uint;
pub const GdkGravity_GDK_GRAVITY_NORTH_WEST: GdkGravity = 1;
pub const GdkGravity_GDK_GRAVITY_NORTH: GdkGravity = 2;
pub const GdkGravity_GDK_GRAVITY_NORTH_EAST: GdkGravity = 3;
pub const GdkGravity_GDK_GRAVITY_WEST: GdkGravity = 4;
pub const GdkGravity_GDK_GRAVITY_CENTER: GdkGravity = 5;
pub const GdkGravity_GDK_GRAVITY_EAST: GdkGravity = 6;
pub const GdkGravity_GDK_GRAVITY_SOUTH_WEST: GdkGravity = 7;
pub const GdkGravity_GDK_GRAVITY_SOUTH: GdkGravity = 8;
pub const GdkGravity_GDK_GRAVITY_SOUTH_EAST: GdkGravity = 9;
pub const GdkGravity_GDK_GRAVITY_STATIC: GdkGravity = 10;
#[doc = " GdkGravity:\n @GDK_GRAVITY_NORTH_WEST: the reference point is at the top left corner.\n @GDK_GRAVITY_NORTH: the reference point is in the middle of the top edge.\n @GDK_GRAVITY_NORTH_EAST: the reference point is at the top right corner.\n @GDK_GRAVITY_WEST: the reference point is at the middle of the left edge.\n @GDK_GRAVITY_CENTER: the reference point is at the center of the window.\n @GDK_GRAVITY_EAST: the reference point is at the middle of the right edge.\n @GDK_GRAVITY_SOUTH_WEST: the reference point is at the lower left corner.\n @GDK_GRAVITY_SOUTH: the reference point is at the middle of the lower edge.\n @GDK_GRAVITY_SOUTH_EAST: the reference point is at the lower right corner.\n @GDK_GRAVITY_STATIC: the reference point is at the top left corner of the\n window itself, ignoring window manager decorations.\n\n Defines the reference point of a window and the meaning of coordinates\n passed to gtk_window_move(). See gtk_window_move() and the \"implementation\n notes\" section of the\n [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)\n specification for more details."]
pub type GdkGravity = ::std::os::raw::c_uint;
pub const GdkWindowEdge_GDK_WINDOW_EDGE_NORTH_WEST: GdkWindowEdge = 0;
pub const GdkWindowEdge_GDK_WINDOW_EDGE_NORTH: GdkWindowEdge = 1;
pub const GdkWindowEdge_GDK_WINDOW_EDGE_NORTH_EAST: GdkWindowEdge = 2;
pub const GdkWindowEdge_GDK_WINDOW_EDGE_WEST: GdkWindowEdge = 3;
pub const GdkWindowEdge_GDK_WINDOW_EDGE_EAST: GdkWindowEdge = 4;
pub const GdkWindowEdge_GDK_WINDOW_EDGE_SOUTH_WEST: GdkWindowEdge = 5;
pub const GdkWindowEdge_GDK_WINDOW_EDGE_SOUTH: GdkWindowEdge = 6;
pub const GdkWindowEdge_GDK_WINDOW_EDGE_SOUTH_EAST: GdkWindowEdge = 7;
#[doc = " GdkWindowEdge:\n @GDK_WINDOW_EDGE_NORTH_WEST: the top left corner.\n @GDK_WINDOW_EDGE_NORTH: the top edge.\n @GDK_WINDOW_EDGE_NORTH_EAST: the top right corner.\n @GDK_WINDOW_EDGE_WEST: the left edge.\n @GDK_WINDOW_EDGE_EAST: the right edge.\n @GDK_WINDOW_EDGE_SOUTH_WEST: the lower left corner.\n @GDK_WINDOW_EDGE_SOUTH: the lower edge.\n @GDK_WINDOW_EDGE_SOUTH_EAST: the lower right corner.\n\n Determines a window edge or corner."]
pub type GdkWindowEdge = ::std::os::raw::c_uint;
#[doc = " GdkGeometry:\n @min_width: minimum width of window (or -1 to use requisition, with\n #GtkWindow only)\n @min_height: minimum height of window (or -1 to use requisition, with\n #GtkWindow only)\n @max_width: maximum width of window (or -1 to use requisition, with\n #GtkWindow only)\n @max_height: maximum height of window (or -1 to use requisition, with\n #GtkWindow only)\n @base_width: allowed window widths are @base_width + @width_inc * N where N\n is any integer (-1 allowed with #GtkWindow)\n @base_height: allowed window widths are @base_height + @height_inc * N where\n N is any integer (-1 allowed with #GtkWindow)\n @width_inc: width resize increment\n @height_inc: height resize increment\n @min_aspect: minimum width/height ratio\n @max_aspect: maximum width/height ratio\n @win_gravity: window gravity, see gtk_window_set_gravity()\n\n The #GdkGeometry struct gives the window manager information about\n a window’s geometry constraints. Normally you would set these on\n the GTK+ level using gtk_window_set_geometry_hints(). #GtkWindow\n then sets the hints on the #GdkWindow it creates.\n\n gdk_window_set_geometry_hints() expects the hints to be fully valid already\n and simply passes them to the window manager; in contrast,\n gtk_window_set_geometry_hints() performs some interpretation. For example,\n #GtkWindow will apply the hints to the geometry widget instead of the\n toplevel window, if you set a geometry widget. Also, the\n @min_width/@min_height/@max_width/@max_height fields may be set to -1, and\n #GtkWindow will substitute the size request of the window or geometry widget.\n If the minimum size hint is not provided, #GtkWindow will use its requisition\n as the minimum size. If the minimum size is provided and a geometry widget is\n set, #GtkWindow will take the minimum size as the minimum size of the\n geometry widget rather than the entire window. The base size is treated\n similarly.\n\n The canonical use-case for gtk_window_set_geometry_hints() is to get a\n terminal widget to resize properly. Here, the terminal text area should be\n the geometry widget; #GtkWindow will then automatically set the base size to\n the size of other widgets in the terminal window, such as the menubar and\n scrollbar. Then, the @width_inc and @height_inc fields should be set to the\n size of one character in the terminal. Finally, the base size should be set\n to the size of one character. The net effect is that the minimum size of the\n terminal will have a 1x1 character terminal area, and only terminal sizes on\n the “character grid” will be allowed.\n\n Here’s an example of how the terminal example would be implemented, assuming\n a terminal area widget called “terminal” and a toplevel window “toplevel”:\n\n |[<!-- language=\"C\" -->\n \tGdkGeometry hints;\n\n \thints.base_width = terminal->char_width;\n hints.base_height = terminal->char_height;\n hints.min_width = terminal->char_width;\n hints.min_height = terminal->char_height;\n hints.width_inc = terminal->char_width;\n hints.height_inc = terminal->char_height;\n\n gtk_window_set_geometry_hints (GTK_WINDOW (toplevel),\n GTK_WIDGET (terminal),\n &hints,\n GDK_HINT_RESIZE_INC |\n GDK_HINT_MIN_SIZE |\n GDK_HINT_BASE_SIZE);\n ]|\n\n The other useful fields are the @min_aspect and @max_aspect fields; these\n contain a width/height ratio as a floating point number. If a geometry widget\n is set, the aspect applies to the geometry widget rather than the entire\n window. The most common use of these hints is probably to set @min_aspect and\n @max_aspect to the same value, thus forcing the window to keep a constant\n aspect ratio."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GdkGeometry {
pub min_width: gint,
pub min_height: gint,
pub max_width: gint,
pub max_height: gint,
pub base_width: gint,
pub base_height: gint,
pub width_inc: gint,
pub height_inc: gint,
pub min_aspect: gdouble,
pub max_aspect: gdouble,
pub win_gravity: GdkGravity,
}
#[test]
fn bindgen_test_layout__GdkGeometry() {
const UNINIT: ::std::mem::MaybeUninit<_GdkGeometry> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GdkGeometry>(),
56usize,
concat!("Size of: ", stringify!(_GdkGeometry))
);
assert_eq!(
::std::mem::align_of::<_GdkGeometry>(),
8usize,
concat!("Alignment of ", stringify!(_GdkGeometry))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min_width) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GdkGeometry),
"::",
stringify!(min_width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min_height) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_GdkGeometry),
"::",
stringify!(min_height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_width) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GdkGeometry),
"::",
stringify!(max_width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_height) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_GdkGeometry),
"::",
stringify!(max_height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).base_width) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GdkGeometry),
"::",
stringify!(base_width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).base_height) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_GdkGeometry),
"::",
stringify!(base_height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width_inc) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GdkGeometry),
"::",
stringify!(width_inc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height_inc) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_GdkGeometry),
"::",
stringify!(height_inc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min_aspect) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GdkGeometry),
"::",
stringify!(min_aspect)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_aspect) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GdkGeometry),
"::",
stringify!(max_aspect)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).win_gravity) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GdkGeometry),
"::",
stringify!(win_gravity)
)
);
}
impl Default for _GdkGeometry {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const GtkAlign_GTK_ALIGN_FILL: GtkAlign = 0;
pub const GtkAlign_GTK_ALIGN_START: GtkAlign = 1;
pub const GtkAlign_GTK_ALIGN_END: GtkAlign = 2;
pub const GtkAlign_GTK_ALIGN_CENTER: GtkAlign = 3;
pub const GtkAlign_GTK_ALIGN_BASELINE: GtkAlign = 4;
#[doc = " GtkAlign:\n @GTK_ALIGN_FILL: stretch to fill all space if possible, center if\n no meaningful way to stretch\n @GTK_ALIGN_START: snap to left or top side, leaving space on right\n or bottom\n @GTK_ALIGN_END: snap to right or bottom side, leaving space on left\n or top\n @GTK_ALIGN_CENTER: center natural width of widget inside the\n allocation\n @GTK_ALIGN_BASELINE: align the widget according to the baseline. Since 3.10.\n\n Controls how a widget deals with extra space in a single (x or y)\n dimension.\n\n Alignment only matters if the widget receives a “too large” allocation,\n for example if you packed the widget with the #GtkWidget:expand\n flag inside a #GtkBox, then the widget might get extra space. If\n you have for example a 16x16 icon inside a 32x32 space, the icon\n could be scaled and stretched, it could be centered, or it could be\n positioned to one side of the space.\n\n Note that in horizontal context @GTK_ALIGN_START and @GTK_ALIGN_END\n are interpreted relative to text direction.\n\n GTK_ALIGN_BASELINE support for it is optional for containers and widgets, and\n it is only supported for vertical alignment. When its not supported by\n a child or a container it is treated as @GTK_ALIGN_FILL."]
pub type GtkAlign = ::std::os::raw::c_uint;
pub const GtkArrowType_GTK_ARROW_UP: GtkArrowType = 0;
pub const GtkArrowType_GTK_ARROW_DOWN: GtkArrowType = 1;
pub const GtkArrowType_GTK_ARROW_LEFT: GtkArrowType = 2;
pub const GtkArrowType_GTK_ARROW_RIGHT: GtkArrowType = 3;
pub const GtkArrowType_GTK_ARROW_NONE: GtkArrowType = 4;
#[doc = " GtkArrowType:\n @GTK_ARROW_UP: Represents an upward pointing arrow.\n @GTK_ARROW_DOWN: Represents a downward pointing arrow.\n @GTK_ARROW_LEFT: Represents a left pointing arrow.\n @GTK_ARROW_RIGHT: Represents a right pointing arrow.\n @GTK_ARROW_NONE: No arrow. Since 2.10.\n\n Used to indicate the direction in which an arrow should point."]
pub type GtkArrowType = ::std::os::raw::c_uint;
pub const GtkBaselinePosition_GTK_BASELINE_POSITION_TOP: GtkBaselinePosition = 0;
pub const GtkBaselinePosition_GTK_BASELINE_POSITION_CENTER: GtkBaselinePosition = 1;
pub const GtkBaselinePosition_GTK_BASELINE_POSITION_BOTTOM: GtkBaselinePosition = 2;
#[doc = " GtkBaselinePosition:\n @GTK_BASELINE_POSITION_TOP: Align the baseline at the top\n @GTK_BASELINE_POSITION_CENTER: Center the baseline\n @GTK_BASELINE_POSITION_BOTTOM: Align the baseline at the bottom\n\n Whenever a container has some form of natural row it may align\n children in that row along a common typographical baseline. If\n the amount of verical space in the row is taller than the total\n requested height of the baseline-aligned children then it can use a\n #GtkBaselinePosition to select where to put the baseline inside the\n extra availible space.\n\n Since: 3.10"]
pub type GtkBaselinePosition = ::std::os::raw::c_uint;
pub const GtkDirectionType_GTK_DIR_TAB_FORWARD: GtkDirectionType = 0;
pub const GtkDirectionType_GTK_DIR_TAB_BACKWARD: GtkDirectionType = 1;
pub const GtkDirectionType_GTK_DIR_UP: GtkDirectionType = 2;
pub const GtkDirectionType_GTK_DIR_DOWN: GtkDirectionType = 3;
pub const GtkDirectionType_GTK_DIR_LEFT: GtkDirectionType = 4;
pub const GtkDirectionType_GTK_DIR_RIGHT: GtkDirectionType = 5;
#[doc = " GtkDirectionType:\n @GTK_DIR_TAB_FORWARD: Move forward.\n @GTK_DIR_TAB_BACKWARD: Move backward.\n @GTK_DIR_UP: Move up.\n @GTK_DIR_DOWN: Move down.\n @GTK_DIR_LEFT: Move left.\n @GTK_DIR_RIGHT: Move right.\n\n Focus movement types."]
pub type GtkDirectionType = ::std::os::raw::c_uint;
pub const GtkIconSize_GTK_ICON_SIZE_INVALID: GtkIconSize = 0;
pub const GtkIconSize_GTK_ICON_SIZE_MENU: GtkIconSize = 1;
pub const GtkIconSize_GTK_ICON_SIZE_SMALL_TOOLBAR: GtkIconSize = 2;
pub const GtkIconSize_GTK_ICON_SIZE_LARGE_TOOLBAR: GtkIconSize = 3;
pub const GtkIconSize_GTK_ICON_SIZE_BUTTON: GtkIconSize = 4;
pub const GtkIconSize_GTK_ICON_SIZE_DND: GtkIconSize = 5;
pub const GtkIconSize_GTK_ICON_SIZE_DIALOG: GtkIconSize = 6;
#[doc = " GtkIconSize:\n @GTK_ICON_SIZE_INVALID: Invalid size.\n @GTK_ICON_SIZE_MENU: Size appropriate for menus (16px).\n @GTK_ICON_SIZE_SMALL_TOOLBAR: Size appropriate for small toolbars (16px).\n @GTK_ICON_SIZE_LARGE_TOOLBAR: Size appropriate for large toolbars (24px)\n @GTK_ICON_SIZE_BUTTON: Size appropriate for buttons (16px)\n @GTK_ICON_SIZE_DND: Size appropriate for drag and drop (32px)\n @GTK_ICON_SIZE_DIALOG: Size appropriate for dialogs (48px)\n\n Built-in stock icon sizes."]
pub type GtkIconSize = ::std::os::raw::c_uint;
pub const GtkSensitivityType_GTK_SENSITIVITY_AUTO: GtkSensitivityType = 0;
pub const GtkSensitivityType_GTK_SENSITIVITY_ON: GtkSensitivityType = 1;
pub const GtkSensitivityType_GTK_SENSITIVITY_OFF: GtkSensitivityType = 2;
#[doc = " GtkSensitivityType:\n @GTK_SENSITIVITY_AUTO: The arrow is made insensitive if the\n thumb is at the end\n @GTK_SENSITIVITY_ON: The arrow is always sensitive\n @GTK_SENSITIVITY_OFF: The arrow is always insensitive\n\n Determines how GTK+ handles the sensitivity of stepper arrows\n at the end of range widgets."]
pub type GtkSensitivityType = ::std::os::raw::c_uint;
pub const GtkTextDirection_GTK_TEXT_DIR_NONE: GtkTextDirection = 0;
pub const GtkTextDirection_GTK_TEXT_DIR_LTR: GtkTextDirection = 1;
pub const GtkTextDirection_GTK_TEXT_DIR_RTL: GtkTextDirection = 2;
#[doc = " GtkTextDirection:\n @GTK_TEXT_DIR_NONE: No direction.\n @GTK_TEXT_DIR_LTR: Left to right text direction.\n @GTK_TEXT_DIR_RTL: Right to left text direction.\n\n Reading directions for text."]
pub type GtkTextDirection = ::std::os::raw::c_uint;
pub const GtkJustification_GTK_JUSTIFY_LEFT: GtkJustification = 0;
pub const GtkJustification_GTK_JUSTIFY_RIGHT: GtkJustification = 1;
pub const GtkJustification_GTK_JUSTIFY_CENTER: GtkJustification = 2;
pub const GtkJustification_GTK_JUSTIFY_FILL: GtkJustification = 3;
#[doc = " GtkJustification:\n @GTK_JUSTIFY_LEFT: The text is placed at the left edge of the label.\n @GTK_JUSTIFY_RIGHT: The text is placed at the right edge of the label.\n @GTK_JUSTIFY_CENTER: The text is placed in the center of the label.\n @GTK_JUSTIFY_FILL: The text is placed is distributed across the label.\n\n Used for justifying the text inside a #GtkLabel widget. (See also\n #GtkAlignment)."]
pub type GtkJustification = ::std::os::raw::c_uint;
pub const GtkMessageType_GTK_MESSAGE_INFO: GtkMessageType = 0;
pub const GtkMessageType_GTK_MESSAGE_WARNING: GtkMessageType = 1;
pub const GtkMessageType_GTK_MESSAGE_QUESTION: GtkMessageType = 2;
pub const GtkMessageType_GTK_MESSAGE_ERROR: GtkMessageType = 3;
pub const GtkMessageType_GTK_MESSAGE_OTHER: GtkMessageType = 4;
#[doc = " GtkMessageType:\n @GTK_MESSAGE_INFO: Informational message\n @GTK_MESSAGE_WARNING: Non-fatal warning message\n @GTK_MESSAGE_QUESTION: Question requiring a choice\n @GTK_MESSAGE_ERROR: Fatal error message\n @GTK_MESSAGE_OTHER: None of the above, doesn’t get an icon\n\n The type of message being displayed in the dialog."]
pub type GtkMessageType = ::std::os::raw::c_uint;
pub const GtkOrientation_GTK_ORIENTATION_HORIZONTAL: GtkOrientation = 0;
pub const GtkOrientation_GTK_ORIENTATION_VERTICAL: GtkOrientation = 1;
#[doc = " GtkOrientation:\n @GTK_ORIENTATION_HORIZONTAL: The element is in horizontal orientation.\n @GTK_ORIENTATION_VERTICAL: The element is in vertical orientation.\n\n Represents the orientation of widgets and other objects which can be switched\n between horizontal and vertical orientation on the fly, like #GtkToolbar or\n #GtkGesturePan."]
pub type GtkOrientation = ::std::os::raw::c_uint;
pub const GtkPackType_GTK_PACK_START: GtkPackType = 0;
pub const GtkPackType_GTK_PACK_END: GtkPackType = 1;
#[doc = " GtkPackType:\n @GTK_PACK_START: The child is packed into the start of the box\n @GTK_PACK_END: The child is packed into the end of the box\n\n Represents the packing location #GtkBox children. (See: #GtkVBox,\n #GtkHBox, and #GtkButtonBox)."]
pub type GtkPackType = ::std::os::raw::c_uint;
pub const GtkPositionType_GTK_POS_LEFT: GtkPositionType = 0;
pub const GtkPositionType_GTK_POS_RIGHT: GtkPositionType = 1;
pub const GtkPositionType_GTK_POS_TOP: GtkPositionType = 2;
pub const GtkPositionType_GTK_POS_BOTTOM: GtkPositionType = 3;
#[doc = " GtkPositionType:\n @GTK_POS_LEFT: The feature is at the left edge.\n @GTK_POS_RIGHT: The feature is at the right edge.\n @GTK_POS_TOP: The feature is at the top edge.\n @GTK_POS_BOTTOM: The feature is at the bottom edge.\n\n Describes which edge of a widget a certain feature is positioned at, e.g. the\n tabs of a #GtkNotebook, the handle of a #GtkHandleBox or the label of a\n #GtkScale."]
pub type GtkPositionType = ::std::os::raw::c_uint;
pub const GtkReliefStyle_GTK_RELIEF_NORMAL: GtkReliefStyle = 0;
pub const GtkReliefStyle_GTK_RELIEF_HALF: GtkReliefStyle = 1;
pub const GtkReliefStyle_GTK_RELIEF_NONE: GtkReliefStyle = 2;
#[doc = " GtkReliefStyle:\n @GTK_RELIEF_NORMAL: Draw a normal relief.\n @GTK_RELIEF_HALF: A half relief. Deprecated in 3.14, does the same as @GTK_RELIEF_NORMAL\n @GTK_RELIEF_NONE: No relief.\n\n Indicated the relief to be drawn around a #GtkButton."]
pub type GtkReliefStyle = ::std::os::raw::c_uint;
pub const GtkSelectionMode_GTK_SELECTION_NONE: GtkSelectionMode = 0;
pub const GtkSelectionMode_GTK_SELECTION_SINGLE: GtkSelectionMode = 1;
pub const GtkSelectionMode_GTK_SELECTION_BROWSE: GtkSelectionMode = 2;
pub const GtkSelectionMode_GTK_SELECTION_MULTIPLE: GtkSelectionMode = 3;
#[doc = " GtkSelectionMode:\n @GTK_SELECTION_NONE: No selection is possible.\n @GTK_SELECTION_SINGLE: Zero or one element may be selected.\n @GTK_SELECTION_BROWSE: Exactly one element is selected.\n In some circumstances, such as initially or during a search\n operation, it’s possible for no element to be selected with\n %GTK_SELECTION_BROWSE. What is really enforced is that the user\n can’t deselect a currently selected element except by selecting\n another element.\n @GTK_SELECTION_MULTIPLE: Any number of elements may be selected.\n The Ctrl key may be used to enlarge the selection, and Shift\n key to select between the focus and the child pointed to.\n Some widgets may also allow Click-drag to select a range of elements.\n\n Used to control what selections users are allowed to make."]
pub type GtkSelectionMode = ::std::os::raw::c_uint;
pub const GtkShadowType_GTK_SHADOW_NONE: GtkShadowType = 0;
pub const GtkShadowType_GTK_SHADOW_IN: GtkShadowType = 1;
pub const GtkShadowType_GTK_SHADOW_OUT: GtkShadowType = 2;
pub const GtkShadowType_GTK_SHADOW_ETCHED_IN: GtkShadowType = 3;
pub const GtkShadowType_GTK_SHADOW_ETCHED_OUT: GtkShadowType = 4;
#[doc = " GtkShadowType:\n @GTK_SHADOW_NONE: No outline.\n @GTK_SHADOW_IN: The outline is bevelled inwards.\n @GTK_SHADOW_OUT: The outline is bevelled outwards like a button.\n @GTK_SHADOW_ETCHED_IN: The outline has a sunken 3d appearance.\n @GTK_SHADOW_ETCHED_OUT: The outline has a raised 3d appearance.\n\n Used to change the appearance of an outline typically provided by a #GtkFrame.\n\n Note that many themes do not differentiate the appearance of the\n various shadow types: Either their is no visible shadow (@GTK_SHADOW_NONE),\n or there is (any other value)."]
pub type GtkShadowType = ::std::os::raw::c_uint;
pub const GtkStateType_GTK_STATE_NORMAL: GtkStateType = 0;
pub const GtkStateType_GTK_STATE_ACTIVE: GtkStateType = 1;
pub const GtkStateType_GTK_STATE_PRELIGHT: GtkStateType = 2;
pub const GtkStateType_GTK_STATE_SELECTED: GtkStateType = 3;
pub const GtkStateType_GTK_STATE_INSENSITIVE: GtkStateType = 4;
pub const GtkStateType_GTK_STATE_INCONSISTENT: GtkStateType = 5;
pub const GtkStateType_GTK_STATE_FOCUSED: GtkStateType = 6;
#[doc = " GtkStateType:\n @GTK_STATE_NORMAL: State during normal operation.\n @GTK_STATE_ACTIVE: State of a currently active widget, such as a depressed button.\n @GTK_STATE_PRELIGHT: State indicating that the mouse pointer is over\n the widget and the widget will respond to mouse clicks.\n @GTK_STATE_SELECTED: State of a selected item, such the selected row in a list.\n @GTK_STATE_INSENSITIVE: State indicating that the widget is\n unresponsive to user actions.\n @GTK_STATE_INCONSISTENT: The widget is inconsistent, such as checkbuttons\n or radiobuttons that aren’t either set to %TRUE nor %FALSE,\n or buttons requiring the user attention.\n @GTK_STATE_FOCUSED: The widget has the keyboard focus.\n\n This type indicates the current state of a widget; the state determines how\n the widget is drawn. The #GtkStateType enumeration is also used to\n identify different colors in a #GtkStyle for drawing, so states can be\n used for subparts of a widget as well as entire widgets.\n\n Deprecated: 3.14: All APIs that are using this enumeration have been deprecated\n in favor of alternatives using #GtkStateFlags."]
pub type GtkStateType = ::std::os::raw::c_uint;
pub const GtkToolbarStyle_GTK_TOOLBAR_ICONS: GtkToolbarStyle = 0;
pub const GtkToolbarStyle_GTK_TOOLBAR_TEXT: GtkToolbarStyle = 1;
pub const GtkToolbarStyle_GTK_TOOLBAR_BOTH: GtkToolbarStyle = 2;
pub const GtkToolbarStyle_GTK_TOOLBAR_BOTH_HORIZ: GtkToolbarStyle = 3;
#[doc = " GtkToolbarStyle:\n @GTK_TOOLBAR_ICONS: Buttons display only icons in the toolbar.\n @GTK_TOOLBAR_TEXT: Buttons display only text labels in the toolbar.\n @GTK_TOOLBAR_BOTH: Buttons display text and icons in the toolbar.\n @GTK_TOOLBAR_BOTH_HORIZ: Buttons display icons and text alongside each\n other, rather than vertically stacked\n\n Used to customize the appearance of a #GtkToolbar. Note that\n setting the toolbar style overrides the user’s preferences\n for the default toolbar style. Note that if the button has only\n a label set and GTK_TOOLBAR_ICONS is used, the label will be\n visible, and vice versa."]
pub type GtkToolbarStyle = ::std::os::raw::c_uint;
pub const GtkWrapMode_GTK_WRAP_NONE: GtkWrapMode = 0;
pub const GtkWrapMode_GTK_WRAP_CHAR: GtkWrapMode = 1;
pub const GtkWrapMode_GTK_WRAP_WORD: GtkWrapMode = 2;
pub const GtkWrapMode_GTK_WRAP_WORD_CHAR: GtkWrapMode = 3;
#[doc = " GtkWrapMode:\n @GTK_WRAP_NONE: do not wrap lines; just make the text area wider\n @GTK_WRAP_CHAR: wrap text, breaking lines anywhere the cursor can\n appear (between characters, usually - if you want to be technical,\n between graphemes, see pango_get_log_attrs())\n @GTK_WRAP_WORD: wrap text, breaking lines in between words\n @GTK_WRAP_WORD_CHAR: wrap text, breaking lines in between words, or if\n that is not enough, also between graphemes\n\n Describes a type of line wrapping."]
pub type GtkWrapMode = ::std::os::raw::c_uint;
pub const GtkSortType_GTK_SORT_ASCENDING: GtkSortType = 0;
pub const GtkSortType_GTK_SORT_DESCENDING: GtkSortType = 1;
#[doc = " GtkSortType:\n @GTK_SORT_ASCENDING: Sorting is in ascending order.\n @GTK_SORT_DESCENDING: Sorting is in descending order.\n\n Determines the direction of a sort."]
pub type GtkSortType = ::std::os::raw::c_uint;
pub const GtkPackDirection_GTK_PACK_DIRECTION_LTR: GtkPackDirection = 0;
pub const GtkPackDirection_GTK_PACK_DIRECTION_RTL: GtkPackDirection = 1;
pub const GtkPackDirection_GTK_PACK_DIRECTION_TTB: GtkPackDirection = 2;
pub const GtkPackDirection_GTK_PACK_DIRECTION_BTT: GtkPackDirection = 3;
#[doc = " GtkPackDirection:\n @GTK_PACK_DIRECTION_LTR: Widgets are packed left-to-right\n @GTK_PACK_DIRECTION_RTL: Widgets are packed right-to-left\n @GTK_PACK_DIRECTION_TTB: Widgets are packed top-to-bottom\n @GTK_PACK_DIRECTION_BTT: Widgets are packed bottom-to-top\n\n Determines how widgets should be packed inside menubars\n and menuitems contained in menubars."]
pub type GtkPackDirection = ::std::os::raw::c_uint;
pub const GtkPrintPages_GTK_PRINT_PAGES_ALL: GtkPrintPages = 0;
pub const GtkPrintPages_GTK_PRINT_PAGES_CURRENT: GtkPrintPages = 1;
pub const GtkPrintPages_GTK_PRINT_PAGES_RANGES: GtkPrintPages = 2;
pub const GtkPrintPages_GTK_PRINT_PAGES_SELECTION: GtkPrintPages = 3;
#[doc = " GtkPrintPages:\n @GTK_PRINT_PAGES_ALL: All pages.\n @GTK_PRINT_PAGES_CURRENT: Current page.\n @GTK_PRINT_PAGES_RANGES: Range of pages.\n @GTK_PRINT_PAGES_SELECTION: Selected pages.\n\n See also gtk_print_job_set_pages()"]
pub type GtkPrintPages = ::std::os::raw::c_uint;
pub const GtkPageSet_GTK_PAGE_SET_ALL: GtkPageSet = 0;
pub const GtkPageSet_GTK_PAGE_SET_EVEN: GtkPageSet = 1;
pub const GtkPageSet_GTK_PAGE_SET_ODD: GtkPageSet = 2;
#[doc = " GtkPageSet:\n @GTK_PAGE_SET_ALL: All pages.\n @GTK_PAGE_SET_EVEN: Even pages.\n @GTK_PAGE_SET_ODD: Odd pages.\n\n See also gtk_print_job_set_page_set()."]
pub type GtkPageSet = ::std::os::raw::c_uint;
pub const GtkNumberUpLayout_GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM: GtkNumberUpLayout = 0;
pub const GtkNumberUpLayout_GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP: GtkNumberUpLayout = 1;
pub const GtkNumberUpLayout_GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM: GtkNumberUpLayout = 2;
pub const GtkNumberUpLayout_GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP: GtkNumberUpLayout = 3;
pub const GtkNumberUpLayout_GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT: GtkNumberUpLayout = 4;
pub const GtkNumberUpLayout_GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT: GtkNumberUpLayout = 5;
pub const GtkNumberUpLayout_GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT: GtkNumberUpLayout = 6;
pub const GtkNumberUpLayout_GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT: GtkNumberUpLayout = 7;
#[doc = " GtkNumberUpLayout:\n @GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM: ![](layout-lrtb.png)\n @GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP: ![](layout-lrbt.png)\n @GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM: ![](layout-rltb.png)\n @GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP: ![](layout-rlbt.png)\n @GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT: ![](layout-tblr.png)\n @GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT: ![](layout-tbrl.png)\n @GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT: ![](layout-btlr.png)\n @GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT: ![](layout-btrl.png)\n\n Used to determine the layout of pages on a sheet when printing\n multiple pages per sheet."]
pub type GtkNumberUpLayout = ::std::os::raw::c_uint;
pub const GtkPageOrientation_GTK_PAGE_ORIENTATION_PORTRAIT: GtkPageOrientation = 0;
pub const GtkPageOrientation_GTK_PAGE_ORIENTATION_LANDSCAPE: GtkPageOrientation = 1;
pub const GtkPageOrientation_GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT: GtkPageOrientation = 2;
pub const GtkPageOrientation_GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE: GtkPageOrientation = 3;
#[doc = " GtkPageOrientation:\n @GTK_PAGE_ORIENTATION_PORTRAIT: Portrait mode.\n @GTK_PAGE_ORIENTATION_LANDSCAPE: Landscape mode.\n @GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT: Reverse portrait mode.\n @GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE: Reverse landscape mode.\n\n See also gtk_print_settings_set_orientation()."]
pub type GtkPageOrientation = ::std::os::raw::c_uint;
pub const GtkPrintQuality_GTK_PRINT_QUALITY_LOW: GtkPrintQuality = 0;
pub const GtkPrintQuality_GTK_PRINT_QUALITY_NORMAL: GtkPrintQuality = 1;
pub const GtkPrintQuality_GTK_PRINT_QUALITY_HIGH: GtkPrintQuality = 2;
pub const GtkPrintQuality_GTK_PRINT_QUALITY_DRAFT: GtkPrintQuality = 3;
#[doc = " GtkPrintQuality:\n @GTK_PRINT_QUALITY_LOW: Low quality.\n @GTK_PRINT_QUALITY_NORMAL: Normal quality.\n @GTK_PRINT_QUALITY_HIGH: High quality.\n @GTK_PRINT_QUALITY_DRAFT: Draft quality.\n\n See also gtk_print_settings_set_quality()."]
pub type GtkPrintQuality = ::std::os::raw::c_uint;
pub const GtkPrintDuplex_GTK_PRINT_DUPLEX_SIMPLEX: GtkPrintDuplex = 0;
pub const GtkPrintDuplex_GTK_PRINT_DUPLEX_HORIZONTAL: GtkPrintDuplex = 1;
pub const GtkPrintDuplex_GTK_PRINT_DUPLEX_VERTICAL: GtkPrintDuplex = 2;
#[doc = " GtkPrintDuplex:\n @GTK_PRINT_DUPLEX_SIMPLEX: No duplex.\n @GTK_PRINT_DUPLEX_HORIZONTAL: Horizontal duplex.\n @GTK_PRINT_DUPLEX_VERTICAL: Vertical duplex.\n\n See also gtk_print_settings_set_duplex()."]
pub type GtkPrintDuplex = ::std::os::raw::c_uint;
pub const GtkUnit_GTK_UNIT_NONE: GtkUnit = 0;
pub const GtkUnit_GTK_UNIT_POINTS: GtkUnit = 1;
pub const GtkUnit_GTK_UNIT_INCH: GtkUnit = 2;
pub const GtkUnit_GTK_UNIT_MM: GtkUnit = 3;
#[doc = " GtkUnit:\n @GTK_UNIT_NONE: No units.\n @GTK_UNIT_POINTS: Dimensions in points.\n @GTK_UNIT_INCH: Dimensions in inches.\n @GTK_UNIT_MM: Dimensions in millimeters\n\n See also gtk_print_settings_set_paper_width()."]
pub type GtkUnit = ::std::os::raw::c_uint;
pub const GtkTreeViewGridLines_GTK_TREE_VIEW_GRID_LINES_NONE: GtkTreeViewGridLines = 0;
pub const GtkTreeViewGridLines_GTK_TREE_VIEW_GRID_LINES_HORIZONTAL: GtkTreeViewGridLines = 1;
pub const GtkTreeViewGridLines_GTK_TREE_VIEW_GRID_LINES_VERTICAL: GtkTreeViewGridLines = 2;
pub const GtkTreeViewGridLines_GTK_TREE_VIEW_GRID_LINES_BOTH: GtkTreeViewGridLines = 3;
#[doc = " GtkTreeViewGridLines:\n @GTK_TREE_VIEW_GRID_LINES_NONE: No grid lines.\n @GTK_TREE_VIEW_GRID_LINES_HORIZONTAL: Horizontal grid lines.\n @GTK_TREE_VIEW_GRID_LINES_VERTICAL: Vertical grid lines.\n @GTK_TREE_VIEW_GRID_LINES_BOTH: Horizontal and vertical grid lines.\n\n Used to indicate which grid lines to draw in a tree view."]
pub type GtkTreeViewGridLines = ::std::os::raw::c_uint;
pub const GtkDragResult_GTK_DRAG_RESULT_SUCCESS: GtkDragResult = 0;
pub const GtkDragResult_GTK_DRAG_RESULT_NO_TARGET: GtkDragResult = 1;
pub const GtkDragResult_GTK_DRAG_RESULT_USER_CANCELLED: GtkDragResult = 2;
pub const GtkDragResult_GTK_DRAG_RESULT_TIMEOUT_EXPIRED: GtkDragResult = 3;
pub const GtkDragResult_GTK_DRAG_RESULT_GRAB_BROKEN: GtkDragResult = 4;
pub const GtkDragResult_GTK_DRAG_RESULT_ERROR: GtkDragResult = 5;
#[doc = " GtkDragResult:\n @GTK_DRAG_RESULT_SUCCESS: The drag operation was successful.\n @GTK_DRAG_RESULT_NO_TARGET: No suitable drag target.\n @GTK_DRAG_RESULT_USER_CANCELLED: The user cancelled the drag operation.\n @GTK_DRAG_RESULT_TIMEOUT_EXPIRED: The drag operation timed out.\n @GTK_DRAG_RESULT_GRAB_BROKEN: The pointer or keyboard grab used\n for the drag operation was broken.\n @GTK_DRAG_RESULT_ERROR: The drag operation failed due to some\n unspecified error.\n\n Gives an indication why a drag operation failed.\n The value can by obtained by connecting to the\n #GtkWidget::drag-failed signal."]
pub type GtkDragResult = ::std::os::raw::c_uint;
pub const GtkSizeGroupMode_GTK_SIZE_GROUP_NONE: GtkSizeGroupMode = 0;
pub const GtkSizeGroupMode_GTK_SIZE_GROUP_HORIZONTAL: GtkSizeGroupMode = 1;
pub const GtkSizeGroupMode_GTK_SIZE_GROUP_VERTICAL: GtkSizeGroupMode = 2;
pub const GtkSizeGroupMode_GTK_SIZE_GROUP_BOTH: GtkSizeGroupMode = 3;
#[doc = " GtkSizeGroupMode:\n @GTK_SIZE_GROUP_NONE: group has no effect\n @GTK_SIZE_GROUP_HORIZONTAL: group affects horizontal requisition\n @GTK_SIZE_GROUP_VERTICAL: group affects vertical requisition\n @GTK_SIZE_GROUP_BOTH: group affects both horizontal and vertical requisition\n\n The mode of the size group determines the directions in which the size\n group affects the requested sizes of its component widgets."]
pub type GtkSizeGroupMode = ::std::os::raw::c_uint;
pub const GtkSizeRequestMode_GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH: GtkSizeRequestMode = 0;
pub const GtkSizeRequestMode_GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT: GtkSizeRequestMode = 1;
pub const GtkSizeRequestMode_GTK_SIZE_REQUEST_CONSTANT_SIZE: GtkSizeRequestMode = 2;
#[doc = " GtkSizeRequestMode:\n @GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH: Prefer height-for-width geometry management\n @GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT: Prefer width-for-height geometry management\n @GTK_SIZE_REQUEST_CONSTANT_SIZE: Don’t trade height-for-width or width-for-height\n\n Specifies a preference for height-for-width or\n width-for-height geometry management."]
pub type GtkSizeRequestMode = ::std::os::raw::c_uint;
pub const GtkScrollablePolicy_GTK_SCROLL_MINIMUM: GtkScrollablePolicy = 0;
pub const GtkScrollablePolicy_GTK_SCROLL_NATURAL: GtkScrollablePolicy = 1;
#[doc = " GtkScrollablePolicy:\n @GTK_SCROLL_MINIMUM: Scrollable adjustments are based on the minimum size\n @GTK_SCROLL_NATURAL: Scrollable adjustments are based on the natural size\n\n Defines the policy to be used in a scrollable widget when updating\n the scrolled window adjustments in a given orientation."]
pub type GtkScrollablePolicy = ::std::os::raw::c_uint;
pub const GtkStateFlags_GTK_STATE_FLAG_NORMAL: GtkStateFlags = 0;
pub const GtkStateFlags_GTK_STATE_FLAG_ACTIVE: GtkStateFlags = 1;
pub const GtkStateFlags_GTK_STATE_FLAG_PRELIGHT: GtkStateFlags = 2;
pub const GtkStateFlags_GTK_STATE_FLAG_SELECTED: GtkStateFlags = 4;
pub const GtkStateFlags_GTK_STATE_FLAG_INSENSITIVE: GtkStateFlags = 8;
pub const GtkStateFlags_GTK_STATE_FLAG_INCONSISTENT: GtkStateFlags = 16;
pub const GtkStateFlags_GTK_STATE_FLAG_FOCUSED: GtkStateFlags = 32;
pub const GtkStateFlags_GTK_STATE_FLAG_BACKDROP: GtkStateFlags = 64;
pub const GtkStateFlags_GTK_STATE_FLAG_DIR_LTR: GtkStateFlags = 128;
pub const GtkStateFlags_GTK_STATE_FLAG_DIR_RTL: GtkStateFlags = 256;
pub const GtkStateFlags_GTK_STATE_FLAG_LINK: GtkStateFlags = 512;
pub const GtkStateFlags_GTK_STATE_FLAG_VISITED: GtkStateFlags = 1024;
pub const GtkStateFlags_GTK_STATE_FLAG_CHECKED: GtkStateFlags = 2048;
#[doc = " GtkStateFlags:\n @GTK_STATE_FLAG_NORMAL: State during normal operation.\n @GTK_STATE_FLAG_ACTIVE: Widget is active.\n @GTK_STATE_FLAG_PRELIGHT: Widget has a mouse pointer over it.\n @GTK_STATE_FLAG_SELECTED: Widget is selected.\n @GTK_STATE_FLAG_INSENSITIVE: Widget is insensitive.\n @GTK_STATE_FLAG_INCONSISTENT: Widget is inconsistent.\n @GTK_STATE_FLAG_FOCUSED: Widget has the keyboard focus.\n @GTK_STATE_FLAG_BACKDROP: Widget is in a background toplevel window.\n @GTK_STATE_FLAG_DIR_LTR: Widget is in left-to-right text direction. Since 3.8\n @GTK_STATE_FLAG_DIR_RTL: Widget is in right-to-left text direction. Since 3.8\n @GTK_STATE_FLAG_LINK: Widget is a link. Since 3.12\n @GTK_STATE_FLAG_VISITED: The location the widget points to has already been visited. Since 3.12\n @GTK_STATE_FLAG_CHECKED: Widget is checked. Since 3.14\n\n Describes a widget state. Widget states are used to match the widget\n against CSS pseudo-classes. Note that GTK extends the regular CSS\n classes and sometimes uses different names."]
pub type GtkStateFlags = ::std::os::raw::c_uint;
pub const GtkRegionFlags_GTK_REGION_EVEN: GtkRegionFlags = 1;
pub const GtkRegionFlags_GTK_REGION_ODD: GtkRegionFlags = 2;
pub const GtkRegionFlags_GTK_REGION_FIRST: GtkRegionFlags = 4;
pub const GtkRegionFlags_GTK_REGION_LAST: GtkRegionFlags = 8;
pub const GtkRegionFlags_GTK_REGION_ONLY: GtkRegionFlags = 16;
pub const GtkRegionFlags_GTK_REGION_SORTED: GtkRegionFlags = 32;
#[doc = " GtkRegionFlags:\n @GTK_REGION_EVEN: Region has an even number within a set.\n @GTK_REGION_ODD: Region has an odd number within a set.\n @GTK_REGION_FIRST: Region is the first one within a set.\n @GTK_REGION_LAST: Region is the last one within a set.\n @GTK_REGION_ONLY: Region is the only one within a set.\n @GTK_REGION_SORTED: Region is part of a sorted area.\n\n Describes a region within a widget."]
pub type GtkRegionFlags = ::std::os::raw::c_uint;
pub const GtkJunctionSides_GTK_JUNCTION_NONE: GtkJunctionSides = 0;
pub const GtkJunctionSides_GTK_JUNCTION_CORNER_TOPLEFT: GtkJunctionSides = 1;
pub const GtkJunctionSides_GTK_JUNCTION_CORNER_TOPRIGHT: GtkJunctionSides = 2;
pub const GtkJunctionSides_GTK_JUNCTION_CORNER_BOTTOMLEFT: GtkJunctionSides = 4;
pub const GtkJunctionSides_GTK_JUNCTION_CORNER_BOTTOMRIGHT: GtkJunctionSides = 8;
pub const GtkJunctionSides_GTK_JUNCTION_TOP: GtkJunctionSides = 3;
pub const GtkJunctionSides_GTK_JUNCTION_BOTTOM: GtkJunctionSides = 12;
pub const GtkJunctionSides_GTK_JUNCTION_LEFT: GtkJunctionSides = 5;
pub const GtkJunctionSides_GTK_JUNCTION_RIGHT: GtkJunctionSides = 10;
#[doc = " GtkJunctionSides:\n @GTK_JUNCTION_NONE: No junctions.\n @GTK_JUNCTION_CORNER_TOPLEFT: Element connects on the top-left corner.\n @GTK_JUNCTION_CORNER_TOPRIGHT: Element connects on the top-right corner.\n @GTK_JUNCTION_CORNER_BOTTOMLEFT: Element connects on the bottom-left corner.\n @GTK_JUNCTION_CORNER_BOTTOMRIGHT: Element connects on the bottom-right corner.\n @GTK_JUNCTION_TOP: Element connects on the top side.\n @GTK_JUNCTION_BOTTOM: Element connects on the bottom side.\n @GTK_JUNCTION_LEFT: Element connects on the left side.\n @GTK_JUNCTION_RIGHT: Element connects on the right side.\n\n Describes how a rendered element connects to adjacent elements."]
pub type GtkJunctionSides = ::std::os::raw::c_uint;
pub const GtkLevelBarMode_GTK_LEVEL_BAR_MODE_CONTINUOUS: GtkLevelBarMode = 0;
pub const GtkLevelBarMode_GTK_LEVEL_BAR_MODE_DISCRETE: GtkLevelBarMode = 1;
#[doc = " GtkLevelBarMode:\n @GTK_LEVEL_BAR_MODE_CONTINUOUS: the bar has a continuous mode\n @GTK_LEVEL_BAR_MODE_DISCRETE: the bar has a discrete mode\n\n Describes how #GtkLevelBar contents should be rendered.\n Note that this enumeration could be extended with additional modes\n in the future.\n\n Since: 3.6"]
pub type GtkLevelBarMode = ::std::os::raw::c_uint;
pub const GtkInputPurpose_GTK_INPUT_PURPOSE_FREE_FORM: GtkInputPurpose = 0;
pub const GtkInputPurpose_GTK_INPUT_PURPOSE_ALPHA: GtkInputPurpose = 1;
pub const GtkInputPurpose_GTK_INPUT_PURPOSE_DIGITS: GtkInputPurpose = 2;
pub const GtkInputPurpose_GTK_INPUT_PURPOSE_NUMBER: GtkInputPurpose = 3;
pub const GtkInputPurpose_GTK_INPUT_PURPOSE_PHONE: GtkInputPurpose = 4;
pub const GtkInputPurpose_GTK_INPUT_PURPOSE_URL: GtkInputPurpose = 5;
pub const GtkInputPurpose_GTK_INPUT_PURPOSE_EMAIL: GtkInputPurpose = 6;
pub const GtkInputPurpose_GTK_INPUT_PURPOSE_NAME: GtkInputPurpose = 7;
pub const GtkInputPurpose_GTK_INPUT_PURPOSE_PASSWORD: GtkInputPurpose = 8;
pub const GtkInputPurpose_GTK_INPUT_PURPOSE_PIN: GtkInputPurpose = 9;
#[doc = " GtkInputPurpose:\n @GTK_INPUT_PURPOSE_FREE_FORM: Allow any character\n @GTK_INPUT_PURPOSE_ALPHA: Allow only alphabetic characters\n @GTK_INPUT_PURPOSE_DIGITS: Allow only digits\n @GTK_INPUT_PURPOSE_NUMBER: Edited field expects numbers\n @GTK_INPUT_PURPOSE_PHONE: Edited field expects phone number\n @GTK_INPUT_PURPOSE_URL: Edited field expects URL\n @GTK_INPUT_PURPOSE_EMAIL: Edited field expects email address\n @GTK_INPUT_PURPOSE_NAME: Edited field expects the name of a person\n @GTK_INPUT_PURPOSE_PASSWORD: Like @GTK_INPUT_PURPOSE_FREE_FORM, but characters are hidden\n @GTK_INPUT_PURPOSE_PIN: Like @GTK_INPUT_PURPOSE_DIGITS, but characters are hidden\n\n Describes primary purpose of the input widget. This information is\n useful for on-screen keyboards and similar input methods to decide\n which keys should be presented to the user.\n\n Note that the purpose is not meant to impose a totally strict rule\n about allowed characters, and does not replace input validation.\n It is fine for an on-screen keyboard to let the user override the\n character set restriction that is expressed by the purpose. The\n application is expected to validate the entry contents, even if\n it specified a purpose.\n\n The difference between @GTK_INPUT_PURPOSE_DIGITS and\n @GTK_INPUT_PURPOSE_NUMBER is that the former accepts only digits\n while the latter also some punctuation (like commas or points, plus,\n minus) and “e” or “E” as in 3.14E+000.\n\n This enumeration may be extended in the future; input methods should\n interpret unknown values as “free form”.\n\n Since: 3.6"]
pub type GtkInputPurpose = ::std::os::raw::c_uint;
pub const GtkInputHints_GTK_INPUT_HINT_NONE: GtkInputHints = 0;
pub const GtkInputHints_GTK_INPUT_HINT_SPELLCHECK: GtkInputHints = 1;
pub const GtkInputHints_GTK_INPUT_HINT_NO_SPELLCHECK: GtkInputHints = 2;
pub const GtkInputHints_GTK_INPUT_HINT_WORD_COMPLETION: GtkInputHints = 4;
pub const GtkInputHints_GTK_INPUT_HINT_LOWERCASE: GtkInputHints = 8;
pub const GtkInputHints_GTK_INPUT_HINT_UPPERCASE_CHARS: GtkInputHints = 16;
pub const GtkInputHints_GTK_INPUT_HINT_UPPERCASE_WORDS: GtkInputHints = 32;
pub const GtkInputHints_GTK_INPUT_HINT_UPPERCASE_SENTENCES: GtkInputHints = 64;
pub const GtkInputHints_GTK_INPUT_HINT_INHIBIT_OSK: GtkInputHints = 128;
#[doc = " GtkInputHints:\n @GTK_INPUT_HINT_NONE: No special behaviour suggested\n @GTK_INPUT_HINT_SPELLCHECK: Suggest checking for typos\n @GTK_INPUT_HINT_NO_SPELLCHECK: Suggest not checking for typos\n @GTK_INPUT_HINT_WORD_COMPLETION: Suggest word completion\n @GTK_INPUT_HINT_LOWERCASE: Suggest to convert all text to lowercase\n @GTK_INPUT_HINT_UPPERCASE_CHARS: Suggest to capitalize all text\n @GTK_INPUT_HINT_UPPERCASE_WORDS: Suggest to capitalize the first\n character of each word\n @GTK_INPUT_HINT_UPPERCASE_SENTENCES: Suggest to capitalize the\n first word of each sentence\n @GTK_INPUT_HINT_INHIBIT_OSK: Suggest to not show an onscreen keyboard\n (e.g for a calculator that already has all the keys).\n\n Describes hints that might be taken into account by input methods\n or applications. Note that input methods may already tailor their\n behaviour according to the #GtkInputPurpose of the entry.\n\n Some common sense is expected when using these flags - mixing\n @GTK_INPUT_HINT_LOWERCASE with any of the uppercase hints makes no sense.\n\n This enumeration may be extended in the future; input methods should\n ignore unknown values.\n\n Since: 3.6"]
pub type GtkInputHints = ::std::os::raw::c_uint;
pub const GtkPropagationPhase_GTK_PHASE_NONE: GtkPropagationPhase = 0;
pub const GtkPropagationPhase_GTK_PHASE_CAPTURE: GtkPropagationPhase = 1;
pub const GtkPropagationPhase_GTK_PHASE_BUBBLE: GtkPropagationPhase = 2;
pub const GtkPropagationPhase_GTK_PHASE_TARGET: GtkPropagationPhase = 3;
#[doc = " GtkPropagationPhase:\n @GTK_PHASE_NONE: Events are not delivered automatically. Those can be\n manually fed through gtk_event_controller_handle_event(). This should\n only be used when full control about when, or whether the controller\n handles the event is needed.\n @GTK_PHASE_CAPTURE: Events are delivered in the capture phase. The\n capture phase happens before the bubble phase, runs from the toplevel down\n to the event widget. This option should only be used on containers that\n might possibly handle events before their children do.\n @GTK_PHASE_BUBBLE: Events are delivered in the bubble phase. The bubble\n phase happens after the capture phase, and before the default handlers\n are run. This phase runs from the event widget, up to the toplevel.\n @GTK_PHASE_TARGET: Events are delivered in the default widget event handlers,\n note that widget implementations must chain up on button, motion, touch and\n grab broken handlers for controllers in this phase to be run.\n\n Describes the stage at which events are fed into a #GtkEventController.\n\n Since: 3.14"]
pub type GtkPropagationPhase = ::std::os::raw::c_uint;
pub const GtkEventSequenceState_GTK_EVENT_SEQUENCE_NONE: GtkEventSequenceState = 0;
pub const GtkEventSequenceState_GTK_EVENT_SEQUENCE_CLAIMED: GtkEventSequenceState = 1;
pub const GtkEventSequenceState_GTK_EVENT_SEQUENCE_DENIED: GtkEventSequenceState = 2;
#[doc = " GtkEventSequenceState:\n @GTK_EVENT_SEQUENCE_NONE: The sequence is handled, but not grabbed.\n @GTK_EVENT_SEQUENCE_CLAIMED: The sequence is handled and grabbed.\n @GTK_EVENT_SEQUENCE_DENIED: The sequence is denied.\n\n Describes the state of a #GdkEventSequence in a #GtkGesture.\n\n Since: 3.14"]
pub type GtkEventSequenceState = ::std::os::raw::c_uint;
pub const GtkAccelFlags_GTK_ACCEL_VISIBLE: GtkAccelFlags = 1;
pub const GtkAccelFlags_GTK_ACCEL_LOCKED: GtkAccelFlags = 2;
pub const GtkAccelFlags_GTK_ACCEL_MASK: GtkAccelFlags = 7;
#[doc = " GtkAccelFlags:\n @GTK_ACCEL_VISIBLE: Accelerator is visible\n @GTK_ACCEL_LOCKED: Accelerator not removable\n @GTK_ACCEL_MASK: Mask\n\n Accelerator flags used with gtk_accel_group_connect()."]
pub type GtkAccelFlags = ::std::os::raw::c_uint;
#[doc = " GtkAccelGroup:\n\n An object representing and maintaining a group of accelerators."]
pub type GtkAccelGroup = _GtkAccelGroup;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAccelGroupPrivate {
_unused: [u8; 0],
}
pub type GtkAccelGroupPrivate = _GtkAccelGroupPrivate;
#[doc = " GtkAccelKey:\n @accel_key: The accelerator keyval\n @accel_mods:The accelerator modifiers\n @accel_flags: The accelerator flags"]
pub type GtkAccelKey = _GtkAccelKey;
pub type GtkAccelGroupEntry = _GtkAccelGroupEntry;
#[doc = " GtkAccelGroupFindFunc:\n @key:\n @closure:\n @data: (closure):\n\n Since: 2.2"]
pub type GtkAccelGroupFindFunc = ::std::option::Option<
unsafe extern "C" fn(key: *mut GtkAccelKey, closure: *mut GClosure, data: gpointer) -> gboolean,
>;
#[doc = " GtkAccelGroup:\n\n An object representing and maintaining a group of accelerators."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAccelGroup {
pub parent: GObject,
pub priv_: *mut GtkAccelGroupPrivate,
}
#[test]
fn bindgen_test_layout__GtkAccelGroup() {
const UNINIT: ::std::mem::MaybeUninit<_GtkAccelGroup> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkAccelGroup>(),
32usize,
concat!("Size of: ", stringify!(_GtkAccelGroup))
);
assert_eq!(
::std::mem::align_of::<_GtkAccelGroup>(),
8usize,
concat!("Alignment of ", stringify!(_GtkAccelGroup))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkAccelGroup),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkAccelGroup),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkAccelGroup {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GtkAccelKey:\n @accel_key: The accelerator keyval\n @accel_mods:The accelerator modifiers\n @accel_flags: The accelerator flags"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAccelKey {
pub accel_key: guint,
pub accel_mods: GdkModifierType,
pub _bitfield_align_1: [u16; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
pub __bindgen_padding_0: u16,
}
#[test]
fn bindgen_test_layout__GtkAccelKey() {
const UNINIT: ::std::mem::MaybeUninit<_GtkAccelKey> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkAccelKey>(),
12usize,
concat!("Size of: ", stringify!(_GtkAccelKey))
);
assert_eq!(
::std::mem::align_of::<_GtkAccelKey>(),
4usize,
concat!("Alignment of ", stringify!(_GtkAccelKey))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).accel_key) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkAccelKey),
"::",
stringify!(accel_key)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).accel_mods) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_GtkAccelKey),
"::",
stringify!(accel_mods)
)
);
}
impl Default for _GtkAccelKey {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl _GtkAccelKey {
#[inline]
pub fn accel_flags(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
}
#[inline]
pub fn set_accel_flags(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 16u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(accel_flags: guint) -> __BindgenBitfieldUnit<[u8; 2usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 16u8, {
let accel_flags: u32 = unsafe { ::std::mem::transmute(accel_flags) };
accel_flags as u64
});
__bindgen_bitfield_unit
}
}
extern "C" {
pub fn gtk_accel_group_get_type() -> GType;
}
extern "C" {
pub fn gtk_accel_group_new() -> *mut GtkAccelGroup;
}
extern "C" {
pub fn gtk_accel_group_get_is_locked(accel_group: *mut GtkAccelGroup) -> gboolean;
}
extern "C" {
pub fn gtk_accel_group_get_modifier_mask(accel_group: *mut GtkAccelGroup) -> GdkModifierType;
}
extern "C" {
pub fn gtk_accel_group_lock(accel_group: *mut GtkAccelGroup);
}
extern "C" {
pub fn gtk_accel_group_unlock(accel_group: *mut GtkAccelGroup);
}
extern "C" {
pub fn gtk_accel_group_connect(
accel_group: *mut GtkAccelGroup,
accel_key: guint,
accel_mods: GdkModifierType,
accel_flags: GtkAccelFlags,
closure: *mut GClosure,
);
}
extern "C" {
pub fn gtk_accel_group_connect_by_path(
accel_group: *mut GtkAccelGroup,
accel_path: *const gchar,
closure: *mut GClosure,
);
}
extern "C" {
pub fn gtk_accel_group_disconnect(
accel_group: *mut GtkAccelGroup,
closure: *mut GClosure,
) -> gboolean;
}
extern "C" {
pub fn gtk_accel_group_disconnect_key(
accel_group: *mut GtkAccelGroup,
accel_key: guint,
accel_mods: GdkModifierType,
) -> gboolean;
}
extern "C" {
pub fn gtk_accel_group_activate(
accel_group: *mut GtkAccelGroup,
accel_quark: GQuark,
acceleratable: *mut GObject,
accel_key: guint,
accel_mods: GdkModifierType,
) -> gboolean;
}
extern "C" {
pub fn gtk_accel_groups_activate(
object: *mut GObject,
accel_key: guint,
accel_mods: GdkModifierType,
) -> gboolean;
}
extern "C" {
pub fn gtk_accel_groups_from_object(object: *mut GObject) -> *mut GSList;
}
extern "C" {
pub fn gtk_accel_group_find(
accel_group: *mut GtkAccelGroup,
find_func: GtkAccelGroupFindFunc,
data: gpointer,
) -> *mut GtkAccelKey;
}
extern "C" {
pub fn gtk_accel_group_from_accel_closure(closure: *mut GClosure) -> *mut GtkAccelGroup;
}
extern "C" {
pub fn gtk_accelerator_valid(keyval: guint, modifiers: GdkModifierType) -> gboolean;
}
extern "C" {
pub fn gtk_accelerator_parse(
accelerator: *const gchar,
accelerator_key: *mut guint,
accelerator_mods: *mut GdkModifierType,
);
}
extern "C" {
pub fn gtk_accelerator_parse_with_keycode(
accelerator: *const gchar,
accelerator_key: *mut guint,
accelerator_codes: *mut *mut guint,
accelerator_mods: *mut GdkModifierType,
);
}
extern "C" {
pub fn gtk_accelerator_name(
accelerator_key: guint,
accelerator_mods: GdkModifierType,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_accelerator_name_with_keycode(
display: *mut GdkDisplay,
accelerator_key: guint,
keycode: guint,
accelerator_mods: GdkModifierType,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_accelerator_get_label(
accelerator_key: guint,
accelerator_mods: GdkModifierType,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_accelerator_get_label_with_keycode(
display: *mut GdkDisplay,
accelerator_key: guint,
keycode: guint,
accelerator_mods: GdkModifierType,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_accelerator_set_default_mod_mask(default_mod_mask: GdkModifierType);
}
extern "C" {
pub fn gtk_accelerator_get_default_mod_mask() -> GdkModifierType;
}
extern "C" {
pub fn gtk_accel_group_query(
accel_group: *mut GtkAccelGroup,
accel_key: guint,
accel_mods: GdkModifierType,
n_entries: *mut guint,
) -> *mut GtkAccelGroupEntry;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAccelGroupEntry {
pub key: GtkAccelKey,
pub closure: *mut GClosure,
pub accel_path_quark: GQuark,
}
#[test]
fn bindgen_test_layout__GtkAccelGroupEntry() {
const UNINIT: ::std::mem::MaybeUninit<_GtkAccelGroupEntry> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkAccelGroupEntry>(),
32usize,
concat!("Size of: ", stringify!(_GtkAccelGroupEntry))
);
assert_eq!(
::std::mem::align_of::<_GtkAccelGroupEntry>(),
8usize,
concat!("Alignment of ", stringify!(_GtkAccelGroupEntry))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkAccelGroupEntry),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).closure) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GtkAccelGroupEntry),
"::",
stringify!(closure)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).accel_path_quark) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkAccelGroupEntry),
"::",
stringify!(accel_path_quark)
)
);
}
impl Default for _GtkAccelGroupEntry {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GtkBorder:\n @left: The width of the left border\n @right: The width of the right border\n @top: The width of the top border\n @bottom: The width of the bottom border\n\n A struct that specifies a border around a rectangular area\n that can be of different width on each side."]
pub type GtkBorder = _GtkBorder;
#[doc = " GtkBorder:\n @left: The width of the left border\n @right: The width of the right border\n @top: The width of the top border\n @bottom: The width of the bottom border\n\n A struct that specifies a border around a rectangular area\n that can be of different width on each side."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _GtkBorder {
pub left: gint16,
pub right: gint16,
pub top: gint16,
pub bottom: gint16,
}
#[test]
fn bindgen_test_layout__GtkBorder() {
const UNINIT: ::std::mem::MaybeUninit<_GtkBorder> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkBorder>(),
8usize,
concat!("Size of: ", stringify!(_GtkBorder))
);
assert_eq!(
::std::mem::align_of::<_GtkBorder>(),
2usize,
concat!("Alignment of ", stringify!(_GtkBorder))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).left) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkBorder),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).right) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(_GtkBorder),
"::",
stringify!(right)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).top) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_GtkBorder),
"::",
stringify!(top)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bottom) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(_GtkBorder),
"::",
stringify!(bottom)
)
);
}
extern "C" {
pub fn gtk_border_get_type() -> GType;
}
extern "C" {
pub fn gtk_border_new() -> *mut GtkBorder;
}
extern "C" {
pub fn gtk_border_copy(border_: *const GtkBorder) -> *mut GtkBorder;
}
extern "C" {
pub fn gtk_border_free(border_: *mut GtkBorder);
}
#[doc = " GtkAdjustment:\n\n The #GtkAdjustment-struct contains only private fields and\n should not be directly accessed."]
pub type GtkAdjustment = _GtkAdjustment;
pub type GtkBuilder = _GtkBuilder;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkClipboard {
_unused: [u8; 0],
}
pub type GtkClipboard = _GtkClipboard;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkIconSet {
_unused: [u8; 0],
}
pub type GtkIconSet = _GtkIconSet;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkIconSource {
_unused: [u8; 0],
}
pub type GtkIconSource = _GtkIconSource;
#[doc = " GtkRcStyle:\n @name: Name\n @bg_pixmap_name: Pixmap name\n @font_desc: A #PangoFontDescription\n @color_flags: #GtkRcFlags\n @fg: Foreground colors\n @bg: Background colors\n @text: Text colors\n @base: Base colors\n @xthickness: X thickness\n @ythickness: Y thickness\n\n The #GtkRcStyle-struct is used to represent a set\n of information about the appearance of a widget.\n This can later be composited together with other\n #GtkRcStyle-struct<!-- -->s to form a #GtkStyle."]
pub type GtkRcStyle = _GtkRcStyle;
#[doc = " GtkRequisition:\n @width: the widget’s desired width\n @height: the widget’s desired height\n\n A #GtkRequisition-struct represents the desired size of a widget. See\n [GtkWidget’s geometry management section][geometry-management] for\n more information."]
pub type GtkRequisition = _GtkRequisition;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkSelectionData {
_unused: [u8; 0],
}
pub type GtkSelectionData = _GtkSelectionData;
pub type GtkSettings = _GtkSettings;
#[doc = " GtkStyle:\n @fg: Set of foreground #GdkColor\n @bg: Set of background #GdkColor\n @light: Set of light #GdkColor\n @dark: Set of dark #GdkColor\n @mid: Set of mid #GdkColor\n @text: Set of text #GdkColor\n @base: Set of base #GdkColor\n @text_aa: Color halfway between text/base\n @black: #GdkColor to use for black\n @white: #GdkColor to use for white\n @font_desc: #PangoFontDescription\n @xthickness: Thickness in X direction\n @ythickness: Thickness in Y direction\n @background: Set of background #cairo_pattern_t"]
pub type GtkStyle = _GtkStyle;
pub type GtkStyleContext = _GtkStyleContext;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTooltip {
_unused: [u8; 0],
}
pub type GtkTooltip = _GtkTooltip;
pub type GtkWidget = _GtkWidget;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkWidgetPath {
_unused: [u8; 0],
}
pub type GtkWidgetPath = _GtkWidgetPath;
pub type GtkWindow = _GtkWindow;
pub type GtkRcPropertyParser = ::std::option::Option<
unsafe extern "C" fn(
pspec: *const GParamSpec,
rc_string: *const GString,
property_value: *mut GValue,
) -> gboolean,
>;
pub type GtkBuilderConnectFunc = ::std::option::Option<
unsafe extern "C" fn(
builder: *mut GtkBuilder,
object: *mut GObject,
signal_name: *const gchar,
handler_name: *const gchar,
connect_object: *mut GObject,
flags: GConnectFlags,
user_data: gpointer,
),
>;
pub const AtkRole_ATK_ROLE_INVALID: AtkRole = 0;
pub const AtkRole_ATK_ROLE_ACCEL_LABEL: AtkRole = 1;
pub const AtkRole_ATK_ROLE_ALERT: AtkRole = 2;
pub const AtkRole_ATK_ROLE_ANIMATION: AtkRole = 3;
pub const AtkRole_ATK_ROLE_ARROW: AtkRole = 4;
pub const AtkRole_ATK_ROLE_CALENDAR: AtkRole = 5;
pub const AtkRole_ATK_ROLE_CANVAS: AtkRole = 6;
pub const AtkRole_ATK_ROLE_CHECK_BOX: AtkRole = 7;
pub const AtkRole_ATK_ROLE_CHECK_MENU_ITEM: AtkRole = 8;
pub const AtkRole_ATK_ROLE_COLOR_CHOOSER: AtkRole = 9;
pub const AtkRole_ATK_ROLE_COLUMN_HEADER: AtkRole = 10;
pub const AtkRole_ATK_ROLE_COMBO_BOX: AtkRole = 11;
pub const AtkRole_ATK_ROLE_DATE_EDITOR: AtkRole = 12;
pub const AtkRole_ATK_ROLE_DESKTOP_ICON: AtkRole = 13;
pub const AtkRole_ATK_ROLE_DESKTOP_FRAME: AtkRole = 14;
pub const AtkRole_ATK_ROLE_DIAL: AtkRole = 15;
pub const AtkRole_ATK_ROLE_DIALOG: AtkRole = 16;
pub const AtkRole_ATK_ROLE_DIRECTORY_PANE: AtkRole = 17;
pub const AtkRole_ATK_ROLE_DRAWING_AREA: AtkRole = 18;
pub const AtkRole_ATK_ROLE_FILE_CHOOSER: AtkRole = 19;
pub const AtkRole_ATK_ROLE_FILLER: AtkRole = 20;
pub const AtkRole_ATK_ROLE_FONT_CHOOSER: AtkRole = 21;
pub const AtkRole_ATK_ROLE_FRAME: AtkRole = 22;
pub const AtkRole_ATK_ROLE_GLASS_PANE: AtkRole = 23;
pub const AtkRole_ATK_ROLE_HTML_CONTAINER: AtkRole = 24;
pub const AtkRole_ATK_ROLE_ICON: AtkRole = 25;
pub const AtkRole_ATK_ROLE_IMAGE: AtkRole = 26;
pub const AtkRole_ATK_ROLE_INTERNAL_FRAME: AtkRole = 27;
pub const AtkRole_ATK_ROLE_LABEL: AtkRole = 28;
pub const AtkRole_ATK_ROLE_LAYERED_PANE: AtkRole = 29;
pub const AtkRole_ATK_ROLE_LIST: AtkRole = 30;
pub const AtkRole_ATK_ROLE_LIST_ITEM: AtkRole = 31;
pub const AtkRole_ATK_ROLE_MENU: AtkRole = 32;
pub const AtkRole_ATK_ROLE_MENU_BAR: AtkRole = 33;
pub const AtkRole_ATK_ROLE_MENU_ITEM: AtkRole = 34;
pub const AtkRole_ATK_ROLE_OPTION_PANE: AtkRole = 35;
pub const AtkRole_ATK_ROLE_PAGE_TAB: AtkRole = 36;
pub const AtkRole_ATK_ROLE_PAGE_TAB_LIST: AtkRole = 37;
pub const AtkRole_ATK_ROLE_PANEL: AtkRole = 38;
pub const AtkRole_ATK_ROLE_PASSWORD_TEXT: AtkRole = 39;
pub const AtkRole_ATK_ROLE_POPUP_MENU: AtkRole = 40;
pub const AtkRole_ATK_ROLE_PROGRESS_BAR: AtkRole = 41;
pub const AtkRole_ATK_ROLE_PUSH_BUTTON: AtkRole = 42;
pub const AtkRole_ATK_ROLE_RADIO_BUTTON: AtkRole = 43;
pub const AtkRole_ATK_ROLE_RADIO_MENU_ITEM: AtkRole = 44;
pub const AtkRole_ATK_ROLE_ROOT_PANE: AtkRole = 45;
pub const AtkRole_ATK_ROLE_ROW_HEADER: AtkRole = 46;
pub const AtkRole_ATK_ROLE_SCROLL_BAR: AtkRole = 47;
pub const AtkRole_ATK_ROLE_SCROLL_PANE: AtkRole = 48;
pub const AtkRole_ATK_ROLE_SEPARATOR: AtkRole = 49;
pub const AtkRole_ATK_ROLE_SLIDER: AtkRole = 50;
pub const AtkRole_ATK_ROLE_SPLIT_PANE: AtkRole = 51;
pub const AtkRole_ATK_ROLE_SPIN_BUTTON: AtkRole = 52;
pub const AtkRole_ATK_ROLE_STATUSBAR: AtkRole = 53;
pub const AtkRole_ATK_ROLE_TABLE: AtkRole = 54;
pub const AtkRole_ATK_ROLE_TABLE_CELL: AtkRole = 55;
pub const AtkRole_ATK_ROLE_TABLE_COLUMN_HEADER: AtkRole = 56;
pub const AtkRole_ATK_ROLE_TABLE_ROW_HEADER: AtkRole = 57;
pub const AtkRole_ATK_ROLE_TEAR_OFF_MENU_ITEM: AtkRole = 58;
pub const AtkRole_ATK_ROLE_TERMINAL: AtkRole = 59;
pub const AtkRole_ATK_ROLE_TEXT: AtkRole = 60;
pub const AtkRole_ATK_ROLE_TOGGLE_BUTTON: AtkRole = 61;
pub const AtkRole_ATK_ROLE_TOOL_BAR: AtkRole = 62;
pub const AtkRole_ATK_ROLE_TOOL_TIP: AtkRole = 63;
pub const AtkRole_ATK_ROLE_TREE: AtkRole = 64;
pub const AtkRole_ATK_ROLE_TREE_TABLE: AtkRole = 65;
pub const AtkRole_ATK_ROLE_UNKNOWN: AtkRole = 66;
pub const AtkRole_ATK_ROLE_VIEWPORT: AtkRole = 67;
pub const AtkRole_ATK_ROLE_WINDOW: AtkRole = 68;
pub const AtkRole_ATK_ROLE_HEADER: AtkRole = 69;
pub const AtkRole_ATK_ROLE_FOOTER: AtkRole = 70;
pub const AtkRole_ATK_ROLE_PARAGRAPH: AtkRole = 71;
pub const AtkRole_ATK_ROLE_RULER: AtkRole = 72;
pub const AtkRole_ATK_ROLE_APPLICATION: AtkRole = 73;
pub const AtkRole_ATK_ROLE_AUTOCOMPLETE: AtkRole = 74;
pub const AtkRole_ATK_ROLE_EDITBAR: AtkRole = 75;
pub const AtkRole_ATK_ROLE_EMBEDDED: AtkRole = 76;
pub const AtkRole_ATK_ROLE_ENTRY: AtkRole = 77;
pub const AtkRole_ATK_ROLE_CHART: AtkRole = 78;
pub const AtkRole_ATK_ROLE_CAPTION: AtkRole = 79;
pub const AtkRole_ATK_ROLE_DOCUMENT_FRAME: AtkRole = 80;
pub const AtkRole_ATK_ROLE_HEADING: AtkRole = 81;
pub const AtkRole_ATK_ROLE_PAGE: AtkRole = 82;
pub const AtkRole_ATK_ROLE_SECTION: AtkRole = 83;
pub const AtkRole_ATK_ROLE_REDUNDANT_OBJECT: AtkRole = 84;
pub const AtkRole_ATK_ROLE_FORM: AtkRole = 85;
pub const AtkRole_ATK_ROLE_LINK: AtkRole = 86;
pub const AtkRole_ATK_ROLE_INPUT_METHOD_WINDOW: AtkRole = 87;
pub const AtkRole_ATK_ROLE_TABLE_ROW: AtkRole = 88;
pub const AtkRole_ATK_ROLE_TREE_ITEM: AtkRole = 89;
pub const AtkRole_ATK_ROLE_DOCUMENT_SPREADSHEET: AtkRole = 90;
pub const AtkRole_ATK_ROLE_DOCUMENT_PRESENTATION: AtkRole = 91;
pub const AtkRole_ATK_ROLE_DOCUMENT_TEXT: AtkRole = 92;
pub const AtkRole_ATK_ROLE_DOCUMENT_WEB: AtkRole = 93;
pub const AtkRole_ATK_ROLE_DOCUMENT_EMAIL: AtkRole = 94;
pub const AtkRole_ATK_ROLE_COMMENT: AtkRole = 95;
pub const AtkRole_ATK_ROLE_LIST_BOX: AtkRole = 96;
pub const AtkRole_ATK_ROLE_GROUPING: AtkRole = 97;
pub const AtkRole_ATK_ROLE_IMAGE_MAP: AtkRole = 98;
pub const AtkRole_ATK_ROLE_NOTIFICATION: AtkRole = 99;
pub const AtkRole_ATK_ROLE_INFO_BAR: AtkRole = 100;
pub const AtkRole_ATK_ROLE_LEVEL_BAR: AtkRole = 101;
pub const AtkRole_ATK_ROLE_TITLE_BAR: AtkRole = 102;
pub const AtkRole_ATK_ROLE_BLOCK_QUOTE: AtkRole = 103;
pub const AtkRole_ATK_ROLE_AUDIO: AtkRole = 104;
pub const AtkRole_ATK_ROLE_VIDEO: AtkRole = 105;
pub const AtkRole_ATK_ROLE_DEFINITION: AtkRole = 106;
pub const AtkRole_ATK_ROLE_ARTICLE: AtkRole = 107;
pub const AtkRole_ATK_ROLE_LANDMARK: AtkRole = 108;
pub const AtkRole_ATK_ROLE_LOG: AtkRole = 109;
pub const AtkRole_ATK_ROLE_MARQUEE: AtkRole = 110;
pub const AtkRole_ATK_ROLE_MATH: AtkRole = 111;
pub const AtkRole_ATK_ROLE_RATING: AtkRole = 112;
pub const AtkRole_ATK_ROLE_TIMER: AtkRole = 113;
pub const AtkRole_ATK_ROLE_DESCRIPTION_LIST: AtkRole = 114;
pub const AtkRole_ATK_ROLE_DESCRIPTION_TERM: AtkRole = 115;
pub const AtkRole_ATK_ROLE_DESCRIPTION_VALUE: AtkRole = 116;
pub const AtkRole_ATK_ROLE_LAST_DEFINED: AtkRole = 117;
#[doc = "AtkRole:\n@ATK_ROLE_INVALID: Invalid role\n@ATK_ROLE_ACCEL_LABEL: A label which represents an accelerator\n@ATK_ROLE_ALERT: An object which is an alert to the user. Assistive Technologies typically respond to ATK_ROLE_ALERT by reading the entire onscreen contents of containers advertising this role. Should be used for warning dialogs, etc.\n@ATK_ROLE_ANIMATION: An object which is an animated image\n@ATK_ROLE_ARROW: An arrow in one of the four cardinal directions\n@ATK_ROLE_CALENDAR: An object that displays a calendar and allows the user to select a date\n@ATK_ROLE_CANVAS: An object that can be drawn into and is used to trap events\n@ATK_ROLE_CHECK_BOX: A choice that can be checked or unchecked and provides a separate indicator for the current state\n@ATK_ROLE_CHECK_MENU_ITEM: A menu item with a check box\n@ATK_ROLE_COLOR_CHOOSER: A specialized dialog that lets the user choose a color\n@ATK_ROLE_COLUMN_HEADER: The header for a column of data\n@ATK_ROLE_COMBO_BOX: A collapsible list of choices the user can select from\n@ATK_ROLE_DATE_EDITOR: An object whose purpose is to allow a user to edit a date\n@ATK_ROLE_DESKTOP_ICON: An inconifed internal frame within a DESKTOP_PANE\n@ATK_ROLE_DESKTOP_FRAME: A pane that supports internal frames and iconified versions of those internal frames\n@ATK_ROLE_DIAL: An object whose purpose is to allow a user to set a value\n@ATK_ROLE_DIALOG: A top level window with title bar and a border\n@ATK_ROLE_DIRECTORY_PANE: A pane that allows the user to navigate through and select the contents of a directory\n@ATK_ROLE_DRAWING_AREA: An object used for drawing custom user interface elements\n@ATK_ROLE_FILE_CHOOSER: A specialized dialog that lets the user choose a file\n@ATK_ROLE_FILLER: A object that fills up space in a user interface\n@ATK_ROLE_FONT_CHOOSER: A specialized dialog that lets the user choose a font\n@ATK_ROLE_FRAME: A top level window with a title bar, border, menubar, etc.\n@ATK_ROLE_GLASS_PANE: A pane that is guaranteed to be painted on top of all panes beneath it\n@ATK_ROLE_HTML_CONTAINER: A document container for HTML, whose children represent the document content\n@ATK_ROLE_ICON: A small fixed size picture, typically used to decorate components\n@ATK_ROLE_IMAGE: An object whose primary purpose is to display an image\n@ATK_ROLE_INTERNAL_FRAME: A frame-like object that is clipped by a desktop pane\n@ATK_ROLE_LABEL: An object used to present an icon or short string in an interface\n@ATK_ROLE_LAYERED_PANE: A specialized pane that allows its children to be drawn in layers, providing a form of stacking order\n@ATK_ROLE_LIST: An object that presents a list of objects to the user and allows the user to select one or more of them\n@ATK_ROLE_LIST_ITEM: An object that represents an element of a list\n@ATK_ROLE_MENU: An object usually found inside a menu bar that contains a list of actions the user can choose from\n@ATK_ROLE_MENU_BAR: An object usually drawn at the top of the primary dialog box of an application that contains a list of menus the user can choose from\n@ATK_ROLE_MENU_ITEM: An object usually contained in a menu that presents an action the user can choose\n@ATK_ROLE_OPTION_PANE: A specialized pane whose primary use is inside a DIALOG\n@ATK_ROLE_PAGE_TAB: An object that is a child of a page tab list\n@ATK_ROLE_PAGE_TAB_LIST: An object that presents a series of panels (or page tabs), one at a time, through some mechanism provided by the object\n@ATK_ROLE_PANEL: A generic container that is often used to group objects\n@ATK_ROLE_PASSWORD_TEXT: A text object uses for passwords, or other places where the text content is not shown visibly to the user\n@ATK_ROLE_POPUP_MENU: A temporary window that is usually used to offer the user a list of choices, and then hides when the user selects one of those choices\n@ATK_ROLE_PROGRESS_BAR: An object used to indicate how much of a task has been completed\n@ATK_ROLE_PUSH_BUTTON: An object the user can manipulate to tell the application to do something\n@ATK_ROLE_RADIO_BUTTON: A specialized check box that will cause other radio buttons in the same group to become unchecked when this one is checked\n@ATK_ROLE_RADIO_MENU_ITEM: A check menu item which belongs to a group. At each instant exactly one of the radio menu items from a group is selected\n@ATK_ROLE_ROOT_PANE: A specialized pane that has a glass pane and a layered pane as its children\n@ATK_ROLE_ROW_HEADER: The header for a row of data\n@ATK_ROLE_SCROLL_BAR: An object usually used to allow a user to incrementally view a large amount of data.\n@ATK_ROLE_SCROLL_PANE: An object that allows a user to incrementally view a large amount of information\n@ATK_ROLE_SEPARATOR: An object usually contained in a menu to provide a visible and logical separation of the contents in a menu\n@ATK_ROLE_SLIDER: An object that allows the user to select from a bounded range\n@ATK_ROLE_SPLIT_PANE: A specialized panel that presents two other panels at the same time\n@ATK_ROLE_SPIN_BUTTON: An object used to get an integer or floating point number from the user\n@ATK_ROLE_STATUSBAR: An object which reports messages of minor importance to the user\n@ATK_ROLE_TABLE: An object used to represent information in terms of rows and columns\n@ATK_ROLE_TABLE_CELL: A cell in a table\n@ATK_ROLE_TABLE_COLUMN_HEADER: The header for a column of a table\n@ATK_ROLE_TABLE_ROW_HEADER: The header for a row of a table\n@ATK_ROLE_TEAR_OFF_MENU_ITEM: A menu item used to tear off and reattach its menu\n@ATK_ROLE_TERMINAL: An object that represents an accessible terminal. @Since: ATK-0.6\n@ATK_ROLE_TEXT: An object that presents text to the user\n@ATK_ROLE_TOGGLE_BUTTON: A specialized push button that can be checked or unchecked, but does not provide a separate indicator for the current state\n@ATK_ROLE_TOOL_BAR: A bar or palette usually composed of push buttons or toggle buttons\n@ATK_ROLE_TOOL_TIP: An object that provides information about another object\n@ATK_ROLE_TREE: An object used to represent hierarchical information to the user\n@ATK_ROLE_TREE_TABLE: An object capable of expanding and collapsing rows as well as showing multiple columns of data. @Since: ATK-0.7\n@ATK_ROLE_UNKNOWN: The object contains some Accessible information, but its role is not known\n@ATK_ROLE_VIEWPORT: An object usually used in a scroll pane\n@ATK_ROLE_WINDOW: A top level window with no title or border.\n@ATK_ROLE_HEADER: An object that serves as a document header. @Since: ATK-1.1.1\n@ATK_ROLE_FOOTER: An object that serves as a document footer. @Since: ATK-1.1.1\n@ATK_ROLE_PARAGRAPH: An object which is contains a paragraph of text content. @Since: ATK-1.1.1\n@ATK_ROLE_RULER: An object which describes margins and tab stops, etc. for text objects which it controls (should have CONTROLLER_FOR relation to such). @Since: ATK-1.1.1\n@ATK_ROLE_APPLICATION: The object is an application object, which may contain @ATK_ROLE_FRAME objects or other types of accessibles. The root accessible of any application's ATK hierarchy should have ATK_ROLE_APPLICATION. @Since: ATK-1.1.4\n@ATK_ROLE_AUTOCOMPLETE: The object is a dialog or list containing items for insertion into an entry widget, for instance a list of words for completion of a text entry. @Since: ATK-1.3\n@ATK_ROLE_EDITBAR: The object is an editable text object in a toolbar. @Since: ATK-1.5\n@ATK_ROLE_EMBEDDED: The object is an embedded container within a document or panel. This role is a grouping \"hint\" indicating that the contained objects share a context. @Since: ATK-1.7.2\n@ATK_ROLE_ENTRY: The object is a component whose textual content may be entered or modified by the user, provided @ATK_STATE_EDITABLE is present. @Since: ATK-1.11\n@ATK_ROLE_CHART: The object is a graphical depiction of quantitative data. It may contain multiple subelements whose attributes and/or description may be queried to obtain both the quantitative data and information about how the data is being presented. The LABELLED_BY relation is particularly important in interpreting objects of this type, as is the accessible-description property. @Since: ATK-1.11\n@ATK_ROLE_CAPTION: The object contains descriptive information, usually textual, about another user interface element such as a table, chart, or image. @Since: ATK-1.11\n@ATK_ROLE_DOCUMENT_FRAME: The object is a visual frame or container which contains a view of document content. Document frames may occur within another Document instance, in which case the second document may be said to be embedded in the containing instance. HTML frames are often ROLE_DOCUMENT_FRAME. Either this object, or a singleton descendant, should implement the Document interface. @Since: ATK-1.11\n@ATK_ROLE_HEADING: The object serves as a heading for content which follows it in a document. The 'heading level' of the heading, if availabe, may be obtained by querying the object's attributes.\n@ATK_ROLE_PAGE: The object is a containing instance which encapsulates a page of information. @ATK_ROLE_PAGE is used in documents and content which support a paginated navigation model. @Since: ATK-1.11\n@ATK_ROLE_SECTION: The object is a containing instance of document content which constitutes a particular 'logical' section of the document. The type of content within a section, and the nature of the section division itself, may be obtained by querying the object's attributes. Sections may be nested. @Since: ATK-1.11\n@ATK_ROLE_REDUNDANT_OBJECT: The object is redundant with another object in the hierarchy, and is exposed for purely technical reasons. Objects of this role should normally be ignored by clients. @Since: ATK-1.11\n@ATK_ROLE_FORM: The object is a container for form controls, for instance as part of a\n web form or user-input form within a document. This role is primarily a tag/convenience for\n clients when navigating complex documents, it is not expected that ordinary GUI containers will\n always have ATK_ROLE_FORM. @Since: ATK-1.12.0\n@ATK_ROLE_LINK: The object is a hypertext anchor, i.e. a \"link\" in a\n hypertext document. Such objects are distinct from 'inline'\n content which may also use the Hypertext/Hyperlink interfaces\n to indicate the range/location within a text object where\n an inline or embedded object lies. @Since: ATK-1.12.1\n@ATK_ROLE_INPUT_METHOD_WINDOW: The object is a window or similar viewport\n which is used to allow composition or input of a 'complex character',\n in other words it is an \"input method window.\" @Since: ATK-1.12.1\n@ATK_ROLE_TABLE_ROW: A row in a table. @Since: ATK-2.1.0\n@ATK_ROLE_TREE_ITEM: An object that represents an element of a tree. @Since: ATK-2.1.0\n@ATK_ROLE_DOCUMENT_SPREADSHEET: A document frame which contains a spreadsheet. @Since: ATK-2.1.0\n@ATK_ROLE_DOCUMENT_PRESENTATION: A document frame which contains a presentation or slide content. @Since: ATK-2.1.0\n@ATK_ROLE_DOCUMENT_TEXT: A document frame which contains textual content, such as found in a word processing application. @Since: ATK-2.1.0\n@ATK_ROLE_DOCUMENT_WEB: A document frame which contains HTML or other markup suitable for display in a web browser. @Since: ATK-2.1.0\n@ATK_ROLE_DOCUMENT_EMAIL: A document frame which contains email content to be displayed or composed either in plain text or HTML. @Since: ATK-2.1.0\n@ATK_ROLE_COMMENT: An object found within a document and designed to present a comment, note, or other annotation. In some cases, this object might not be visible until activated. @Since: ATK-2.1.0\n@ATK_ROLE_LIST_BOX: A non-collapsible list of choices the user can select from. @Since: ATK-2.1.0\n@ATK_ROLE_GROUPING: A group of related widgets. This group typically has a label. @Since: ATK-2.1.0\n@ATK_ROLE_IMAGE_MAP: An image map object. Usually a graphic with multiple hotspots, where each hotspot can be activated resulting in the loading of another document or section of a document. @Since: ATK-2.1.0\n@ATK_ROLE_NOTIFICATION: A transitory object designed to present a message to the user, typically at the desktop level rather than inside a particular application. @Since: ATK-2.1.0\n@ATK_ROLE_INFO_BAR: An object designed to present a message to the user within an existing window. @Since: ATK-2.1.0\n@ATK_ROLE_LEVEL_BAR: A bar that serves as a level indicator to, for instance, show the strength of a password or the state of a battery. @Since: ATK-2.7.3\n@ATK_ROLE_TITLE_BAR: A bar that serves as the title of a window or a\n dialog. @Since: ATK-2.12\n@ATK_ROLE_BLOCK_QUOTE: An object which contains a text section\n that is quoted from another source. @Since: ATK-2.12\n@ATK_ROLE_AUDIO: An object which represents an audio element. @Since: ATK-2.12\n@ATK_ROLE_VIDEO: An object which represents a video element. @Since: ATK-2.12\n@ATK_ROLE_DEFINITION: A definition of a term or concept. @Since: ATK-2.12\n@ATK_ROLE_ARTICLE: A section of a page that consists of a\n composition that forms an independent part of a document, page, or\n site. Examples: A blog entry, a news story, a forum post. @Since:\n ATK-2.12\n@ATK_ROLE_LANDMARK: A region of a web page intended as a\n navigational landmark. This is designed to allow Assistive\n Technologies to provide quick navigation among key regions within a\n document. @Since: ATK-2.12\n@ATK_ROLE_LOG: A text widget or container holding log content, such\n as chat history and error logs. In this role there is a\n relationship between the arrival of new items in the log and the\n reading order. The log contains a meaningful sequence and new\n information is added only to the end of the log, not at arbitrary\n points. @Since: ATK-2.12\n@ATK_ROLE_MARQUEE: A container where non-essential information\n changes frequently. Common usages of marquee include stock tickers\n and ad banners. The primary difference between a marquee and a log\n is that logs usually have a meaningful order or sequence of\n important content changes. @Since: ATK-2.12\n@ATK_ROLE_MATH: A text widget or container that holds a mathematical\n expression. @Since: ATK-2.12\n@ATK_ROLE_RATING: A widget whose purpose is to display a rating,\n such as the number of stars associated with a song in a media\n player. Objects of this role should also implement\n AtkValue. @Since: ATK-2.12\n@ATK_ROLE_TIMER: An object containing a numerical counter which\n indicates an amount of elapsed time from a start point, or the time\n remaining until an end point. @Since: ATK-2.12\n@ATK_ROLE_DESCRIPTION_LIST: An object that represents a list of\n term-value groups. A term-value group represents a individual\n description and consist of one or more names\n (ATK_ROLE_DESCRIPTION_TERM) followed by one or more values\n (ATK_ROLE_DESCRIPTION_VALUE). For each list, there should not be\n more than one group with the same term name. @Since: ATK-2.12\n@ATK_ROLE_DESCRIPTION_TERM: An object that represents the term, or\n name, part of a term-description group in a description\n list. @Since: ATK-2.12\n@ATK_ROLE_DESCRIPTION_VALUE: An object that represents the\n description, definition or value of a term-description group in a\n description list. The values within a group are alternatives,\n meaning that you can have several ATK_ROLE_DESCRIPTION_VALUE for a\n given ATK_ROLE_DESCRIPTION_TERM. @Since: ATK-2.12\n@ATK_ROLE_LAST_DEFINED: not a valid role, used for finding end of the enumeration\n\n Describes the role of an object\n\n These are the built-in enumerated roles that UI components can have in\n ATK. Other roles may be added at runtime, so an AtkRole >=\n ATK_ROLE_LAST_DEFINED is not necessarily an error."]
pub type AtkRole = ::std::os::raw::c_uint;
pub const AtkLayer_ATK_LAYER_INVALID: AtkLayer = 0;
pub const AtkLayer_ATK_LAYER_BACKGROUND: AtkLayer = 1;
pub const AtkLayer_ATK_LAYER_CANVAS: AtkLayer = 2;
pub const AtkLayer_ATK_LAYER_WIDGET: AtkLayer = 3;
pub const AtkLayer_ATK_LAYER_MDI: AtkLayer = 4;
pub const AtkLayer_ATK_LAYER_POPUP: AtkLayer = 5;
pub const AtkLayer_ATK_LAYER_OVERLAY: AtkLayer = 6;
pub const AtkLayer_ATK_LAYER_WINDOW: AtkLayer = 7;
#[doc = "AtkLayer:\n@ATK_LAYER_INVALID: The object does not have a layer\n@ATK_LAYER_BACKGROUND: This layer is reserved for the desktop background\n@ATK_LAYER_CANVAS: This layer is used for Canvas components\n@ATK_LAYER_WIDGET: This layer is normally used for components\n@ATK_LAYER_MDI: This layer is used for layered components\n@ATK_LAYER_POPUP: This layer is used for popup components, such as menus\n@ATK_LAYER_OVERLAY: This layer is reserved for future use.\n@ATK_LAYER_WINDOW: This layer is used for toplevel windows.\n\n Describes the layer of a component\n\n These enumerated \"layer values\" are used when determining which UI\n rendering layer a component is drawn into, which can help in making\n determinations of when components occlude one another."]
pub type AtkLayer = ::std::os::raw::c_uint;
pub type AtkObject = _AtkObject;
pub type AtkRelationSet = _AtkRelationSet;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _AtkObject {
pub parent: GObject,
pub description: *mut gchar,
pub name: *mut gchar,
pub accessible_parent: *mut AtkObject,
pub role: AtkRole,
pub relation_set: *mut AtkRelationSet,
pub layer: AtkLayer,
}
#[test]
fn bindgen_test_layout__AtkObject() {
const UNINIT: ::std::mem::MaybeUninit<_AtkObject> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_AtkObject>(),
72usize,
concat!("Size of: ", stringify!(_AtkObject))
);
assert_eq!(
::std::mem::align_of::<_AtkObject>(),
8usize,
concat!("Alignment of ", stringify!(_AtkObject))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_AtkObject),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_AtkObject),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_AtkObject),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).accessible_parent) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_AtkObject),
"::",
stringify!(accessible_parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).role) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_AtkObject),
"::",
stringify!(role)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).relation_set) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_AtkObject),
"::",
stringify!(relation_set)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).layer) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_AtkObject),
"::",
stringify!(layer)
)
);
}
impl Default for _AtkObject {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _AtkRelationSet {
pub parent: GObject,
pub relations: *mut GPtrArray,
}
#[test]
fn bindgen_test_layout__AtkRelationSet() {
const UNINIT: ::std::mem::MaybeUninit<_AtkRelationSet> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_AtkRelationSet>(),
32usize,
concat!("Size of: ", stringify!(_AtkRelationSet))
);
assert_eq!(
::std::mem::align_of::<_AtkRelationSet>(),
8usize,
concat!("Alignment of ", stringify!(_AtkRelationSet))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_AtkRelationSet),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).relations) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_AtkRelationSet),
"::",
stringify!(relations)
)
);
}
impl Default for _AtkRelationSet {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const GtkWidgetHelpType_GTK_WIDGET_HELP_TOOLTIP: GtkWidgetHelpType = 0;
pub const GtkWidgetHelpType_GTK_WIDGET_HELP_WHATS_THIS: GtkWidgetHelpType = 1;
#[doc = " GtkWidgetHelpType:\n @GTK_WIDGET_HELP_TOOLTIP: Tooltip.\n @GTK_WIDGET_HELP_WHATS_THIS: What’s this.\n\n Kinds of widget-specific help. Used by the ::show-help signal."]
pub type GtkWidgetHelpType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkWidgetPrivate {
_unused: [u8; 0],
}
pub type GtkWidgetPrivate = _GtkWidgetPrivate;
#[doc = " GtkWidgetClass:\n @parent_class: The object class structure needs to be the first\n element in the widget class structure in order for the class mechanism\n to work correctly. This allows a GtkWidgetClass pointer to be cast to\n a GObjectClass pointer.\n @activate_signal: The signal to emit when a widget of this class is\n activated, gtk_widget_activate() handles the emission.\n Implementation of this signal is optional.\n @dispatch_child_properties_changed: Seldomly overidden.\n @destroy: Signals that all holders of a reference to the widget\n should release the reference that they hold.\n @show: Signal emitted when widget is shown\n @show_all: Recursively shows a widget, and any child widgets (if the widget is\n a container).\n @hide: Signal emitted when widget is hidden.\n @map: Signal emitted when widget is going to be mapped, that is\n when the widget is visible (which is controlled with\n gtk_widget_set_visible()) and all its parents up to the toplevel\n widget are also visible.\n @unmap: Signal emitted when widget is going to be unmapped, which\n means that either it or any of its parents up to the toplevel\n widget have been set as hidden.\n @realize: Signal emitted when widget is associated with a\n #GdkWindow, which means that gtk_widget_realize() has been called or\n the widget has been mapped (that is, it is going to be drawn).\n @unrealize: Signal emitted when the GdkWindow associated with\n widget is destroyed, which means that gtk_widget_unrealize() has\n been called or the widget has been unmapped (that is, it is going\n to be hidden).\n @size_allocate: Signal emitted to get the widget allocation.\n @state_changed: Signal emitted when the widget state\n changes. Deprecated: 3.0\n @state_flags_changed: Signal emitted when the widget state changes,\n see gtk_widget_get_state_flags().\n @parent_set: Signal emitted when a new parent has been set on a\n widget.\n @hierarchy_changed: Signal emitted when the anchored state of a\n widget changes.\n @style_set: Signal emitted when a new style has been set on a\n widget. Deprecated: 3.0\n @direction_changed: Signal emitted when the text direction of a\n widget changes.\n @grab_notify: Signal emitted when a widget becomes shadowed by a\n GTK+ grab (not a pointer or keyboard grab) on another widget, or\n when it becomes unshadowed due to a grab being removed.\n @child_notify: Signal emitted for each child property that has\n changed on an object.\n @draw: Signal emitted when a widget is supposed to render itself.\n @get_request_mode: This allows a widget to tell its parent container whether\n it prefers to be allocated in %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH or\n %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT mode.\n %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH means the widget prefers to have\n #GtkWidgetClass.get_preferred_width() called and then\n #GtkWidgetClass.get_preferred_height_for_width().\n %GTK_SIZE_REQUEST_CONSTANT_SIZE disables any height-for-width or\n width-for-height geometry management for a said widget and is the\n default return.\n It’s important to note (as described below) that any widget\n which trades height-for-width or width-for-height must respond properly\n to both of the virtual methods #GtkWidgetClass.get_preferred_height_for_width()\n and #GtkWidgetClass.get_preferred_width_for_height() since it might be\n queried in either #GtkSizeRequestMode by its parent container.\n @get_preferred_height: This is called by containers to obtain the minimum\n and natural height of a widget. A widget that does not actually trade\n any height for width or width for height only has to implement these\n two virtual methods (#GtkWidgetClass.get_preferred_width() and\n #GtkWidgetClass.get_preferred_height()).\n @get_preferred_width_for_height: This is analogous to\n #GtkWidgetClass.get_preferred_height_for_width() except that it\n operates in the oposite orientation. It’s rare that a widget actually\n does %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT requests but this can happen\n when, for example, a widget or container gets additional columns to\n compensate for a smaller allocated height.\n @get_preferred_width: This is called by containers to obtain the minimum\n and natural width of a widget. A widget will never be allocated a width\n less than its minimum and will only ever be allocated a width greater\n than the natural width once all of the said widget’s siblings have\n received their natural widths.\n Furthermore, a widget will only ever be allocated a width greater than\n its natural width if it was configured to receive extra expand space\n from its parent container.\n @get_preferred_height_for_width: This is similar to\n #GtkWidgetClass.get_preferred_height() except that it is passed a\n contextual width to request height for. By implementing this virtual\n method it is possible for a #GtkLabel to tell its parent how much height\n would be required if the label were to be allocated a said width.\n @mnemonic_activate: Activates the @widget if @group_cycling is\n %FALSE, and just grabs the focus if @group_cycling is %TRUE.\n @grab_focus: Causes @widget to have the keyboard focus for the\n #GtkWindow it’s inside.\n @focus:\n @move_focus: Signal emitted when a change of focus is requested\n @keynav_failed: Signal emitted if keyboard navigation fails.\n @event: The GTK+ main loop will emit three signals for each GDK\n event delivered to a widget: one generic ::event signal, another,\n more specific, signal that matches the type of event delivered\n (e.g. \"key-press-event\") and finally a generic \"event-after\"\n signal.\n @button_press_event: Signal will be emitted when a button\n (typically from a mouse) is pressed.\n @button_release_event: Signal will be emitted when a button\n (typically from a mouse) is released.\n @scroll_event: Signal emitted when a button in the 4 to 7 range is\n pressed.\n @motion_notify_event: Signal emitted when the pointer moves over\n the widget’s #GdkWindow.\n @delete_event: Signal emitted if a user requests that a toplevel\n window is closed.\n @destroy_event: Signal is emitted when a #GdkWindow is destroyed.\n @key_press_event: Signal emitted when a key is pressed.\n @key_release_event: Signal is emitted when a key is released.\n @enter_notify_event: Signal event will be emitted when the pointer\n enters the widget’s window.\n @leave_notify_event: Will be emitted when the pointer leaves the\n widget’s window.\n @configure_event: Signal will be emitted when the size, position or\n stacking of the widget’s window has changed.\n @focus_in_event: Signal emitted when the keyboard focus enters the\n widget’s window.\n @focus_out_event: Signal emitted when the keyboard focus leaves the\n widget’s window.\n @map_event: Signal emitted when the widget’s window is mapped.\n @unmap_event: Signal will be emitted when the widget’s window is\n unmapped.\n @property_notify_event: Signal will be emitted when a property on\n the widget’s window has been changed or deleted.\n @selection_clear_event: Signal will be emitted when the the\n widget’s window has lost ownership of a selection.\n @selection_request_event: Signal will be emitted when another\n client requests ownership of the selection owned by the widget's\n window.\n @selection_notify_event:\n @proximity_in_event:\n @proximity_out_event:\n @visibility_notify_event: Signal emitted when the widget’s window is\n obscured or unobscured.\n @window_state_event: Signal emitted when the state of the toplevel\n window associated to the widget changes.\n @damage_event: Signal emitted when a redirected window belonging to\n widget gets drawn into.\n @grab_broken_event: Signal emitted when a pointer or keyboard grab\n on a window belonging to widget gets broken.\n @selection_get:\n @selection_received:\n @drag_begin: Signal emitted on the drag source when a drag is\n started.\n @drag_end: Signal emitted on the drag source when a drag is\n finished.\n @drag_data_get: Signal emitted on the drag source when the drop\n site requests the data which is dragged.\n @drag_data_delete: Signal emitted on the drag source when a drag\n with the action %GDK_ACTION_MOVE is successfully completed.\n @drag_leave: Signal emitted on the drop site when the cursor leaves\n the widget.\n @drag_motion: signal emitted on the drop site when the user moves\n the cursor over the widget during a drag.\n @drag_drop: Signal emitted on the drop site when the user drops the\n data onto the widget.\n @drag_data_received: Signal emitted on the drop site when the\n dragged data has been received.\n @drag_failed: Signal emitted on the drag source when a drag has\n failed.\n @popup_menu: Signal emitted whenever a widget should pop up a\n context menu.\n @show_help:\n @get_accessible: Returns the accessible object that describes the\n widget to an assistive technology.\n @screen_changed: Signal emitted when the screen of a widget has\n changed.\n @can_activate_accel: Signal allows applications and derived widgets\n to override the default GtkWidget handling for determining whether\n an accelerator can be activated.\n @composited_changed: Signal emitted when the composited status of\n widgets screen changes. See gdk_screen_is_composited().\n @query_tooltip: Signal emitted when “has-tooltip” is %TRUE and the\n hover timeout has expired with the cursor hovering “above”\n widget; or emitted when widget got focus in keyboard mode.\n @compute_expand: Computes whether a container should give this\n widget extra space when possible.\n @adjust_size_request: Convert an initial size request from a widget's\n #GtkSizeRequestMode virtual method implementations into a size request to\n be used by parent containers in laying out the widget.\n adjust_size_request adjusts from a child widget's\n original request to what a parent container should\n use for layout. The @for_size argument will be -1 if the request should\n not be for a particular size in the opposing orientation, i.e. if the\n request is not height-for-width or width-for-height. If @for_size is\n greater than -1, it is the proposed allocation in the opposing\n orientation that we need the request for. Implementations of\n adjust_size_request should chain up to the default implementation,\n which applies #GtkWidget’s margin properties and imposes any values\n from gtk_widget_set_size_request(). Chaining up should be last,\n after your subclass adjusts the request, so\n #GtkWidget can apply constraints and add the margin properly.\n @adjust_size_allocation: Convert an initial size allocation assigned\n by a #GtkContainer using gtk_widget_size_allocate(), into an actual\n size allocation to be used by the widget. adjust_size_allocation\n adjusts to a child widget’s actual allocation\n from what a parent container computed for the\n child. The adjusted allocation must be entirely within the original\n allocation. In any custom implementation, chain up to the default\n #GtkWidget implementation of this method, which applies the margin\n and alignment properties of #GtkWidget. Chain up\n before performing your own adjustments so your\n own adjustments remove more allocation after the #GtkWidget base\n class has already removed margin and alignment. The natural size\n passed in should be adjusted in the same way as the allocated size,\n which allows adjustments to perform alignments or other changes\n based on natural size.\n @style_updated: Signal emitted when the GtkStyleContext of a widget\n is changed.\n @touch_event:\n @get_preferred_height_and_baseline_for_width:\n @adjust_baseline_request:\n @adjust_baseline_allocation:\n @queue_draw_region: Invalidates the area of widget defined by\n region by calling gdk_window_invalidate_region() on the widget's\n window and all its child windows."]
pub type GtkWidgetClass = _GtkWidgetClass;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkWidgetClassPrivate {
_unused: [u8; 0],
}
pub type GtkWidgetClassPrivate = _GtkWidgetClassPrivate;
#[doc = " GtkAllocation:\n @x: the X position of the widget’s area relative to its parents allocation.\n @y: the Y position of the widget’s area relative to its parents allocation.\n @width: the width of the widget’s allocated area.\n @height: the height of the widget’s allocated area.\n\n A #GtkAllocation-struct of a widget represents region\n which has been allocated to the widget by its parent. It is a subregion\n of its parents allocation. See\n [GtkWidget’s geometry management section][geometry-management] for\n more information."]
pub type GtkAllocation = GdkRectangle;
#[doc = " GtkCallback:\n @widget: the widget to operate on\n @data: (closure): user-supplied data\n\n The type of the callback functions used for e.g. iterating over\n the children of a container, see gtk_container_foreach()."]
pub type GtkCallback =
::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget, data: gpointer)>;
#[doc = " GtkTickCallback:\n @widget: the widget\n @frame_clock: the frame clock for the widget (same as calling gtk_widget_get_frame_clock())\n @user_data: user data passed to gtk_widget_add_tick_callback().\n\n Callback type for adding a function to update animations. See gtk_widget_add_tick_callback().\n\n Returns: %G_SOURCE_CONTINUE if the tick callback should continue to be called,\n %G_SOURCE_REMOVE if the tick callback should be removed.\n\n Since: 3.8"]
pub type GtkTickCallback = ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
frame_clock: *mut GdkFrameClock,
user_data: gpointer,
) -> gboolean,
>;
#[doc = " GtkRequisition:\n @width: the widget’s desired width\n @height: the widget’s desired height\n\n A #GtkRequisition-struct represents the desired size of a widget. See\n [GtkWidget’s geometry management section][geometry-management] for\n more information."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _GtkRequisition {
pub width: gint,
pub height: gint,
}
#[test]
fn bindgen_test_layout__GtkRequisition() {
const UNINIT: ::std::mem::MaybeUninit<_GtkRequisition> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkRequisition>(),
8usize,
concat!("Size of: ", stringify!(_GtkRequisition))
);
assert_eq!(
::std::mem::align_of::<_GtkRequisition>(),
4usize,
concat!("Alignment of ", stringify!(_GtkRequisition))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkRequisition),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_GtkRequisition),
"::",
stringify!(height)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkWidget {
pub parent_instance: GInitiallyUnowned,
pub priv_: *mut GtkWidgetPrivate,
}
#[test]
fn bindgen_test_layout__GtkWidget() {
const UNINIT: ::std::mem::MaybeUninit<_GtkWidget> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkWidget>(),
32usize,
concat!("Size of: ", stringify!(_GtkWidget))
);
assert_eq!(
::std::mem::align_of::<_GtkWidget>(),
8usize,
concat!("Alignment of ", stringify!(_GtkWidget))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidget),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidget),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkWidget {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GtkWidgetClass:\n @parent_class: The object class structure needs to be the first\n element in the widget class structure in order for the class mechanism\n to work correctly. This allows a GtkWidgetClass pointer to be cast to\n a GObjectClass pointer.\n @activate_signal: The signal to emit when a widget of this class is\n activated, gtk_widget_activate() handles the emission.\n Implementation of this signal is optional.\n @dispatch_child_properties_changed: Seldomly overidden.\n @destroy: Signals that all holders of a reference to the widget\n should release the reference that they hold.\n @show: Signal emitted when widget is shown\n @show_all: Recursively shows a widget, and any child widgets (if the widget is\n a container).\n @hide: Signal emitted when widget is hidden.\n @map: Signal emitted when widget is going to be mapped, that is\n when the widget is visible (which is controlled with\n gtk_widget_set_visible()) and all its parents up to the toplevel\n widget are also visible.\n @unmap: Signal emitted when widget is going to be unmapped, which\n means that either it or any of its parents up to the toplevel\n widget have been set as hidden.\n @realize: Signal emitted when widget is associated with a\n #GdkWindow, which means that gtk_widget_realize() has been called or\n the widget has been mapped (that is, it is going to be drawn).\n @unrealize: Signal emitted when the GdkWindow associated with\n widget is destroyed, which means that gtk_widget_unrealize() has\n been called or the widget has been unmapped (that is, it is going\n to be hidden).\n @size_allocate: Signal emitted to get the widget allocation.\n @state_changed: Signal emitted when the widget state\n changes. Deprecated: 3.0\n @state_flags_changed: Signal emitted when the widget state changes,\n see gtk_widget_get_state_flags().\n @parent_set: Signal emitted when a new parent has been set on a\n widget.\n @hierarchy_changed: Signal emitted when the anchored state of a\n widget changes.\n @style_set: Signal emitted when a new style has been set on a\n widget. Deprecated: 3.0\n @direction_changed: Signal emitted when the text direction of a\n widget changes.\n @grab_notify: Signal emitted when a widget becomes shadowed by a\n GTK+ grab (not a pointer or keyboard grab) on another widget, or\n when it becomes unshadowed due to a grab being removed.\n @child_notify: Signal emitted for each child property that has\n changed on an object.\n @draw: Signal emitted when a widget is supposed to render itself.\n @get_request_mode: This allows a widget to tell its parent container whether\n it prefers to be allocated in %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH or\n %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT mode.\n %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH means the widget prefers to have\n #GtkWidgetClass.get_preferred_width() called and then\n #GtkWidgetClass.get_preferred_height_for_width().\n %GTK_SIZE_REQUEST_CONSTANT_SIZE disables any height-for-width or\n width-for-height geometry management for a said widget and is the\n default return.\n It’s important to note (as described below) that any widget\n which trades height-for-width or width-for-height must respond properly\n to both of the virtual methods #GtkWidgetClass.get_preferred_height_for_width()\n and #GtkWidgetClass.get_preferred_width_for_height() since it might be\n queried in either #GtkSizeRequestMode by its parent container.\n @get_preferred_height: This is called by containers to obtain the minimum\n and natural height of a widget. A widget that does not actually trade\n any height for width or width for height only has to implement these\n two virtual methods (#GtkWidgetClass.get_preferred_width() and\n #GtkWidgetClass.get_preferred_height()).\n @get_preferred_width_for_height: This is analogous to\n #GtkWidgetClass.get_preferred_height_for_width() except that it\n operates in the oposite orientation. It’s rare that a widget actually\n does %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT requests but this can happen\n when, for example, a widget or container gets additional columns to\n compensate for a smaller allocated height.\n @get_preferred_width: This is called by containers to obtain the minimum\n and natural width of a widget. A widget will never be allocated a width\n less than its minimum and will only ever be allocated a width greater\n than the natural width once all of the said widget’s siblings have\n received their natural widths.\n Furthermore, a widget will only ever be allocated a width greater than\n its natural width if it was configured to receive extra expand space\n from its parent container.\n @get_preferred_height_for_width: This is similar to\n #GtkWidgetClass.get_preferred_height() except that it is passed a\n contextual width to request height for. By implementing this virtual\n method it is possible for a #GtkLabel to tell its parent how much height\n would be required if the label were to be allocated a said width.\n @mnemonic_activate: Activates the @widget if @group_cycling is\n %FALSE, and just grabs the focus if @group_cycling is %TRUE.\n @grab_focus: Causes @widget to have the keyboard focus for the\n #GtkWindow it’s inside.\n @focus:\n @move_focus: Signal emitted when a change of focus is requested\n @keynav_failed: Signal emitted if keyboard navigation fails.\n @event: The GTK+ main loop will emit three signals for each GDK\n event delivered to a widget: one generic ::event signal, another,\n more specific, signal that matches the type of event delivered\n (e.g. \"key-press-event\") and finally a generic \"event-after\"\n signal.\n @button_press_event: Signal will be emitted when a button\n (typically from a mouse) is pressed.\n @button_release_event: Signal will be emitted when a button\n (typically from a mouse) is released.\n @scroll_event: Signal emitted when a button in the 4 to 7 range is\n pressed.\n @motion_notify_event: Signal emitted when the pointer moves over\n the widget’s #GdkWindow.\n @delete_event: Signal emitted if a user requests that a toplevel\n window is closed.\n @destroy_event: Signal is emitted when a #GdkWindow is destroyed.\n @key_press_event: Signal emitted when a key is pressed.\n @key_release_event: Signal is emitted when a key is released.\n @enter_notify_event: Signal event will be emitted when the pointer\n enters the widget’s window.\n @leave_notify_event: Will be emitted when the pointer leaves the\n widget’s window.\n @configure_event: Signal will be emitted when the size, position or\n stacking of the widget’s window has changed.\n @focus_in_event: Signal emitted when the keyboard focus enters the\n widget’s window.\n @focus_out_event: Signal emitted when the keyboard focus leaves the\n widget’s window.\n @map_event: Signal emitted when the widget’s window is mapped.\n @unmap_event: Signal will be emitted when the widget’s window is\n unmapped.\n @property_notify_event: Signal will be emitted when a property on\n the widget’s window has been changed or deleted.\n @selection_clear_event: Signal will be emitted when the the\n widget’s window has lost ownership of a selection.\n @selection_request_event: Signal will be emitted when another\n client requests ownership of the selection owned by the widget's\n window.\n @selection_notify_event:\n @proximity_in_event:\n @proximity_out_event:\n @visibility_notify_event: Signal emitted when the widget’s window is\n obscured or unobscured.\n @window_state_event: Signal emitted when the state of the toplevel\n window associated to the widget changes.\n @damage_event: Signal emitted when a redirected window belonging to\n widget gets drawn into.\n @grab_broken_event: Signal emitted when a pointer or keyboard grab\n on a window belonging to widget gets broken.\n @selection_get:\n @selection_received:\n @drag_begin: Signal emitted on the drag source when a drag is\n started.\n @drag_end: Signal emitted on the drag source when a drag is\n finished.\n @drag_data_get: Signal emitted on the drag source when the drop\n site requests the data which is dragged.\n @drag_data_delete: Signal emitted on the drag source when a drag\n with the action %GDK_ACTION_MOVE is successfully completed.\n @drag_leave: Signal emitted on the drop site when the cursor leaves\n the widget.\n @drag_motion: signal emitted on the drop site when the user moves\n the cursor over the widget during a drag.\n @drag_drop: Signal emitted on the drop site when the user drops the\n data onto the widget.\n @drag_data_received: Signal emitted on the drop site when the\n dragged data has been received.\n @drag_failed: Signal emitted on the drag source when a drag has\n failed.\n @popup_menu: Signal emitted whenever a widget should pop up a\n context menu.\n @show_help:\n @get_accessible: Returns the accessible object that describes the\n widget to an assistive technology.\n @screen_changed: Signal emitted when the screen of a widget has\n changed.\n @can_activate_accel: Signal allows applications and derived widgets\n to override the default GtkWidget handling for determining whether\n an accelerator can be activated.\n @composited_changed: Signal emitted when the composited status of\n widgets screen changes. See gdk_screen_is_composited().\n @query_tooltip: Signal emitted when “has-tooltip” is %TRUE and the\n hover timeout has expired with the cursor hovering “above”\n widget; or emitted when widget got focus in keyboard mode.\n @compute_expand: Computes whether a container should give this\n widget extra space when possible.\n @adjust_size_request: Convert an initial size request from a widget's\n #GtkSizeRequestMode virtual method implementations into a size request to\n be used by parent containers in laying out the widget.\n adjust_size_request adjusts from a child widget's\n original request to what a parent container should\n use for layout. The @for_size argument will be -1 if the request should\n not be for a particular size in the opposing orientation, i.e. if the\n request is not height-for-width or width-for-height. If @for_size is\n greater than -1, it is the proposed allocation in the opposing\n orientation that we need the request for. Implementations of\n adjust_size_request should chain up to the default implementation,\n which applies #GtkWidget’s margin properties and imposes any values\n from gtk_widget_set_size_request(). Chaining up should be last,\n after your subclass adjusts the request, so\n #GtkWidget can apply constraints and add the margin properly.\n @adjust_size_allocation: Convert an initial size allocation assigned\n by a #GtkContainer using gtk_widget_size_allocate(), into an actual\n size allocation to be used by the widget. adjust_size_allocation\n adjusts to a child widget’s actual allocation\n from what a parent container computed for the\n child. The adjusted allocation must be entirely within the original\n allocation. In any custom implementation, chain up to the default\n #GtkWidget implementation of this method, which applies the margin\n and alignment properties of #GtkWidget. Chain up\n before performing your own adjustments so your\n own adjustments remove more allocation after the #GtkWidget base\n class has already removed margin and alignment. The natural size\n passed in should be adjusted in the same way as the allocated size,\n which allows adjustments to perform alignments or other changes\n based on natural size.\n @style_updated: Signal emitted when the GtkStyleContext of a widget\n is changed.\n @touch_event:\n @get_preferred_height_and_baseline_for_width:\n @adjust_baseline_request:\n @adjust_baseline_allocation:\n @queue_draw_region: Invalidates the area of widget defined by\n region by calling gdk_window_invalidate_region() on the widget's\n window and all its child windows."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkWidgetClass {
pub parent_class: GInitiallyUnownedClass,
pub activate_signal: guint,
pub dispatch_child_properties_changed: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, n_pspecs: guint, pspecs: *mut *mut GParamSpec),
>,
pub destroy: ::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget)>,
pub show: ::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget)>,
pub show_all: ::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget)>,
pub hide: ::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget)>,
pub map: ::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget)>,
pub unmap: ::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget)>,
pub realize: ::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget)>,
pub unrealize: ::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget)>,
pub size_allocate: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, allocation: *mut GtkAllocation),
>,
pub state_changed: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, previous_state: GtkStateType),
>,
pub state_flags_changed: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, previous_state_flags: GtkStateFlags),
>,
pub parent_set: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, previous_parent: *mut GtkWidget),
>,
pub hierarchy_changed: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, previous_toplevel: *mut GtkWidget),
>,
pub style_set: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, previous_style: *mut GtkStyle),
>,
pub direction_changed: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, previous_direction: GtkTextDirection),
>,
pub grab_notify:
::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget, was_grabbed: gboolean)>,
pub child_notify: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, child_property: *mut GParamSpec),
>,
pub draw: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, cr: *mut cairo_t) -> gboolean,
>,
pub get_request_mode:
::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget) -> GtkSizeRequestMode>,
pub get_preferred_height: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
minimum_height: *mut gint,
natural_height: *mut gint,
),
>,
pub get_preferred_width_for_height: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
height: gint,
minimum_width: *mut gint,
natural_width: *mut gint,
),
>,
pub get_preferred_width: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
minimum_width: *mut gint,
natural_width: *mut gint,
),
>,
pub get_preferred_height_for_width: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
width: gint,
minimum_height: *mut gint,
natural_height: *mut gint,
),
>,
pub mnemonic_activate: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, group_cycling: gboolean) -> gboolean,
>,
pub grab_focus: ::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget)>,
pub focus: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, direction: GtkDirectionType) -> gboolean,
>,
pub move_focus: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, direction: GtkDirectionType),
>,
pub keynav_failed: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, direction: GtkDirectionType) -> gboolean,
>,
pub event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEvent) -> gboolean,
>,
pub button_press_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventButton) -> gboolean,
>,
pub button_release_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventButton) -> gboolean,
>,
pub scroll_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventScroll) -> gboolean,
>,
pub motion_notify_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventMotion) -> gboolean,
>,
pub delete_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventAny) -> gboolean,
>,
pub destroy_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventAny) -> gboolean,
>,
pub key_press_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventKey) -> gboolean,
>,
pub key_release_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventKey) -> gboolean,
>,
pub enter_notify_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventCrossing) -> gboolean,
>,
pub leave_notify_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventCrossing) -> gboolean,
>,
pub configure_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventConfigure) -> gboolean,
>,
pub focus_in_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventFocus) -> gboolean,
>,
pub focus_out_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventFocus) -> gboolean,
>,
pub map_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventAny) -> gboolean,
>,
pub unmap_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventAny) -> gboolean,
>,
pub property_notify_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventProperty) -> gboolean,
>,
pub selection_clear_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventSelection) -> gboolean,
>,
pub selection_request_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventSelection) -> gboolean,
>,
pub selection_notify_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventSelection) -> gboolean,
>,
pub proximity_in_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventProximity) -> gboolean,
>,
pub proximity_out_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventProximity) -> gboolean,
>,
pub visibility_notify_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventVisibility) -> gboolean,
>,
pub window_state_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventWindowState) -> gboolean,
>,
pub damage_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventExpose) -> gboolean,
>,
pub grab_broken_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventGrabBroken) -> gboolean,
>,
pub selection_get: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
selection_data: *mut GtkSelectionData,
info: guint,
time_: guint,
),
>,
pub selection_received: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
selection_data: *mut GtkSelectionData,
time_: guint,
),
>,
pub drag_begin: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, context: *mut GdkDragContext),
>,
pub drag_end: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, context: *mut GdkDragContext),
>,
pub drag_data_get: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
context: *mut GdkDragContext,
selection_data: *mut GtkSelectionData,
info: guint,
time_: guint,
),
>,
pub drag_data_delete: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, context: *mut GdkDragContext),
>,
pub drag_leave: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, context: *mut GdkDragContext, time_: guint),
>,
pub drag_motion: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
context: *mut GdkDragContext,
x: gint,
y: gint,
time_: guint,
) -> gboolean,
>,
pub drag_drop: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
context: *mut GdkDragContext,
x: gint,
y: gint,
time_: guint,
) -> gboolean,
>,
pub drag_data_received: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
context: *mut GdkDragContext,
x: gint,
y: gint,
selection_data: *mut GtkSelectionData,
info: guint,
time_: guint,
),
>,
pub drag_failed: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
context: *mut GdkDragContext,
result: GtkDragResult,
) -> gboolean,
>,
pub popup_menu: ::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget) -> gboolean>,
pub show_help: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, help_type: GtkWidgetHelpType) -> gboolean,
>,
pub get_accessible:
::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget) -> *mut AtkObject>,
pub screen_changed: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, previous_screen: *mut GdkScreen),
>,
pub can_activate_accel: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, signal_id: guint) -> gboolean,
>,
pub composited_changed: ::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget)>,
pub query_tooltip: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
x: gint,
y: gint,
keyboard_tooltip: gboolean,
tooltip: *mut GtkTooltip,
) -> gboolean,
>,
pub compute_expand: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
hexpand_p: *mut gboolean,
vexpand_p: *mut gboolean,
),
>,
pub adjust_size_request: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
orientation: GtkOrientation,
minimum_size: *mut gint,
natural_size: *mut gint,
),
>,
pub adjust_size_allocation: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
orientation: GtkOrientation,
minimum_size: *mut gint,
natural_size: *mut gint,
allocated_pos: *mut gint,
allocated_size: *mut gint,
),
>,
pub style_updated: ::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget)>,
pub touch_event: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, event: *mut GdkEventTouch) -> gboolean,
>,
pub get_preferred_height_and_baseline_for_width: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
width: gint,
minimum_height: *mut gint,
natural_height: *mut gint,
minimum_baseline: *mut gint,
natural_baseline: *mut gint,
),
>,
pub adjust_baseline_request: ::std::option::Option<
unsafe extern "C" fn(
widget: *mut GtkWidget,
minimum_baseline: *mut gint,
natural_baseline: *mut gint,
),
>,
pub adjust_baseline_allocation:
::std::option::Option<unsafe extern "C" fn(widget: *mut GtkWidget, baseline: *mut gint)>,
pub queue_draw_region: ::std::option::Option<
unsafe extern "C" fn(widget: *mut GtkWidget, region: *const cairo_region_t),
>,
pub priv_: *mut GtkWidgetClassPrivate,
pub _gtk_reserved6: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved7: ::std::option::Option<unsafe extern "C" fn()>,
}
#[test]
fn bindgen_test_layout__GtkWidgetClass() {
const UNINIT: ::std::mem::MaybeUninit<_GtkWidgetClass> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkWidgetClass>(),
824usize,
concat!("Size of: ", stringify!(_GtkWidgetClass))
);
assert_eq!(
::std::mem::align_of::<_GtkWidgetClass>(),
8usize,
concat!("Alignment of ", stringify!(_GtkWidgetClass))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_class) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(parent_class)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).activate_signal) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(activate_signal)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).dispatch_child_properties_changed) as usize - ptr as usize
},
144usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(dispatch_child_properties_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).destroy) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(destroy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(show)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_all) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(show_all)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hide) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(hide)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).map) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(map)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).unmap) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(unmap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).realize) as usize - ptr as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(realize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).unrealize) as usize - ptr as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(unrealize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size_allocate) as usize - ptr as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(size_allocate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state_changed) as usize - ptr as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(state_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state_flags_changed) as usize - ptr as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(state_flags_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_set) as usize - ptr as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(parent_set)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hierarchy_changed) as usize - ptr as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(hierarchy_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).style_set) as usize - ptr as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(style_set)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).direction_changed) as usize - ptr as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(direction_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).grab_notify) as usize - ptr as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(grab_notify)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).child_notify) as usize - ptr as usize },
280usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(child_notify)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).draw) as usize - ptr as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(draw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_request_mode) as usize - ptr as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(get_request_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_preferred_height) as usize - ptr as usize },
304usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(get_preferred_height)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).get_preferred_width_for_height) as usize - ptr as usize
},
312usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(get_preferred_width_for_height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_preferred_width) as usize - ptr as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(get_preferred_width)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).get_preferred_height_for_width) as usize - ptr as usize
},
328usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(get_preferred_height_for_width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mnemonic_activate) as usize - ptr as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(mnemonic_activate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).grab_focus) as usize - ptr as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(grab_focus)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).focus) as usize - ptr as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(focus)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).move_focus) as usize - ptr as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(move_focus)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).keynav_failed) as usize - ptr as usize },
368usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(keynav_failed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).event) as usize - ptr as usize },
376usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).button_press_event) as usize - ptr as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(button_press_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).button_release_event) as usize - ptr as usize },
392usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(button_release_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).scroll_event) as usize - ptr as usize },
400usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(scroll_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).motion_notify_event) as usize - ptr as usize },
408usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(motion_notify_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).delete_event) as usize - ptr as usize },
416usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(delete_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).destroy_event) as usize - ptr as usize },
424usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(destroy_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).key_press_event) as usize - ptr as usize },
432usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(key_press_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).key_release_event) as usize - ptr as usize },
440usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(key_release_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).enter_notify_event) as usize - ptr as usize },
448usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(enter_notify_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).leave_notify_event) as usize - ptr as usize },
456usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(leave_notify_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).configure_event) as usize - ptr as usize },
464usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(configure_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).focus_in_event) as usize - ptr as usize },
472usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(focus_in_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).focus_out_event) as usize - ptr as usize },
480usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(focus_out_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).map_event) as usize - ptr as usize },
488usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(map_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).unmap_event) as usize - ptr as usize },
496usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(unmap_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).property_notify_event) as usize - ptr as usize },
504usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(property_notify_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).selection_clear_event) as usize - ptr as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(selection_clear_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).selection_request_event) as usize - ptr as usize },
520usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(selection_request_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).selection_notify_event) as usize - ptr as usize },
528usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(selection_notify_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).proximity_in_event) as usize - ptr as usize },
536usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(proximity_in_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).proximity_out_event) as usize - ptr as usize },
544usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(proximity_out_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).visibility_notify_event) as usize - ptr as usize },
552usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(visibility_notify_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window_state_event) as usize - ptr as usize },
560usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(window_state_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).damage_event) as usize - ptr as usize },
568usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(damage_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).grab_broken_event) as usize - ptr as usize },
576usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(grab_broken_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).selection_get) as usize - ptr as usize },
584usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(selection_get)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).selection_received) as usize - ptr as usize },
592usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(selection_received)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drag_begin) as usize - ptr as usize },
600usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(drag_begin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drag_end) as usize - ptr as usize },
608usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(drag_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drag_data_get) as usize - ptr as usize },
616usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(drag_data_get)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drag_data_delete) as usize - ptr as usize },
624usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(drag_data_delete)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drag_leave) as usize - ptr as usize },
632usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(drag_leave)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drag_motion) as usize - ptr as usize },
640usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(drag_motion)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drag_drop) as usize - ptr as usize },
648usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(drag_drop)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drag_data_received) as usize - ptr as usize },
656usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(drag_data_received)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drag_failed) as usize - ptr as usize },
664usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(drag_failed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).popup_menu) as usize - ptr as usize },
672usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(popup_menu)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_help) as usize - ptr as usize },
680usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(show_help)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_accessible) as usize - ptr as usize },
688usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(get_accessible)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).screen_changed) as usize - ptr as usize },
696usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(screen_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).can_activate_accel) as usize - ptr as usize },
704usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(can_activate_accel)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).composited_changed) as usize - ptr as usize },
712usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(composited_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).query_tooltip) as usize - ptr as usize },
720usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(query_tooltip)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).compute_expand) as usize - ptr as usize },
728usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(compute_expand)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).adjust_size_request) as usize - ptr as usize },
736usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(adjust_size_request)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).adjust_size_allocation) as usize - ptr as usize },
744usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(adjust_size_allocation)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).style_updated) as usize - ptr as usize },
752usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(style_updated)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).touch_event) as usize - ptr as usize },
760usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(touch_event)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).get_preferred_height_and_baseline_for_width) as usize
- ptr as usize
},
768usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(get_preferred_height_and_baseline_for_width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).adjust_baseline_request) as usize - ptr as usize },
776usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(adjust_baseline_request)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).adjust_baseline_allocation) as usize - ptr as usize },
784usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(adjust_baseline_allocation)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).queue_draw_region) as usize - ptr as usize },
792usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(queue_draw_region)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
800usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(priv_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved6) as usize - ptr as usize },
808usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(_gtk_reserved6)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved7) as usize - ptr as usize },
816usize,
concat!(
"Offset of field: ",
stringify!(_GtkWidgetClass),
"::",
stringify!(_gtk_reserved7)
)
);
}
impl Default for _GtkWidgetClass {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_widget_get_type() -> GType;
}
extern "C" {
pub fn gtk_widget_new(type_: GType, first_property_name: *const gchar, ...) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_widget_destroy(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_destroyed(widget: *mut GtkWidget, widget_pointer: *mut *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_unparent(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_show(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_hide(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_show_now(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_show_all(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_set_no_show_all(widget: *mut GtkWidget, no_show_all: gboolean);
}
extern "C" {
pub fn gtk_widget_get_no_show_all(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_map(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_unmap(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_realize(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_unrealize(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_draw(widget: *mut GtkWidget, cr: *mut cairo_t);
}
extern "C" {
pub fn gtk_widget_queue_draw(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_queue_draw_area(
widget: *mut GtkWidget,
x: gint,
y: gint,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_widget_queue_draw_region(widget: *mut GtkWidget, region: *const cairo_region_t);
}
extern "C" {
pub fn gtk_widget_queue_resize(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_queue_resize_no_redraw(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_get_frame_clock(widget: *mut GtkWidget) -> *mut GdkFrameClock;
}
extern "C" {
pub fn gtk_widget_size_request(widget: *mut GtkWidget, requisition: *mut GtkRequisition);
}
extern "C" {
pub fn gtk_widget_size_allocate(widget: *mut GtkWidget, allocation: *mut GtkAllocation);
}
extern "C" {
pub fn gtk_widget_size_allocate_with_baseline(
widget: *mut GtkWidget,
allocation: *mut GtkAllocation,
baseline: gint,
);
}
extern "C" {
pub fn gtk_widget_get_request_mode(widget: *mut GtkWidget) -> GtkSizeRequestMode;
}
extern "C" {
pub fn gtk_widget_get_preferred_width(
widget: *mut GtkWidget,
minimum_width: *mut gint,
natural_width: *mut gint,
);
}
extern "C" {
pub fn gtk_widget_get_preferred_height_for_width(
widget: *mut GtkWidget,
width: gint,
minimum_height: *mut gint,
natural_height: *mut gint,
);
}
extern "C" {
pub fn gtk_widget_get_preferred_height(
widget: *mut GtkWidget,
minimum_height: *mut gint,
natural_height: *mut gint,
);
}
extern "C" {
pub fn gtk_widget_get_preferred_width_for_height(
widget: *mut GtkWidget,
height: gint,
minimum_width: *mut gint,
natural_width: *mut gint,
);
}
extern "C" {
pub fn gtk_widget_get_preferred_height_and_baseline_for_width(
widget: *mut GtkWidget,
width: gint,
minimum_height: *mut gint,
natural_height: *mut gint,
minimum_baseline: *mut gint,
natural_baseline: *mut gint,
);
}
extern "C" {
pub fn gtk_widget_get_preferred_size(
widget: *mut GtkWidget,
minimum_size: *mut GtkRequisition,
natural_size: *mut GtkRequisition,
);
}
extern "C" {
pub fn gtk_widget_get_child_requisition(
widget: *mut GtkWidget,
requisition: *mut GtkRequisition,
);
}
extern "C" {
pub fn gtk_widget_add_accelerator(
widget: *mut GtkWidget,
accel_signal: *const gchar,
accel_group: *mut GtkAccelGroup,
accel_key: guint,
accel_mods: GdkModifierType,
accel_flags: GtkAccelFlags,
);
}
extern "C" {
pub fn gtk_widget_remove_accelerator(
widget: *mut GtkWidget,
accel_group: *mut GtkAccelGroup,
accel_key: guint,
accel_mods: GdkModifierType,
) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_accel_path(
widget: *mut GtkWidget,
accel_path: *const gchar,
accel_group: *mut GtkAccelGroup,
);
}
extern "C" {
pub fn gtk_widget_list_accel_closures(widget: *mut GtkWidget) -> *mut GList;
}
extern "C" {
pub fn gtk_widget_can_activate_accel(widget: *mut GtkWidget, signal_id: guint) -> gboolean;
}
extern "C" {
pub fn gtk_widget_mnemonic_activate(
widget: *mut GtkWidget,
group_cycling: gboolean,
) -> gboolean;
}
extern "C" {
pub fn gtk_widget_event(widget: *mut GtkWidget, event: *mut GdkEvent) -> gboolean;
}
extern "C" {
pub fn gtk_widget_send_expose(widget: *mut GtkWidget, event: *mut GdkEvent) -> gint;
}
extern "C" {
pub fn gtk_widget_send_focus_change(widget: *mut GtkWidget, event: *mut GdkEvent) -> gboolean;
}
extern "C" {
pub fn gtk_widget_activate(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_reparent(widget: *mut GtkWidget, new_parent: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_intersect(
widget: *mut GtkWidget,
area: *const GdkRectangle,
intersection: *mut GdkRectangle,
) -> gboolean;
}
extern "C" {
pub fn gtk_widget_region_intersect(
widget: *mut GtkWidget,
region: *const cairo_region_t,
) -> *mut cairo_region_t;
}
extern "C" {
pub fn gtk_widget_freeze_child_notify(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_child_notify(widget: *mut GtkWidget, child_property: *const gchar);
}
extern "C" {
pub fn gtk_widget_thaw_child_notify(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_set_can_focus(widget: *mut GtkWidget, can_focus: gboolean);
}
extern "C" {
pub fn gtk_widget_get_can_focus(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_has_focus(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_is_focus(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_has_visible_focus(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_grab_focus(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_set_can_default(widget: *mut GtkWidget, can_default: gboolean);
}
extern "C" {
pub fn gtk_widget_get_can_default(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_has_default(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_grab_default(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_set_receives_default(widget: *mut GtkWidget, receives_default: gboolean);
}
extern "C" {
pub fn gtk_widget_get_receives_default(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_has_grab(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_device_is_shadowed(
widget: *mut GtkWidget,
device: *mut GdkDevice,
) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_name(widget: *mut GtkWidget, name: *const gchar);
}
extern "C" {
pub fn gtk_widget_get_name(widget: *mut GtkWidget) -> *const gchar;
}
extern "C" {
pub fn gtk_widget_set_state(widget: *mut GtkWidget, state: GtkStateType);
}
extern "C" {
pub fn gtk_widget_get_state(widget: *mut GtkWidget) -> GtkStateType;
}
extern "C" {
pub fn gtk_widget_set_state_flags(
widget: *mut GtkWidget,
flags: GtkStateFlags,
clear: gboolean,
);
}
extern "C" {
pub fn gtk_widget_unset_state_flags(widget: *mut GtkWidget, flags: GtkStateFlags);
}
extern "C" {
pub fn gtk_widget_get_state_flags(widget: *mut GtkWidget) -> GtkStateFlags;
}
extern "C" {
pub fn gtk_widget_set_sensitive(widget: *mut GtkWidget, sensitive: gboolean);
}
extern "C" {
pub fn gtk_widget_get_sensitive(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_is_sensitive(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_visible(widget: *mut GtkWidget, visible: gboolean);
}
extern "C" {
pub fn gtk_widget_get_visible(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_is_visible(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_has_window(widget: *mut GtkWidget, has_window: gboolean);
}
extern "C" {
pub fn gtk_widget_get_has_window(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_is_toplevel(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_is_drawable(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_realized(widget: *mut GtkWidget, realized: gboolean);
}
extern "C" {
pub fn gtk_widget_get_realized(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_mapped(widget: *mut GtkWidget, mapped: gboolean);
}
extern "C" {
pub fn gtk_widget_get_mapped(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_app_paintable(widget: *mut GtkWidget, app_paintable: gboolean);
}
extern "C" {
pub fn gtk_widget_get_app_paintable(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_double_buffered(widget: *mut GtkWidget, double_buffered: gboolean);
}
extern "C" {
pub fn gtk_widget_get_double_buffered(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_redraw_on_allocate(widget: *mut GtkWidget, redraw_on_allocate: gboolean);
}
extern "C" {
pub fn gtk_widget_set_parent(widget: *mut GtkWidget, parent: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_get_parent(widget: *mut GtkWidget) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_widget_set_parent_window(widget: *mut GtkWidget, parent_window: *mut GdkWindow);
}
extern "C" {
pub fn gtk_widget_get_parent_window(widget: *mut GtkWidget) -> *mut GdkWindow;
}
extern "C" {
pub fn gtk_widget_set_child_visible(widget: *mut GtkWidget, is_visible: gboolean);
}
extern "C" {
pub fn gtk_widget_get_child_visible(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_window(widget: *mut GtkWidget, window: *mut GdkWindow);
}
extern "C" {
pub fn gtk_widget_get_window(widget: *mut GtkWidget) -> *mut GdkWindow;
}
extern "C" {
pub fn gtk_widget_register_window(widget: *mut GtkWidget, window: *mut GdkWindow);
}
extern "C" {
pub fn gtk_widget_unregister_window(widget: *mut GtkWidget, window: *mut GdkWindow);
}
extern "C" {
pub fn gtk_widget_get_allocated_width(widget: *mut GtkWidget) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn gtk_widget_get_allocated_height(widget: *mut GtkWidget) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn gtk_widget_get_allocated_baseline(widget: *mut GtkWidget) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn gtk_widget_get_allocation(widget: *mut GtkWidget, allocation: *mut GtkAllocation);
}
extern "C" {
pub fn gtk_widget_set_allocation(widget: *mut GtkWidget, allocation: *const GtkAllocation);
}
extern "C" {
pub fn gtk_widget_set_clip(widget: *mut GtkWidget, clip: *const GtkAllocation);
}
extern "C" {
pub fn gtk_widget_get_clip(widget: *mut GtkWidget, clip: *mut GtkAllocation);
}
extern "C" {
pub fn gtk_widget_get_requisition(widget: *mut GtkWidget, requisition: *mut GtkRequisition);
}
extern "C" {
pub fn gtk_widget_child_focus(widget: *mut GtkWidget, direction: GtkDirectionType) -> gboolean;
}
extern "C" {
pub fn gtk_widget_keynav_failed(
widget: *mut GtkWidget,
direction: GtkDirectionType,
) -> gboolean;
}
extern "C" {
pub fn gtk_widget_error_bell(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_set_size_request(widget: *mut GtkWidget, width: gint, height: gint);
}
extern "C" {
pub fn gtk_widget_get_size_request(widget: *mut GtkWidget, width: *mut gint, height: *mut gint);
}
extern "C" {
pub fn gtk_widget_set_events(widget: *mut GtkWidget, events: gint);
}
extern "C" {
pub fn gtk_widget_add_events(widget: *mut GtkWidget, events: gint);
}
extern "C" {
pub fn gtk_widget_set_device_events(
widget: *mut GtkWidget,
device: *mut GdkDevice,
events: GdkEventMask,
);
}
extern "C" {
pub fn gtk_widget_add_device_events(
widget: *mut GtkWidget,
device: *mut GdkDevice,
events: GdkEventMask,
);
}
extern "C" {
pub fn gtk_widget_set_opacity(widget: *mut GtkWidget, opacity: f64);
}
extern "C" {
pub fn gtk_widget_get_opacity(widget: *mut GtkWidget) -> f64;
}
extern "C" {
pub fn gtk_widget_set_device_enabled(
widget: *mut GtkWidget,
device: *mut GdkDevice,
enabled: gboolean,
);
}
extern "C" {
pub fn gtk_widget_get_device_enabled(
widget: *mut GtkWidget,
device: *mut GdkDevice,
) -> gboolean;
}
extern "C" {
pub fn gtk_widget_get_toplevel(widget: *mut GtkWidget) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_widget_get_ancestor(widget: *mut GtkWidget, widget_type: GType) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_widget_get_visual(widget: *mut GtkWidget) -> *mut GdkVisual;
}
extern "C" {
pub fn gtk_widget_set_visual(widget: *mut GtkWidget, visual: *mut GdkVisual);
}
extern "C" {
pub fn gtk_widget_get_screen(widget: *mut GtkWidget) -> *mut GdkScreen;
}
extern "C" {
pub fn gtk_widget_has_screen(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_get_scale_factor(widget: *mut GtkWidget) -> gint;
}
extern "C" {
pub fn gtk_widget_get_display(widget: *mut GtkWidget) -> *mut GdkDisplay;
}
extern "C" {
pub fn gtk_widget_get_root_window(widget: *mut GtkWidget) -> *mut GdkWindow;
}
extern "C" {
pub fn gtk_widget_get_settings(widget: *mut GtkWidget) -> *mut GtkSettings;
}
extern "C" {
pub fn gtk_widget_get_clipboard(
widget: *mut GtkWidget,
selection: GdkAtom,
) -> *mut GtkClipboard;
}
extern "C" {
pub fn gtk_widget_get_hexpand(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_hexpand(widget: *mut GtkWidget, expand: gboolean);
}
extern "C" {
pub fn gtk_widget_get_hexpand_set(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_hexpand_set(widget: *mut GtkWidget, set: gboolean);
}
extern "C" {
pub fn gtk_widget_get_vexpand(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_vexpand(widget: *mut GtkWidget, expand: gboolean);
}
extern "C" {
pub fn gtk_widget_get_vexpand_set(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_vexpand_set(widget: *mut GtkWidget, set: gboolean);
}
extern "C" {
pub fn gtk_widget_queue_compute_expand(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_compute_expand(
widget: *mut GtkWidget,
orientation: GtkOrientation,
) -> gboolean;
}
extern "C" {
pub fn gtk_widget_get_support_multidevice(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_support_multidevice(
widget: *mut GtkWidget,
support_multidevice: gboolean,
);
}
extern "C" {
pub fn gtk_widget_class_set_accessible_type(widget_class: *mut GtkWidgetClass, type_: GType);
}
extern "C" {
pub fn gtk_widget_class_set_accessible_role(widget_class: *mut GtkWidgetClass, role: AtkRole);
}
extern "C" {
pub fn gtk_widget_get_accessible(widget: *mut GtkWidget) -> *mut AtkObject;
}
extern "C" {
pub fn gtk_widget_get_halign(widget: *mut GtkWidget) -> GtkAlign;
}
extern "C" {
pub fn gtk_widget_set_halign(widget: *mut GtkWidget, align: GtkAlign);
}
extern "C" {
pub fn gtk_widget_get_valign(widget: *mut GtkWidget) -> GtkAlign;
}
extern "C" {
pub fn gtk_widget_get_valign_with_baseline(widget: *mut GtkWidget) -> GtkAlign;
}
extern "C" {
pub fn gtk_widget_set_valign(widget: *mut GtkWidget, align: GtkAlign);
}
extern "C" {
pub fn gtk_widget_get_margin_left(widget: *mut GtkWidget) -> gint;
}
extern "C" {
pub fn gtk_widget_set_margin_left(widget: *mut GtkWidget, margin: gint);
}
extern "C" {
pub fn gtk_widget_get_margin_right(widget: *mut GtkWidget) -> gint;
}
extern "C" {
pub fn gtk_widget_set_margin_right(widget: *mut GtkWidget, margin: gint);
}
extern "C" {
pub fn gtk_widget_get_margin_start(widget: *mut GtkWidget) -> gint;
}
extern "C" {
pub fn gtk_widget_set_margin_start(widget: *mut GtkWidget, margin: gint);
}
extern "C" {
pub fn gtk_widget_get_margin_end(widget: *mut GtkWidget) -> gint;
}
extern "C" {
pub fn gtk_widget_set_margin_end(widget: *mut GtkWidget, margin: gint);
}
extern "C" {
pub fn gtk_widget_get_margin_top(widget: *mut GtkWidget) -> gint;
}
extern "C" {
pub fn gtk_widget_set_margin_top(widget: *mut GtkWidget, margin: gint);
}
extern "C" {
pub fn gtk_widget_get_margin_bottom(widget: *mut GtkWidget) -> gint;
}
extern "C" {
pub fn gtk_widget_set_margin_bottom(widget: *mut GtkWidget, margin: gint);
}
extern "C" {
pub fn gtk_widget_get_events(widget: *mut GtkWidget) -> gint;
}
extern "C" {
pub fn gtk_widget_get_device_events(
widget: *mut GtkWidget,
device: *mut GdkDevice,
) -> GdkEventMask;
}
extern "C" {
pub fn gtk_widget_get_pointer(widget: *mut GtkWidget, x: *mut gint, y: *mut gint);
}
extern "C" {
pub fn gtk_widget_is_ancestor(widget: *mut GtkWidget, ancestor: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_translate_coordinates(
src_widget: *mut GtkWidget,
dest_widget: *mut GtkWidget,
src_x: gint,
src_y: gint,
dest_x: *mut gint,
dest_y: *mut gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_widget_hide_on_delete(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_override_color(
widget: *mut GtkWidget,
state: GtkStateFlags,
color: *const GdkRGBA,
);
}
extern "C" {
pub fn gtk_widget_override_background_color(
widget: *mut GtkWidget,
state: GtkStateFlags,
color: *const GdkRGBA,
);
}
extern "C" {
pub fn gtk_widget_override_font(widget: *mut GtkWidget, font_desc: *const PangoFontDescription);
}
extern "C" {
pub fn gtk_widget_override_symbolic_color(
widget: *mut GtkWidget,
name: *const gchar,
color: *const GdkRGBA,
);
}
extern "C" {
pub fn gtk_widget_override_cursor(
widget: *mut GtkWidget,
cursor: *const GdkRGBA,
secondary_cursor: *const GdkRGBA,
);
}
extern "C" {
pub fn gtk_widget_reset_style(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_create_pango_context(widget: *mut GtkWidget) -> *mut PangoContext;
}
extern "C" {
pub fn gtk_widget_get_pango_context(widget: *mut GtkWidget) -> *mut PangoContext;
}
extern "C" {
pub fn gtk_widget_create_pango_layout(
widget: *mut GtkWidget,
text: *const gchar,
) -> *mut PangoLayout;
}
extern "C" {
pub fn gtk_widget_render_icon_pixbuf(
widget: *mut GtkWidget,
stock_id: *const gchar,
size: GtkIconSize,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_widget_set_composite_name(widget: *mut GtkWidget, name: *const gchar);
}
extern "C" {
pub fn gtk_widget_get_composite_name(widget: *mut GtkWidget) -> *mut gchar;
}
extern "C" {
pub fn gtk_widget_push_composite_child();
}
extern "C" {
pub fn gtk_widget_pop_composite_child();
}
extern "C" {
pub fn gtk_widget_class_install_style_property(
klass: *mut GtkWidgetClass,
pspec: *mut GParamSpec,
);
}
extern "C" {
pub fn gtk_widget_class_install_style_property_parser(
klass: *mut GtkWidgetClass,
pspec: *mut GParamSpec,
parser: GtkRcPropertyParser,
);
}
extern "C" {
pub fn gtk_widget_class_find_style_property(
klass: *mut GtkWidgetClass,
property_name: *const gchar,
) -> *mut GParamSpec;
}
extern "C" {
pub fn gtk_widget_class_list_style_properties(
klass: *mut GtkWidgetClass,
n_properties: *mut guint,
) -> *mut *mut GParamSpec;
}
extern "C" {
pub fn gtk_widget_style_get_property(
widget: *mut GtkWidget,
property_name: *const gchar,
value: *mut GValue,
);
}
extern "C" {
pub fn gtk_widget_style_get(widget: *mut GtkWidget, first_property_name: *const gchar, ...);
}
extern "C" {
pub fn gtk_widget_set_direction(widget: *mut GtkWidget, dir: GtkTextDirection);
}
extern "C" {
pub fn gtk_widget_get_direction(widget: *mut GtkWidget) -> GtkTextDirection;
}
extern "C" {
pub fn gtk_widget_set_default_direction(dir: GtkTextDirection);
}
extern "C" {
pub fn gtk_widget_get_default_direction() -> GtkTextDirection;
}
extern "C" {
pub fn gtk_widget_is_composited(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_shape_combine_region(widget: *mut GtkWidget, region: *mut cairo_region_t);
}
extern "C" {
pub fn gtk_widget_input_shape_combine_region(
widget: *mut GtkWidget,
region: *mut cairo_region_t,
);
}
extern "C" {
pub fn gtk_widget_list_mnemonic_labels(widget: *mut GtkWidget) -> *mut GList;
}
extern "C" {
pub fn gtk_widget_add_mnemonic_label(widget: *mut GtkWidget, label: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_remove_mnemonic_label(widget: *mut GtkWidget, label: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_set_tooltip_window(widget: *mut GtkWidget, custom_window: *mut GtkWindow);
}
extern "C" {
pub fn gtk_widget_get_tooltip_window(widget: *mut GtkWidget) -> *mut GtkWindow;
}
extern "C" {
pub fn gtk_widget_trigger_tooltip_query(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_set_tooltip_text(widget: *mut GtkWidget, text: *const gchar);
}
extern "C" {
pub fn gtk_widget_get_tooltip_text(widget: *mut GtkWidget) -> *mut gchar;
}
extern "C" {
pub fn gtk_widget_set_tooltip_markup(widget: *mut GtkWidget, markup: *const gchar);
}
extern "C" {
pub fn gtk_widget_get_tooltip_markup(widget: *mut GtkWidget) -> *mut gchar;
}
extern "C" {
pub fn gtk_widget_set_has_tooltip(widget: *mut GtkWidget, has_tooltip: gboolean);
}
extern "C" {
pub fn gtk_widget_get_has_tooltip(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_cairo_should_draw_window(cr: *mut cairo_t, window: *mut GdkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_cairo_transform_to_window(
cr: *mut cairo_t,
widget: *mut GtkWidget,
window: *mut GdkWindow,
);
}
extern "C" {
pub fn gtk_requisition_get_type() -> GType;
}
extern "C" {
pub fn gtk_requisition_new() -> *mut GtkRequisition;
}
extern "C" {
pub fn gtk_requisition_copy(requisition: *const GtkRequisition) -> *mut GtkRequisition;
}
extern "C" {
pub fn gtk_requisition_free(requisition: *mut GtkRequisition);
}
extern "C" {
pub fn gtk_widget_in_destruction(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_get_style_context(widget: *mut GtkWidget) -> *mut GtkStyleContext;
}
extern "C" {
pub fn gtk_widget_get_path(widget: *mut GtkWidget) -> *mut GtkWidgetPath;
}
extern "C" {
pub fn gtk_widget_get_modifier_mask(
widget: *mut GtkWidget,
intent: GdkModifierIntent,
) -> GdkModifierType;
}
extern "C" {
pub fn gtk_widget_insert_action_group(
widget: *mut GtkWidget,
name: *const gchar,
group: *mut GActionGroup,
);
}
extern "C" {
pub fn gtk_widget_add_tick_callback(
widget: *mut GtkWidget,
callback: GtkTickCallback,
user_data: gpointer,
notify: GDestroyNotify,
) -> guint;
}
extern "C" {
pub fn gtk_widget_remove_tick_callback(widget: *mut GtkWidget, id: guint);
}
extern "C" {
pub fn gtk_widget_init_template(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_get_template_child(
widget: *mut GtkWidget,
widget_type: GType,
name: *const gchar,
) -> *mut GObject;
}
extern "C" {
pub fn gtk_widget_class_set_template(
widget_class: *mut GtkWidgetClass,
template_bytes: *mut GBytes,
);
}
extern "C" {
pub fn gtk_widget_class_set_template_from_resource(
widget_class: *mut GtkWidgetClass,
resource_name: *const gchar,
);
}
extern "C" {
pub fn gtk_widget_class_bind_template_callback_full(
widget_class: *mut GtkWidgetClass,
callback_name: *const gchar,
callback_symbol: GCallback,
);
}
extern "C" {
pub fn gtk_widget_class_set_connect_func(
widget_class: *mut GtkWidgetClass,
connect_func: GtkBuilderConnectFunc,
connect_data: gpointer,
connect_data_destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_widget_class_bind_template_child_full(
widget_class: *mut GtkWidgetClass,
name: *const gchar,
internal_child: gboolean,
struct_offset: gssize,
);
}
pub type GtkApplication = _GtkApplication;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkApplicationPrivate {
_unused: [u8; 0],
}
pub type GtkApplicationPrivate = _GtkApplicationPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkApplication {
pub parent: GApplication,
pub priv_: *mut GtkApplicationPrivate,
}
#[test]
fn bindgen_test_layout__GtkApplication() {
const UNINIT: ::std::mem::MaybeUninit<_GtkApplication> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkApplication>(),
40usize,
concat!("Size of: ", stringify!(_GtkApplication))
);
assert_eq!(
::std::mem::align_of::<_GtkApplication>(),
8usize,
concat!("Alignment of ", stringify!(_GtkApplication))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkApplication),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkApplication),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkApplication {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_application_get_type() -> GType;
}
extern "C" {
pub fn gtk_application_new(
application_id: *const gchar,
flags: GApplicationFlags,
) -> *mut GtkApplication;
}
extern "C" {
pub fn gtk_application_add_window(application: *mut GtkApplication, window: *mut GtkWindow);
}
extern "C" {
pub fn gtk_application_remove_window(application: *mut GtkApplication, window: *mut GtkWindow);
}
extern "C" {
pub fn gtk_application_get_windows(application: *mut GtkApplication) -> *mut GList;
}
extern "C" {
pub fn gtk_application_get_app_menu(application: *mut GtkApplication) -> *mut GMenuModel;
}
extern "C" {
pub fn gtk_application_set_app_menu(
application: *mut GtkApplication,
app_menu: *mut GMenuModel,
);
}
extern "C" {
pub fn gtk_application_get_menubar(application: *mut GtkApplication) -> *mut GMenuModel;
}
extern "C" {
pub fn gtk_application_set_menubar(application: *mut GtkApplication, menubar: *mut GMenuModel);
}
extern "C" {
pub fn gtk_application_add_accelerator(
application: *mut GtkApplication,
accelerator: *const gchar,
action_name: *const gchar,
parameter: *mut GVariant,
);
}
extern "C" {
pub fn gtk_application_remove_accelerator(
application: *mut GtkApplication,
action_name: *const gchar,
parameter: *mut GVariant,
);
}
pub const GtkApplicationInhibitFlags_GTK_APPLICATION_INHIBIT_LOGOUT: GtkApplicationInhibitFlags = 1;
pub const GtkApplicationInhibitFlags_GTK_APPLICATION_INHIBIT_SWITCH: GtkApplicationInhibitFlags = 2;
pub const GtkApplicationInhibitFlags_GTK_APPLICATION_INHIBIT_SUSPEND: GtkApplicationInhibitFlags =
4;
pub const GtkApplicationInhibitFlags_GTK_APPLICATION_INHIBIT_IDLE: GtkApplicationInhibitFlags = 8;
pub type GtkApplicationInhibitFlags = ::std::os::raw::c_uint;
extern "C" {
pub fn gtk_application_inhibit(
application: *mut GtkApplication,
window: *mut GtkWindow,
flags: GtkApplicationInhibitFlags,
reason: *const gchar,
) -> guint;
}
extern "C" {
pub fn gtk_application_uninhibit(application: *mut GtkApplication, cookie: guint);
}
extern "C" {
pub fn gtk_application_is_inhibited(
application: *mut GtkApplication,
flags: GtkApplicationInhibitFlags,
) -> gboolean;
}
extern "C" {
pub fn gtk_application_get_window_by_id(
application: *mut GtkApplication,
id: guint,
) -> *mut GtkWindow;
}
extern "C" {
pub fn gtk_application_get_active_window(application: *mut GtkApplication) -> *mut GtkWindow;
}
extern "C" {
pub fn gtk_application_list_action_descriptions(
application: *mut GtkApplication,
) -> *mut *mut gchar;
}
extern "C" {
pub fn gtk_application_get_accels_for_action(
application: *mut GtkApplication,
detailed_action_name: *const gchar,
) -> *mut *mut gchar;
}
extern "C" {
pub fn gtk_application_get_actions_for_accel(
application: *mut GtkApplication,
accel: *const gchar,
) -> *mut *mut gchar;
}
extern "C" {
pub fn gtk_application_set_accels_for_action(
application: *mut GtkApplication,
detailed_action_name: *const gchar,
accels: *const *const gchar,
);
}
extern "C" {
pub fn gtk_application_prefers_app_menu(application: *mut GtkApplication) -> gboolean;
}
extern "C" {
pub fn gtk_application_get_menu_by_id(
application: *mut GtkApplication,
id: *const gchar,
) -> *mut GMenu;
}
pub type GtkContainer = _GtkContainer;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkContainerPrivate {
_unused: [u8; 0],
}
pub type GtkContainerPrivate = _GtkContainerPrivate;
#[doc = " GtkContainerClass:\n @parent_class: The parent class.\n @add: Signal emitted when a widget is added to container.\n @remove: Signal emitted when a widget is removed from container.\n @check_resize: Signal emitted when a size recalculation is needed.\n @forall: Invokes callback on each child of container.\n @set_focus_child: Sets the focused child of container.\n @child_type: Returns the type of the children supported by the container.\n @composite_name: Gets a widget’s composite name. Deprecated: 3.10.\n @set_child_property: Set a property on a child of container.\n @get_child_property: Get a property from a child of container.\n @get_path_for_child: Get path representing entire widget hierarchy\n from the toplevel down to and including @child.\n\n Base class for containers."]
pub type GtkContainerClass = _GtkContainerClass;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkContainer {
pub widget: GtkWidget,
pub priv_: *mut GtkContainerPrivate,
}
#[test]
fn bindgen_test_layout__GtkContainer() {
const UNINIT: ::std::mem::MaybeUninit<_GtkContainer> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkContainer>(),
40usize,
concat!("Size of: ", stringify!(_GtkContainer))
);
assert_eq!(
::std::mem::align_of::<_GtkContainer>(),
8usize,
concat!("Alignment of ", stringify!(_GtkContainer))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).widget) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainer),
"::",
stringify!(widget)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainer),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkContainer {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GtkContainerClass:\n @parent_class: The parent class.\n @add: Signal emitted when a widget is added to container.\n @remove: Signal emitted when a widget is removed from container.\n @check_resize: Signal emitted when a size recalculation is needed.\n @forall: Invokes callback on each child of container.\n @set_focus_child: Sets the focused child of container.\n @child_type: Returns the type of the children supported by the container.\n @composite_name: Gets a widget’s composite name. Deprecated: 3.10.\n @set_child_property: Set a property on a child of container.\n @get_child_property: Get a property from a child of container.\n @get_path_for_child: Get path representing entire widget hierarchy\n from the toplevel down to and including @child.\n\n Base class for containers."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkContainerClass {
pub parent_class: GtkWidgetClass,
pub add: ::std::option::Option<
unsafe extern "C" fn(container: *mut GtkContainer, widget: *mut GtkWidget),
>,
pub remove: ::std::option::Option<
unsafe extern "C" fn(container: *mut GtkContainer, widget: *mut GtkWidget),
>,
pub check_resize: ::std::option::Option<unsafe extern "C" fn(container: *mut GtkContainer)>,
pub forall: ::std::option::Option<
unsafe extern "C" fn(
container: *mut GtkContainer,
include_internals: gboolean,
callback: GtkCallback,
callback_data: gpointer,
),
>,
pub set_focus_child: ::std::option::Option<
unsafe extern "C" fn(container: *mut GtkContainer, child: *mut GtkWidget),
>,
pub child_type:
::std::option::Option<unsafe extern "C" fn(container: *mut GtkContainer) -> GType>,
pub composite_name: ::std::option::Option<
unsafe extern "C" fn(container: *mut GtkContainer, child: *mut GtkWidget) -> *mut gchar,
>,
pub set_child_property: ::std::option::Option<
unsafe extern "C" fn(
container: *mut GtkContainer,
child: *mut GtkWidget,
property_id: guint,
value: *const GValue,
pspec: *mut GParamSpec,
),
>,
pub get_child_property: ::std::option::Option<
unsafe extern "C" fn(
container: *mut GtkContainer,
child: *mut GtkWidget,
property_id: guint,
value: *mut GValue,
pspec: *mut GParamSpec,
),
>,
pub get_path_for_child: ::std::option::Option<
unsafe extern "C" fn(
container: *mut GtkContainer,
child: *mut GtkWidget,
) -> *mut GtkWidgetPath,
>,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub _gtk_reserved1: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved2: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved3: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved4: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved5: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved6: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved7: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved8: ::std::option::Option<unsafe extern "C" fn()>,
}
#[test]
fn bindgen_test_layout__GtkContainerClass() {
const UNINIT: ::std::mem::MaybeUninit<_GtkContainerClass> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkContainerClass>(),
976usize,
concat!("Size of: ", stringify!(_GtkContainerClass))
);
assert_eq!(
::std::mem::align_of::<_GtkContainerClass>(),
8usize,
concat!("Alignment of ", stringify!(_GtkContainerClass))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_class) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(parent_class)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).add) as usize - ptr as usize },
824usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(add)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).remove) as usize - ptr as usize },
832usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(remove)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).check_resize) as usize - ptr as usize },
840usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(check_resize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).forall) as usize - ptr as usize },
848usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(forall)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).set_focus_child) as usize - ptr as usize },
856usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(set_focus_child)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).child_type) as usize - ptr as usize },
864usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(child_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).composite_name) as usize - ptr as usize },
872usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(composite_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).set_child_property) as usize - ptr as usize },
880usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(set_child_property)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_child_property) as usize - ptr as usize },
888usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(get_child_property)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_path_for_child) as usize - ptr as usize },
896usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(get_path_for_child)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved1) as usize - ptr as usize },
912usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(_gtk_reserved1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved2) as usize - ptr as usize },
920usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(_gtk_reserved2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved3) as usize - ptr as usize },
928usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(_gtk_reserved3)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved4) as usize - ptr as usize },
936usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(_gtk_reserved4)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved5) as usize - ptr as usize },
944usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(_gtk_reserved5)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved6) as usize - ptr as usize },
952usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(_gtk_reserved6)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved7) as usize - ptr as usize },
960usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(_gtk_reserved7)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved8) as usize - ptr as usize },
968usize,
concat!(
"Offset of field: ",
stringify!(_GtkContainerClass),
"::",
stringify!(_gtk_reserved8)
)
);
}
impl Default for _GtkContainerClass {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl _GtkContainerClass {
#[inline]
pub fn _handle_border_width(&self) -> ::std::os::raw::c_uint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
}
#[inline]
pub fn set__handle_border_width(&mut self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
_handle_border_width: ::std::os::raw::c_uint,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let _handle_border_width: u32 = unsafe { ::std::mem::transmute(_handle_border_width) };
_handle_border_width as u64
});
__bindgen_bitfield_unit
}
}
pub const GtkResizeMode_GTK_RESIZE_PARENT: GtkResizeMode = 0;
pub const GtkResizeMode_GTK_RESIZE_QUEUE: GtkResizeMode = 1;
pub const GtkResizeMode_GTK_RESIZE_IMMEDIATE: GtkResizeMode = 2;
#[doc = " GtkResizeMode:\n @GTK_RESIZE_PARENT: Pass resize request to the parent\n @GTK_RESIZE_QUEUE: Queue resizes on this widget\n @GTK_RESIZE_IMMEDIATE: Resize immediately. Deprecated."]
pub type GtkResizeMode = ::std::os::raw::c_uint;
extern "C" {
pub fn gtk_container_get_type() -> GType;
}
extern "C" {
pub fn gtk_container_set_border_width(container: *mut GtkContainer, border_width: guint);
}
extern "C" {
pub fn gtk_container_get_border_width(container: *mut GtkContainer) -> guint;
}
extern "C" {
pub fn gtk_container_add(container: *mut GtkContainer, widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_container_remove(container: *mut GtkContainer, widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_container_set_resize_mode(container: *mut GtkContainer, resize_mode: GtkResizeMode);
}
extern "C" {
pub fn gtk_container_get_resize_mode(container: *mut GtkContainer) -> GtkResizeMode;
}
extern "C" {
pub fn gtk_container_check_resize(container: *mut GtkContainer);
}
extern "C" {
pub fn gtk_container_foreach(
container: *mut GtkContainer,
callback: GtkCallback,
callback_data: gpointer,
);
}
extern "C" {
pub fn gtk_container_get_children(container: *mut GtkContainer) -> *mut GList;
}
extern "C" {
pub fn gtk_container_propagate_draw(
container: *mut GtkContainer,
child: *mut GtkWidget,
cr: *mut cairo_t,
);
}
extern "C" {
pub fn gtk_container_set_focus_chain(
container: *mut GtkContainer,
focusable_widgets: *mut GList,
);
}
extern "C" {
pub fn gtk_container_get_focus_chain(
container: *mut GtkContainer,
focusable_widgets: *mut *mut GList,
) -> gboolean;
}
extern "C" {
pub fn gtk_container_unset_focus_chain(container: *mut GtkContainer);
}
extern "C" {
pub fn gtk_container_set_reallocate_redraws(
container: *mut GtkContainer,
needs_redraws: gboolean,
);
}
extern "C" {
pub fn gtk_container_set_focus_child(container: *mut GtkContainer, child: *mut GtkWidget);
}
extern "C" {
pub fn gtk_container_get_focus_child(container: *mut GtkContainer) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_container_set_focus_vadjustment(
container: *mut GtkContainer,
adjustment: *mut GtkAdjustment,
);
}
extern "C" {
pub fn gtk_container_get_focus_vadjustment(container: *mut GtkContainer) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_container_set_focus_hadjustment(
container: *mut GtkContainer,
adjustment: *mut GtkAdjustment,
);
}
extern "C" {
pub fn gtk_container_get_focus_hadjustment(container: *mut GtkContainer) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_container_resize_children(container: *mut GtkContainer);
}
extern "C" {
pub fn gtk_container_child_type(container: *mut GtkContainer) -> GType;
}
extern "C" {
pub fn gtk_container_class_install_child_property(
cclass: *mut GtkContainerClass,
property_id: guint,
pspec: *mut GParamSpec,
);
}
extern "C" {
pub fn gtk_container_class_find_child_property(
cclass: *mut GObjectClass,
property_name: *const gchar,
) -> *mut GParamSpec;
}
extern "C" {
pub fn gtk_container_class_list_child_properties(
cclass: *mut GObjectClass,
n_properties: *mut guint,
) -> *mut *mut GParamSpec;
}
extern "C" {
pub fn gtk_container_add_with_properties(
container: *mut GtkContainer,
widget: *mut GtkWidget,
first_prop_name: *const gchar,
...
);
}
extern "C" {
pub fn gtk_container_child_set(
container: *mut GtkContainer,
child: *mut GtkWidget,
first_prop_name: *const gchar,
...
);
}
extern "C" {
pub fn gtk_container_child_get(
container: *mut GtkContainer,
child: *mut GtkWidget,
first_prop_name: *const gchar,
...
);
}
extern "C" {
pub fn gtk_container_child_set_property(
container: *mut GtkContainer,
child: *mut GtkWidget,
property_name: *const gchar,
value: *const GValue,
);
}
extern "C" {
pub fn gtk_container_child_get_property(
container: *mut GtkContainer,
child: *mut GtkWidget,
property_name: *const gchar,
value: *mut GValue,
);
}
extern "C" {
pub fn gtk_container_child_notify(
container: *mut GtkContainer,
child: *mut GtkWidget,
child_property: *const gchar,
);
}
extern "C" {
pub fn gtk_container_forall(
container: *mut GtkContainer,
callback: GtkCallback,
callback_data: gpointer,
);
}
extern "C" {
pub fn gtk_container_class_handle_border_width(klass: *mut GtkContainerClass);
}
extern "C" {
pub fn gtk_container_get_path_for_child(
container: *mut GtkContainer,
child: *mut GtkWidget,
) -> *mut GtkWidgetPath;
}
pub type GtkBin = _GtkBin;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkBinPrivate {
_unused: [u8; 0],
}
pub type GtkBinPrivate = _GtkBinPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkBin {
pub container: GtkContainer,
pub priv_: *mut GtkBinPrivate,
}
#[test]
fn bindgen_test_layout__GtkBin() {
const UNINIT: ::std::mem::MaybeUninit<_GtkBin> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkBin>(),
48usize,
concat!("Size of: ", stringify!(_GtkBin))
);
assert_eq!(
::std::mem::align_of::<_GtkBin>(),
8usize,
concat!("Alignment of ", stringify!(_GtkBin))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).container) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkBin),
"::",
stringify!(container)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkBin),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkBin {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_bin_get_type() -> GType;
}
extern "C" {
pub fn gtk_bin_get_child(bin: *mut GtkBin) -> *mut GtkWidget;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkWindowPrivate {
_unused: [u8; 0],
}
pub type GtkWindowPrivate = _GtkWindowPrivate;
pub type GtkWindowGroup = _GtkWindowGroup;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkWindowGroupPrivate {
_unused: [u8; 0],
}
pub type GtkWindowGroupPrivate = _GtkWindowGroupPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkWindow {
pub bin: GtkBin,
pub priv_: *mut GtkWindowPrivate,
}
#[test]
fn bindgen_test_layout__GtkWindow() {
const UNINIT: ::std::mem::MaybeUninit<_GtkWindow> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkWindow>(),
56usize,
concat!("Size of: ", stringify!(_GtkWindow))
);
assert_eq!(
::std::mem::align_of::<_GtkWindow>(),
8usize,
concat!("Alignment of ", stringify!(_GtkWindow))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bin) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkWindow),
"::",
stringify!(bin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkWindow),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkWindow {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const GtkWindowType_GTK_WINDOW_TOPLEVEL: GtkWindowType = 0;
pub const GtkWindowType_GTK_WINDOW_POPUP: GtkWindowType = 1;
#[doc = " GtkWindowType:\n @GTK_WINDOW_TOPLEVEL: A regular window, such as a dialog.\n @GTK_WINDOW_POPUP: A special window such as a tooltip.\n\n A #GtkWindow can be one of these types. Most things you’d consider a\n “window” should have type #GTK_WINDOW_TOPLEVEL; windows with this type\n are managed by the window manager and have a frame by default (call\n gtk_window_set_decorated() to toggle the frame). Windows with type\n #GTK_WINDOW_POPUP are ignored by the window manager; window manager\n keybindings won’t work on them, the window manager won’t decorate the\n window with a frame, many GTK+ features that rely on the window\n manager will not work (e.g. resize grips and\n maximization/minimization). #GTK_WINDOW_POPUP is used to implement\n widgets such as #GtkMenu or tooltips that you normally don’t think of\n as windows per se. Nearly all windows should be #GTK_WINDOW_TOPLEVEL.\n In particular, do not use #GTK_WINDOW_POPUP just to turn off\n the window borders; use gtk_window_set_decorated() for that."]
pub type GtkWindowType = ::std::os::raw::c_uint;
pub const GtkWindowPosition_GTK_WIN_POS_NONE: GtkWindowPosition = 0;
pub const GtkWindowPosition_GTK_WIN_POS_CENTER: GtkWindowPosition = 1;
pub const GtkWindowPosition_GTK_WIN_POS_MOUSE: GtkWindowPosition = 2;
pub const GtkWindowPosition_GTK_WIN_POS_CENTER_ALWAYS: GtkWindowPosition = 3;
pub const GtkWindowPosition_GTK_WIN_POS_CENTER_ON_PARENT: GtkWindowPosition = 4;
#[doc = " GtkWindowPosition:\n @GTK_WIN_POS_NONE: No influence is made on placement.\n @GTK_WIN_POS_CENTER: Windows should be placed in the center of the screen.\n @GTK_WIN_POS_MOUSE: Windows should be placed at the current mouse position.\n @GTK_WIN_POS_CENTER_ALWAYS: Keep window centered as it changes size, etc.\n @GTK_WIN_POS_CENTER_ON_PARENT: Center the window on its transient\n parent (see gtk_window_set_transient_for()).\n\n Window placement can be influenced using this enumeration. Note that\n using #GTK_WIN_POS_CENTER_ALWAYS is almost always a bad idea.\n It won’t necessarily work well with all window managers or on all windowing systems."]
pub type GtkWindowPosition = ::std::os::raw::c_uint;
extern "C" {
pub fn gtk_window_get_type() -> GType;
}
extern "C" {
pub fn gtk_window_new(type_: GtkWindowType) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_window_set_title(window: *mut GtkWindow, title: *const gchar);
}
extern "C" {
pub fn gtk_window_get_title(window: *mut GtkWindow) -> *const gchar;
}
extern "C" {
pub fn gtk_window_set_wmclass(
window: *mut GtkWindow,
wmclass_name: *const gchar,
wmclass_class: *const gchar,
);
}
extern "C" {
pub fn gtk_window_set_role(window: *mut GtkWindow, role: *const gchar);
}
extern "C" {
pub fn gtk_window_set_startup_id(window: *mut GtkWindow, startup_id: *const gchar);
}
extern "C" {
pub fn gtk_window_get_role(window: *mut GtkWindow) -> *const gchar;
}
extern "C" {
pub fn gtk_window_add_accel_group(window: *mut GtkWindow, accel_group: *mut GtkAccelGroup);
}
extern "C" {
pub fn gtk_window_remove_accel_group(window: *mut GtkWindow, accel_group: *mut GtkAccelGroup);
}
extern "C" {
pub fn gtk_window_set_position(window: *mut GtkWindow, position: GtkWindowPosition);
}
extern "C" {
pub fn gtk_window_activate_focus(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_focus(window: *mut GtkWindow, focus: *mut GtkWidget);
}
extern "C" {
pub fn gtk_window_get_focus(window: *mut GtkWindow) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_window_set_default(window: *mut GtkWindow, default_widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_window_get_default_widget(window: *mut GtkWindow) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_window_activate_default(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_transient_for(window: *mut GtkWindow, parent: *mut GtkWindow);
}
extern "C" {
pub fn gtk_window_get_transient_for(window: *mut GtkWindow) -> *mut GtkWindow;
}
extern "C" {
pub fn gtk_window_set_attached_to(window: *mut GtkWindow, attach_widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_window_get_attached_to(window: *mut GtkWindow) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_window_set_opacity(window: *mut GtkWindow, opacity: gdouble);
}
extern "C" {
pub fn gtk_window_get_opacity(window: *mut GtkWindow) -> gdouble;
}
extern "C" {
pub fn gtk_window_set_type_hint(window: *mut GtkWindow, hint: GdkWindowTypeHint);
}
extern "C" {
pub fn gtk_window_get_type_hint(window: *mut GtkWindow) -> GdkWindowTypeHint;
}
extern "C" {
pub fn gtk_window_set_skip_taskbar_hint(window: *mut GtkWindow, setting: gboolean);
}
extern "C" {
pub fn gtk_window_get_skip_taskbar_hint(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_skip_pager_hint(window: *mut GtkWindow, setting: gboolean);
}
extern "C" {
pub fn gtk_window_get_skip_pager_hint(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_urgency_hint(window: *mut GtkWindow, setting: gboolean);
}
extern "C" {
pub fn gtk_window_get_urgency_hint(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_accept_focus(window: *mut GtkWindow, setting: gboolean);
}
extern "C" {
pub fn gtk_window_get_accept_focus(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_focus_on_map(window: *mut GtkWindow, setting: gboolean);
}
extern "C" {
pub fn gtk_window_get_focus_on_map(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_destroy_with_parent(window: *mut GtkWindow, setting: gboolean);
}
extern "C" {
pub fn gtk_window_get_destroy_with_parent(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_hide_titlebar_when_maximized(window: *mut GtkWindow, setting: gboolean);
}
extern "C" {
pub fn gtk_window_get_hide_titlebar_when_maximized(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_mnemonics_visible(window: *mut GtkWindow, setting: gboolean);
}
extern "C" {
pub fn gtk_window_get_mnemonics_visible(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_focus_visible(window: *mut GtkWindow, setting: gboolean);
}
extern "C" {
pub fn gtk_window_get_focus_visible(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_resizable(window: *mut GtkWindow, resizable: gboolean);
}
extern "C" {
pub fn gtk_window_get_resizable(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_gravity(window: *mut GtkWindow, gravity: GdkGravity);
}
extern "C" {
pub fn gtk_window_get_gravity(window: *mut GtkWindow) -> GdkGravity;
}
extern "C" {
pub fn gtk_window_set_geometry_hints(
window: *mut GtkWindow,
geometry_widget: *mut GtkWidget,
geometry: *mut GdkGeometry,
geom_mask: GdkWindowHints,
);
}
extern "C" {
pub fn gtk_window_set_screen(window: *mut GtkWindow, screen: *mut GdkScreen);
}
extern "C" {
pub fn gtk_window_get_screen(window: *mut GtkWindow) -> *mut GdkScreen;
}
extern "C" {
pub fn gtk_window_is_active(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_has_toplevel_focus(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_decorated(window: *mut GtkWindow, setting: gboolean);
}
extern "C" {
pub fn gtk_window_get_decorated(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_deletable(window: *mut GtkWindow, setting: gboolean);
}
extern "C" {
pub fn gtk_window_get_deletable(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_icon_list(window: *mut GtkWindow, list: *mut GList);
}
extern "C" {
pub fn gtk_window_get_icon_list(window: *mut GtkWindow) -> *mut GList;
}
extern "C" {
pub fn gtk_window_set_icon(window: *mut GtkWindow, icon: *mut GdkPixbuf);
}
extern "C" {
pub fn gtk_window_set_icon_name(window: *mut GtkWindow, name: *const gchar);
}
extern "C" {
pub fn gtk_window_set_icon_from_file(
window: *mut GtkWindow,
filename: *const gchar,
err: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_window_get_icon(window: *mut GtkWindow) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_window_get_icon_name(window: *mut GtkWindow) -> *const gchar;
}
extern "C" {
pub fn gtk_window_set_default_icon_list(list: *mut GList);
}
extern "C" {
pub fn gtk_window_get_default_icon_list() -> *mut GList;
}
extern "C" {
pub fn gtk_window_set_default_icon(icon: *mut GdkPixbuf);
}
extern "C" {
pub fn gtk_window_set_default_icon_name(name: *const gchar);
}
extern "C" {
pub fn gtk_window_get_default_icon_name() -> *const gchar;
}
extern "C" {
pub fn gtk_window_set_default_icon_from_file(
filename: *const gchar,
err: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_auto_startup_notification(setting: gboolean);
}
extern "C" {
pub fn gtk_window_set_modal(window: *mut GtkWindow, modal: gboolean);
}
extern "C" {
pub fn gtk_window_get_modal(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_list_toplevels() -> *mut GList;
}
extern "C" {
pub fn gtk_window_set_has_user_ref_count(window: *mut GtkWindow, setting: gboolean);
}
extern "C" {
pub fn gtk_window_add_mnemonic(window: *mut GtkWindow, keyval: guint, target: *mut GtkWidget);
}
extern "C" {
pub fn gtk_window_remove_mnemonic(
window: *mut GtkWindow,
keyval: guint,
target: *mut GtkWidget,
);
}
extern "C" {
pub fn gtk_window_mnemonic_activate(
window: *mut GtkWindow,
keyval: guint,
modifier: GdkModifierType,
) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_mnemonic_modifier(window: *mut GtkWindow, modifier: GdkModifierType);
}
extern "C" {
pub fn gtk_window_get_mnemonic_modifier(window: *mut GtkWindow) -> GdkModifierType;
}
extern "C" {
pub fn gtk_window_activate_key(window: *mut GtkWindow, event: *mut GdkEventKey) -> gboolean;
}
extern "C" {
pub fn gtk_window_propagate_key_event(
window: *mut GtkWindow,
event: *mut GdkEventKey,
) -> gboolean;
}
extern "C" {
pub fn gtk_window_present(window: *mut GtkWindow);
}
extern "C" {
pub fn gtk_window_present_with_time(window: *mut GtkWindow, timestamp: guint32);
}
extern "C" {
pub fn gtk_window_iconify(window: *mut GtkWindow);
}
extern "C" {
pub fn gtk_window_deiconify(window: *mut GtkWindow);
}
extern "C" {
pub fn gtk_window_stick(window: *mut GtkWindow);
}
extern "C" {
pub fn gtk_window_unstick(window: *mut GtkWindow);
}
extern "C" {
pub fn gtk_window_maximize(window: *mut GtkWindow);
}
extern "C" {
pub fn gtk_window_unmaximize(window: *mut GtkWindow);
}
extern "C" {
pub fn gtk_window_fullscreen(window: *mut GtkWindow);
}
extern "C" {
pub fn gtk_window_unfullscreen(window: *mut GtkWindow);
}
extern "C" {
pub fn gtk_window_close(window: *mut GtkWindow);
}
extern "C" {
pub fn gtk_window_set_keep_above(window: *mut GtkWindow, setting: gboolean);
}
extern "C" {
pub fn gtk_window_set_keep_below(window: *mut GtkWindow, setting: gboolean);
}
extern "C" {
pub fn gtk_window_begin_resize_drag(
window: *mut GtkWindow,
edge: GdkWindowEdge,
button: gint,
root_x: gint,
root_y: gint,
timestamp: guint32,
);
}
extern "C" {
pub fn gtk_window_begin_move_drag(
window: *mut GtkWindow,
button: gint,
root_x: gint,
root_y: gint,
timestamp: guint32,
);
}
extern "C" {
pub fn gtk_window_set_default_size(window: *mut GtkWindow, width: gint, height: gint);
}
extern "C" {
pub fn gtk_window_get_default_size(window: *mut GtkWindow, width: *mut gint, height: *mut gint);
}
extern "C" {
pub fn gtk_window_resize(window: *mut GtkWindow, width: gint, height: gint);
}
extern "C" {
pub fn gtk_window_get_size(window: *mut GtkWindow, width: *mut gint, height: *mut gint);
}
extern "C" {
pub fn gtk_window_move(window: *mut GtkWindow, x: gint, y: gint);
}
extern "C" {
pub fn gtk_window_get_position(window: *mut GtkWindow, root_x: *mut gint, root_y: *mut gint);
}
extern "C" {
pub fn gtk_window_parse_geometry(window: *mut GtkWindow, geometry: *const gchar) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_default_geometry(window: *mut GtkWindow, width: gint, height: gint);
}
extern "C" {
pub fn gtk_window_resize_to_geometry(window: *mut GtkWindow, width: gint, height: gint);
}
extern "C" {
pub fn gtk_window_get_group(window: *mut GtkWindow) -> *mut GtkWindowGroup;
}
extern "C" {
pub fn gtk_window_has_group(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_reshow_with_initial_size(window: *mut GtkWindow);
}
extern "C" {
pub fn gtk_window_get_window_type(window: *mut GtkWindow) -> GtkWindowType;
}
extern "C" {
pub fn gtk_window_get_application(window: *mut GtkWindow) -> *mut GtkApplication;
}
extern "C" {
pub fn gtk_window_set_application(window: *mut GtkWindow, application: *mut GtkApplication);
}
extern "C" {
pub fn gtk_window_set_has_resize_grip(window: *mut GtkWindow, value: gboolean);
}
extern "C" {
pub fn gtk_window_get_has_resize_grip(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_resize_grip_is_visible(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_get_resize_grip_area(
window: *mut GtkWindow,
rect: *mut GdkRectangle,
) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_titlebar(window: *mut GtkWindow, titlebar: *mut GtkWidget);
}
extern "C" {
pub fn gtk_window_is_maximized(window: *mut GtkWindow) -> gboolean;
}
extern "C" {
pub fn gtk_window_set_interactive_debugging(enable: gboolean);
}
pub const GtkDialogFlags_GTK_DIALOG_MODAL: GtkDialogFlags = 1;
pub const GtkDialogFlags_GTK_DIALOG_DESTROY_WITH_PARENT: GtkDialogFlags = 2;
pub const GtkDialogFlags_GTK_DIALOG_USE_HEADER_BAR: GtkDialogFlags = 4;
#[doc = " GtkDialogFlags:\n @GTK_DIALOG_MODAL: Make the constructed dialog modal,\n see gtk_window_set_modal()\n @GTK_DIALOG_DESTROY_WITH_PARENT: Destroy the dialog when its\n parent is destroyed, see gtk_window_set_destroy_with_parent()\n @GTK_DIALOG_USE_HEADER_BAR: Create dialog with actions in header\n bar instead of action area. Since 3.12.\n\n Flags used to influence dialog construction."]
pub type GtkDialogFlags = ::std::os::raw::c_uint;
#[doc = " GtkDialog:\n\n The #GtkDialog-struct contains only private fields\n and should not be directly accessed."]
pub type GtkDialog = _GtkDialog;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkDialogPrivate {
_unused: [u8; 0],
}
pub type GtkDialogPrivate = _GtkDialogPrivate;
#[doc = " GtkDialog:\n\n The #GtkDialog-struct contains only private fields\n and should not be directly accessed."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkDialog {
pub window: GtkWindow,
pub priv_: *mut GtkDialogPrivate,
}
#[test]
fn bindgen_test_layout__GtkDialog() {
const UNINIT: ::std::mem::MaybeUninit<_GtkDialog> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkDialog>(),
64usize,
concat!("Size of: ", stringify!(_GtkDialog))
);
assert_eq!(
::std::mem::align_of::<_GtkDialog>(),
8usize,
concat!("Alignment of ", stringify!(_GtkDialog))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkDialog),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkDialog),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkDialog {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_dialog_get_type() -> GType;
}
extern "C" {
pub fn gtk_dialog_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_dialog_new_with_buttons(
title: *const gchar,
parent: *mut GtkWindow,
flags: GtkDialogFlags,
first_button_text: *const gchar,
...
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_dialog_add_action_widget(
dialog: *mut GtkDialog,
child: *mut GtkWidget,
response_id: gint,
);
}
extern "C" {
pub fn gtk_dialog_add_button(
dialog: *mut GtkDialog,
button_text: *const gchar,
response_id: gint,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_dialog_add_buttons(dialog: *mut GtkDialog, first_button_text: *const gchar, ...);
}
extern "C" {
pub fn gtk_dialog_set_response_sensitive(
dialog: *mut GtkDialog,
response_id: gint,
setting: gboolean,
);
}
extern "C" {
pub fn gtk_dialog_set_default_response(dialog: *mut GtkDialog, response_id: gint);
}
extern "C" {
pub fn gtk_dialog_get_widget_for_response(
dialog: *mut GtkDialog,
response_id: gint,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_dialog_get_response_for_widget(
dialog: *mut GtkDialog,
widget: *mut GtkWidget,
) -> gint;
}
extern "C" {
pub fn gtk_alternative_dialog_button_order(screen: *mut GdkScreen) -> gboolean;
}
extern "C" {
pub fn gtk_dialog_set_alternative_button_order(
dialog: *mut GtkDialog,
first_response_id: gint,
...
);
}
extern "C" {
pub fn gtk_dialog_set_alternative_button_order_from_array(
dialog: *mut GtkDialog,
n_params: gint,
new_order: *mut gint,
);
}
extern "C" {
pub fn gtk_dialog_response(dialog: *mut GtkDialog, response_id: gint);
}
extern "C" {
pub fn gtk_dialog_run(dialog: *mut GtkDialog) -> gint;
}
extern "C" {
pub fn gtk_dialog_get_action_area(dialog: *mut GtkDialog) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_dialog_get_content_area(dialog: *mut GtkDialog) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_dialog_get_header_bar(dialog: *mut GtkDialog) -> *mut GtkWidget;
}
#[doc = " GtkAboutDialog:\n\n The #GtkAboutDialog-struct contains\n only private fields and should not be directly accessed."]
pub type GtkAboutDialog = _GtkAboutDialog;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAboutDialogPrivate {
_unused: [u8; 0],
}
pub type GtkAboutDialogPrivate = _GtkAboutDialogPrivate;
pub const GtkLicense_GTK_LICENSE_UNKNOWN: GtkLicense = 0;
pub const GtkLicense_GTK_LICENSE_CUSTOM: GtkLicense = 1;
pub const GtkLicense_GTK_LICENSE_GPL_2_0: GtkLicense = 2;
pub const GtkLicense_GTK_LICENSE_GPL_3_0: GtkLicense = 3;
pub const GtkLicense_GTK_LICENSE_LGPL_2_1: GtkLicense = 4;
pub const GtkLicense_GTK_LICENSE_LGPL_3_0: GtkLicense = 5;
pub const GtkLicense_GTK_LICENSE_BSD: GtkLicense = 6;
pub const GtkLicense_GTK_LICENSE_MIT_X11: GtkLicense = 7;
pub const GtkLicense_GTK_LICENSE_ARTISTIC: GtkLicense = 8;
pub const GtkLicense_GTK_LICENSE_GPL_2_0_ONLY: GtkLicense = 9;
pub const GtkLicense_GTK_LICENSE_GPL_3_0_ONLY: GtkLicense = 10;
pub const GtkLicense_GTK_LICENSE_LGPL_2_1_ONLY: GtkLicense = 11;
pub const GtkLicense_GTK_LICENSE_LGPL_3_0_ONLY: GtkLicense = 12;
#[doc = " GtkLicense:\n @GTK_LICENSE_UNKNOWN: No license specified\n @GTK_LICENSE_CUSTOM: A license text is going to be specified by the\n developer\n @GTK_LICENSE_GPL_2_0: The GNU General Public License, version 2.0 or later\n @GTK_LICENSE_GPL_3_0: The GNU General Public License, version 3.0 or later\n @GTK_LICENSE_LGPL_2_1: The GNU Lesser General Public License, version 2.1 or later\n @GTK_LICENSE_LGPL_3_0: The GNU Lesser General Public License, version 3.0 or later\n @GTK_LICENSE_BSD: The BSD standard license\n @GTK_LICENSE_MIT_X11: The MIT/X11 standard license\n @GTK_LICENSE_ARTISTIC: The Artistic License, version 2.0\n @GTK_LICENSE_GPL_2_0_ONLY: The GNU General Public License, version 2.0 only. Since 3.12.\n @GTK_LICENSE_GPL_3_0_ONLY: The GNU General Public License, version 3.0 only. Since 3.12.\n @GTK_LICENSE_LGPL_2_1_ONLY: The GNU Lesser General Public License, version 2.1 only. Since 3.12.\n @GTK_LICENSE_LGPL_3_0_ONLY: The GNU Lesser General Public License, version 3.0 only. Since 3.12.\n\n The type of license for an application.\n\n This enumeration can be expanded at later date.\n\n Since: 3.0"]
pub type GtkLicense = ::std::os::raw::c_uint;
#[doc = " GtkAboutDialog:\n\n The #GtkAboutDialog-struct contains\n only private fields and should not be directly accessed."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAboutDialog {
pub parent_instance: GtkDialog,
pub priv_: *mut GtkAboutDialogPrivate,
}
#[test]
fn bindgen_test_layout__GtkAboutDialog() {
const UNINIT: ::std::mem::MaybeUninit<_GtkAboutDialog> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkAboutDialog>(),
72usize,
concat!("Size of: ", stringify!(_GtkAboutDialog))
);
assert_eq!(
::std::mem::align_of::<_GtkAboutDialog>(),
8usize,
concat!("Alignment of ", stringify!(_GtkAboutDialog))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkAboutDialog),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GtkAboutDialog),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkAboutDialog {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_about_dialog_get_type() -> GType;
}
extern "C" {
pub fn gtk_about_dialog_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_show_about_dialog(parent: *mut GtkWindow, first_property_name: *const gchar, ...);
}
extern "C" {
pub fn gtk_about_dialog_get_program_name(about: *mut GtkAboutDialog) -> *const gchar;
}
extern "C" {
pub fn gtk_about_dialog_set_program_name(about: *mut GtkAboutDialog, name: *const gchar);
}
extern "C" {
pub fn gtk_about_dialog_get_version(about: *mut GtkAboutDialog) -> *const gchar;
}
extern "C" {
pub fn gtk_about_dialog_set_version(about: *mut GtkAboutDialog, version: *const gchar);
}
extern "C" {
pub fn gtk_about_dialog_get_copyright(about: *mut GtkAboutDialog) -> *const gchar;
}
extern "C" {
pub fn gtk_about_dialog_set_copyright(about: *mut GtkAboutDialog, copyright: *const gchar);
}
extern "C" {
pub fn gtk_about_dialog_get_comments(about: *mut GtkAboutDialog) -> *const gchar;
}
extern "C" {
pub fn gtk_about_dialog_set_comments(about: *mut GtkAboutDialog, comments: *const gchar);
}
extern "C" {
pub fn gtk_about_dialog_get_license(about: *mut GtkAboutDialog) -> *const gchar;
}
extern "C" {
pub fn gtk_about_dialog_set_license(about: *mut GtkAboutDialog, license: *const gchar);
}
extern "C" {
pub fn gtk_about_dialog_set_license_type(about: *mut GtkAboutDialog, license_type: GtkLicense);
}
extern "C" {
pub fn gtk_about_dialog_get_license_type(about: *mut GtkAboutDialog) -> GtkLicense;
}
extern "C" {
pub fn gtk_about_dialog_get_wrap_license(about: *mut GtkAboutDialog) -> gboolean;
}
extern "C" {
pub fn gtk_about_dialog_set_wrap_license(about: *mut GtkAboutDialog, wrap_license: gboolean);
}
extern "C" {
pub fn gtk_about_dialog_get_website(about: *mut GtkAboutDialog) -> *const gchar;
}
extern "C" {
pub fn gtk_about_dialog_set_website(about: *mut GtkAboutDialog, website: *const gchar);
}
extern "C" {
pub fn gtk_about_dialog_get_website_label(about: *mut GtkAboutDialog) -> *const gchar;
}
extern "C" {
pub fn gtk_about_dialog_set_website_label(
about: *mut GtkAboutDialog,
website_label: *const gchar,
);
}
extern "C" {
pub fn gtk_about_dialog_get_authors(about: *mut GtkAboutDialog) -> *const *const gchar;
}
extern "C" {
pub fn gtk_about_dialog_set_authors(about: *mut GtkAboutDialog, authors: *mut *const gchar);
}
extern "C" {
pub fn gtk_about_dialog_get_documenters(about: *mut GtkAboutDialog) -> *const *const gchar;
}
extern "C" {
pub fn gtk_about_dialog_set_documenters(
about: *mut GtkAboutDialog,
documenters: *mut *const gchar,
);
}
extern "C" {
pub fn gtk_about_dialog_get_artists(about: *mut GtkAboutDialog) -> *const *const gchar;
}
extern "C" {
pub fn gtk_about_dialog_set_artists(about: *mut GtkAboutDialog, artists: *mut *const gchar);
}
extern "C" {
pub fn gtk_about_dialog_get_translator_credits(about: *mut GtkAboutDialog) -> *const gchar;
}
extern "C" {
pub fn gtk_about_dialog_set_translator_credits(
about: *mut GtkAboutDialog,
translator_credits: *const gchar,
);
}
extern "C" {
pub fn gtk_about_dialog_get_logo(about: *mut GtkAboutDialog) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_about_dialog_set_logo(about: *mut GtkAboutDialog, logo: *mut GdkPixbuf);
}
extern "C" {
pub fn gtk_about_dialog_get_logo_icon_name(about: *mut GtkAboutDialog) -> *const gchar;
}
extern "C" {
pub fn gtk_about_dialog_set_logo_icon_name(about: *mut GtkAboutDialog, icon_name: *const gchar);
}
extern "C" {
pub fn gtk_about_dialog_add_credit_section(
about: *mut GtkAboutDialog,
section_name: *const gchar,
people: *mut *const gchar,
);
}
pub type GtkMisc = _GtkMisc;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMiscPrivate {
_unused: [u8; 0],
}
pub type GtkMiscPrivate = _GtkMiscPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMisc {
pub widget: GtkWidget,
pub priv_: *mut GtkMiscPrivate,
}
#[test]
fn bindgen_test_layout__GtkMisc() {
const UNINIT: ::std::mem::MaybeUninit<_GtkMisc> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkMisc>(),
40usize,
concat!("Size of: ", stringify!(_GtkMisc))
);
assert_eq!(
::std::mem::align_of::<_GtkMisc>(),
8usize,
concat!("Alignment of ", stringify!(_GtkMisc))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).widget) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkMisc),
"::",
stringify!(widget)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkMisc),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkMisc {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_misc_get_type() -> GType;
}
extern "C" {
pub fn gtk_misc_set_alignment(misc: *mut GtkMisc, xalign: gfloat, yalign: gfloat);
}
extern "C" {
pub fn gtk_misc_get_alignment(misc: *mut GtkMisc, xalign: *mut gfloat, yalign: *mut gfloat);
}
extern "C" {
pub fn gtk_misc_set_padding(misc: *mut GtkMisc, xpad: gint, ypad: gint);
}
extern "C" {
pub fn gtk_misc_get_padding(misc: *mut GtkMisc, xpad: *mut gint, ypad: *mut gint);
}
pub type GtkMenuShell = _GtkMenuShell;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMenuShellPrivate {
_unused: [u8; 0],
}
pub type GtkMenuShellPrivate = _GtkMenuShellPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMenuShell {
pub container: GtkContainer,
pub priv_: *mut GtkMenuShellPrivate,
}
#[test]
fn bindgen_test_layout__GtkMenuShell() {
const UNINIT: ::std::mem::MaybeUninit<_GtkMenuShell> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkMenuShell>(),
48usize,
concat!("Size of: ", stringify!(_GtkMenuShell))
);
assert_eq!(
::std::mem::align_of::<_GtkMenuShell>(),
8usize,
concat!("Alignment of ", stringify!(_GtkMenuShell))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).container) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkMenuShell),
"::",
stringify!(container)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkMenuShell),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkMenuShell {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_menu_shell_get_type() -> GType;
}
extern "C" {
pub fn gtk_menu_shell_append(menu_shell: *mut GtkMenuShell, child: *mut GtkWidget);
}
extern "C" {
pub fn gtk_menu_shell_prepend(menu_shell: *mut GtkMenuShell, child: *mut GtkWidget);
}
extern "C" {
pub fn gtk_menu_shell_insert(
menu_shell: *mut GtkMenuShell,
child: *mut GtkWidget,
position: gint,
);
}
extern "C" {
pub fn gtk_menu_shell_deactivate(menu_shell: *mut GtkMenuShell);
}
extern "C" {
pub fn gtk_menu_shell_select_item(menu_shell: *mut GtkMenuShell, menu_item: *mut GtkWidget);
}
extern "C" {
pub fn gtk_menu_shell_deselect(menu_shell: *mut GtkMenuShell);
}
extern "C" {
pub fn gtk_menu_shell_activate_item(
menu_shell: *mut GtkMenuShell,
menu_item: *mut GtkWidget,
force_deactivate: gboolean,
);
}
extern "C" {
pub fn gtk_menu_shell_select_first(menu_shell: *mut GtkMenuShell, search_sensitive: gboolean);
}
extern "C" {
pub fn gtk_menu_shell_cancel(menu_shell: *mut GtkMenuShell);
}
extern "C" {
pub fn gtk_menu_shell_get_take_focus(menu_shell: *mut GtkMenuShell) -> gboolean;
}
extern "C" {
pub fn gtk_menu_shell_set_take_focus(menu_shell: *mut GtkMenuShell, take_focus: gboolean);
}
extern "C" {
pub fn gtk_menu_shell_get_selected_item(menu_shell: *mut GtkMenuShell) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_menu_shell_get_parent_shell(menu_shell: *mut GtkMenuShell) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_menu_shell_bind_model(
menu_shell: *mut GtkMenuShell,
model: *mut GMenuModel,
action_namespace: *const gchar,
with_separators: gboolean,
);
}
pub type GtkMenu = _GtkMenu;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMenuPrivate {
_unused: [u8; 0],
}
pub type GtkMenuPrivate = _GtkMenuPrivate;
#[doc = " GtkMenuPositionFunc:\n @menu: a #GtkMenu.\n @x: (out): address of the #gint representing the horizontal\n position where the menu shall be drawn.\n @y: (out): address of the #gint representing the vertical position\n where the menu shall be drawn. This is an output parameter.\n @push_in: (out): This parameter controls how menus placed outside\n the monitor are handled. If this is set to %TRUE and part of\n the menu is outside the monitor then GTK+ pushes the window\n into the visible area, effectively modifying the popup\n position. Note that moving and possibly resizing the menu\n around will alter the scroll position to keep the menu items\n “in place”, i.e. at the same monitor position they would have\n been without resizing. In practice, this behavior is only\n useful for combobox popups or option menus and cannot be used\n to simply confine a menu to monitor boundaries. In that case,\n changing the scroll offset is not desirable.\n @user_data: the data supplied by the user in the gtk_menu_popup()\n @data parameter.\n\n A user function supplied when calling gtk_menu_popup() which\n controls the positioning of the menu when it is displayed. The\n function sets the @x and @y parameters to the coordinates where the\n menu is to be drawn. To make the menu appear on a different\n monitor than the mouse pointer, gtk_menu_set_monitor() must be\n called."]
pub type GtkMenuPositionFunc = ::std::option::Option<
unsafe extern "C" fn(
menu: *mut GtkMenu,
x: *mut gint,
y: *mut gint,
push_in: *mut gboolean,
user_data: gpointer,
),
>;
#[doc = " GtkMenuDetachFunc:\n @attach_widget: the #GtkWidget that the menu is being detached from.\n @menu: the #GtkMenu being detached.\n\n A user function supplied when calling gtk_menu_attach_to_widget() which\n will be called when the menu is later detached from the widget."]
pub type GtkMenuDetachFunc =
::std::option::Option<unsafe extern "C" fn(attach_widget: *mut GtkWidget, menu: *mut GtkMenu)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMenu {
pub menu_shell: GtkMenuShell,
pub priv_: *mut GtkMenuPrivate,
}
#[test]
fn bindgen_test_layout__GtkMenu() {
const UNINIT: ::std::mem::MaybeUninit<_GtkMenu> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkMenu>(),
56usize,
concat!("Size of: ", stringify!(_GtkMenu))
);
assert_eq!(
::std::mem::align_of::<_GtkMenu>(),
8usize,
concat!("Alignment of ", stringify!(_GtkMenu))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).menu_shell) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkMenu),
"::",
stringify!(menu_shell)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkMenu),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkMenu {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_menu_get_type() -> GType;
}
extern "C" {
pub fn gtk_menu_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_menu_new_from_model(model: *mut GMenuModel) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_menu_popup(
menu: *mut GtkMenu,
parent_menu_shell: *mut GtkWidget,
parent_menu_item: *mut GtkWidget,
func: GtkMenuPositionFunc,
data: gpointer,
button: guint,
activate_time: guint32,
);
}
extern "C" {
pub fn gtk_menu_popup_for_device(
menu: *mut GtkMenu,
device: *mut GdkDevice,
parent_menu_shell: *mut GtkWidget,
parent_menu_item: *mut GtkWidget,
func: GtkMenuPositionFunc,
data: gpointer,
destroy: GDestroyNotify,
button: guint,
activate_time: guint32,
);
}
extern "C" {
pub fn gtk_menu_reposition(menu: *mut GtkMenu);
}
extern "C" {
pub fn gtk_menu_popdown(menu: *mut GtkMenu);
}
extern "C" {
pub fn gtk_menu_get_active(menu: *mut GtkMenu) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_menu_set_active(menu: *mut GtkMenu, index: guint);
}
extern "C" {
pub fn gtk_menu_set_accel_group(menu: *mut GtkMenu, accel_group: *mut GtkAccelGroup);
}
extern "C" {
pub fn gtk_menu_get_accel_group(menu: *mut GtkMenu) -> *mut GtkAccelGroup;
}
extern "C" {
pub fn gtk_menu_set_accel_path(menu: *mut GtkMenu, accel_path: *const gchar);
}
extern "C" {
pub fn gtk_menu_get_accel_path(menu: *mut GtkMenu) -> *const gchar;
}
extern "C" {
pub fn gtk_menu_attach_to_widget(
menu: *mut GtkMenu,
attach_widget: *mut GtkWidget,
detacher: GtkMenuDetachFunc,
);
}
extern "C" {
pub fn gtk_menu_detach(menu: *mut GtkMenu);
}
extern "C" {
pub fn gtk_menu_get_attach_widget(menu: *mut GtkMenu) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_menu_set_tearoff_state(menu: *mut GtkMenu, torn_off: gboolean);
}
extern "C" {
pub fn gtk_menu_get_tearoff_state(menu: *mut GtkMenu) -> gboolean;
}
extern "C" {
pub fn gtk_menu_set_title(menu: *mut GtkMenu, title: *const gchar);
}
extern "C" {
pub fn gtk_menu_get_title(menu: *mut GtkMenu) -> *const gchar;
}
extern "C" {
pub fn gtk_menu_reorder_child(menu: *mut GtkMenu, child: *mut GtkWidget, position: gint);
}
extern "C" {
pub fn gtk_menu_set_screen(menu: *mut GtkMenu, screen: *mut GdkScreen);
}
extern "C" {
pub fn gtk_menu_attach(
menu: *mut GtkMenu,
child: *mut GtkWidget,
left_attach: guint,
right_attach: guint,
top_attach: guint,
bottom_attach: guint,
);
}
extern "C" {
pub fn gtk_menu_set_monitor(menu: *mut GtkMenu, monitor_num: gint);
}
extern "C" {
pub fn gtk_menu_get_monitor(menu: *mut GtkMenu) -> gint;
}
extern "C" {
pub fn gtk_menu_get_for_attach_widget(widget: *mut GtkWidget) -> *mut GList;
}
extern "C" {
pub fn gtk_menu_set_reserve_toggle_size(menu: *mut GtkMenu, reserve_toggle_size: gboolean);
}
extern "C" {
pub fn gtk_menu_get_reserve_toggle_size(menu: *mut GtkMenu) -> gboolean;
}
pub type GtkLabel = _GtkLabel;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkLabelPrivate {
_unused: [u8; 0],
}
pub type GtkLabelPrivate = _GtkLabelPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkLabel {
pub misc: GtkMisc,
pub priv_: *mut GtkLabelPrivate,
}
#[test]
fn bindgen_test_layout__GtkLabel() {
const UNINIT: ::std::mem::MaybeUninit<_GtkLabel> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkLabel>(),
48usize,
concat!("Size of: ", stringify!(_GtkLabel))
);
assert_eq!(
::std::mem::align_of::<_GtkLabel>(),
8usize,
concat!("Alignment of ", stringify!(_GtkLabel))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).misc) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkLabel),
"::",
stringify!(misc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkLabel),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkLabel {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_label_get_type() -> GType;
}
extern "C" {
pub fn gtk_label_new(str_: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_label_new_with_mnemonic(str_: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_label_set_text(label: *mut GtkLabel, str_: *const gchar);
}
extern "C" {
pub fn gtk_label_get_text(label: *mut GtkLabel) -> *const gchar;
}
extern "C" {
pub fn gtk_label_set_attributes(label: *mut GtkLabel, attrs: *mut PangoAttrList);
}
extern "C" {
pub fn gtk_label_get_attributes(label: *mut GtkLabel) -> *mut PangoAttrList;
}
extern "C" {
pub fn gtk_label_set_label(label: *mut GtkLabel, str_: *const gchar);
}
extern "C" {
pub fn gtk_label_get_label(label: *mut GtkLabel) -> *const gchar;
}
extern "C" {
pub fn gtk_label_set_markup(label: *mut GtkLabel, str_: *const gchar);
}
extern "C" {
pub fn gtk_label_set_use_markup(label: *mut GtkLabel, setting: gboolean);
}
extern "C" {
pub fn gtk_label_get_use_markup(label: *mut GtkLabel) -> gboolean;
}
extern "C" {
pub fn gtk_label_set_use_underline(label: *mut GtkLabel, setting: gboolean);
}
extern "C" {
pub fn gtk_label_get_use_underline(label: *mut GtkLabel) -> gboolean;
}
extern "C" {
pub fn gtk_label_set_markup_with_mnemonic(label: *mut GtkLabel, str_: *const gchar);
}
extern "C" {
pub fn gtk_label_get_mnemonic_keyval(label: *mut GtkLabel) -> guint;
}
extern "C" {
pub fn gtk_label_set_mnemonic_widget(label: *mut GtkLabel, widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_label_get_mnemonic_widget(label: *mut GtkLabel) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_label_set_text_with_mnemonic(label: *mut GtkLabel, str_: *const gchar);
}
extern "C" {
pub fn gtk_label_set_justify(label: *mut GtkLabel, jtype: GtkJustification);
}
extern "C" {
pub fn gtk_label_get_justify(label: *mut GtkLabel) -> GtkJustification;
}
extern "C" {
pub fn gtk_label_set_ellipsize(label: *mut GtkLabel, mode: PangoEllipsizeMode);
}
extern "C" {
pub fn gtk_label_get_ellipsize(label: *mut GtkLabel) -> PangoEllipsizeMode;
}
extern "C" {
pub fn gtk_label_set_width_chars(label: *mut GtkLabel, n_chars: gint);
}
extern "C" {
pub fn gtk_label_get_width_chars(label: *mut GtkLabel) -> gint;
}
extern "C" {
pub fn gtk_label_set_max_width_chars(label: *mut GtkLabel, n_chars: gint);
}
extern "C" {
pub fn gtk_label_get_max_width_chars(label: *mut GtkLabel) -> gint;
}
extern "C" {
pub fn gtk_label_set_lines(label: *mut GtkLabel, lines: gint);
}
extern "C" {
pub fn gtk_label_get_lines(label: *mut GtkLabel) -> gint;
}
extern "C" {
pub fn gtk_label_set_pattern(label: *mut GtkLabel, pattern: *const gchar);
}
extern "C" {
pub fn gtk_label_set_line_wrap(label: *mut GtkLabel, wrap: gboolean);
}
extern "C" {
pub fn gtk_label_get_line_wrap(label: *mut GtkLabel) -> gboolean;
}
extern "C" {
pub fn gtk_label_set_line_wrap_mode(label: *mut GtkLabel, wrap_mode: PangoWrapMode);
}
extern "C" {
pub fn gtk_label_get_line_wrap_mode(label: *mut GtkLabel) -> PangoWrapMode;
}
extern "C" {
pub fn gtk_label_set_selectable(label: *mut GtkLabel, setting: gboolean);
}
extern "C" {
pub fn gtk_label_get_selectable(label: *mut GtkLabel) -> gboolean;
}
extern "C" {
pub fn gtk_label_set_angle(label: *mut GtkLabel, angle: gdouble);
}
extern "C" {
pub fn gtk_label_get_angle(label: *mut GtkLabel) -> gdouble;
}
extern "C" {
pub fn gtk_label_select_region(label: *mut GtkLabel, start_offset: gint, end_offset: gint);
}
extern "C" {
pub fn gtk_label_get_selection_bounds(
label: *mut GtkLabel,
start: *mut gint,
end: *mut gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_label_get_layout(label: *mut GtkLabel) -> *mut PangoLayout;
}
extern "C" {
pub fn gtk_label_get_layout_offsets(label: *mut GtkLabel, x: *mut gint, y: *mut gint);
}
extern "C" {
pub fn gtk_label_set_single_line_mode(label: *mut GtkLabel, single_line_mode: gboolean);
}
extern "C" {
pub fn gtk_label_get_single_line_mode(label: *mut GtkLabel) -> gboolean;
}
extern "C" {
pub fn gtk_label_get_current_uri(label: *mut GtkLabel) -> *const gchar;
}
extern "C" {
pub fn gtk_label_set_track_visited_links(label: *mut GtkLabel, track_links: gboolean);
}
extern "C" {
pub fn gtk_label_get_track_visited_links(label: *mut GtkLabel) -> gboolean;
}
#[doc = " GtkAccelLabel:\n\n The #GtkAccelLabel-struct contains private data only, and\n should be accessed using the functions below."]
pub type GtkAccelLabel = _GtkAccelLabel;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAccelLabelPrivate {
_unused: [u8; 0],
}
pub type GtkAccelLabelPrivate = _GtkAccelLabelPrivate;
#[doc = " GtkAccelLabel:\n\n The #GtkAccelLabel-struct contains private data only, and\n should be accessed using the functions below."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAccelLabel {
pub label: GtkLabel,
pub priv_: *mut GtkAccelLabelPrivate,
}
#[test]
fn bindgen_test_layout__GtkAccelLabel() {
const UNINIT: ::std::mem::MaybeUninit<_GtkAccelLabel> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkAccelLabel>(),
56usize,
concat!("Size of: ", stringify!(_GtkAccelLabel))
);
assert_eq!(
::std::mem::align_of::<_GtkAccelLabel>(),
8usize,
concat!("Alignment of ", stringify!(_GtkAccelLabel))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkAccelLabel),
"::",
stringify!(label)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkAccelLabel),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkAccelLabel {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_accel_label_get_type() -> GType;
}
extern "C" {
pub fn gtk_accel_label_new(string: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_accel_label_get_accel_widget(accel_label: *mut GtkAccelLabel) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_accel_label_get_accel_width(accel_label: *mut GtkAccelLabel) -> guint;
}
extern "C" {
pub fn gtk_accel_label_set_accel_widget(
accel_label: *mut GtkAccelLabel,
accel_widget: *mut GtkWidget,
);
}
extern "C" {
pub fn gtk_accel_label_set_accel_closure(
accel_label: *mut GtkAccelLabel,
accel_closure: *mut GClosure,
);
}
extern "C" {
pub fn gtk_accel_label_refetch(accel_label: *mut GtkAccelLabel) -> gboolean;
}
extern "C" {
pub fn gtk_accel_label_set_accel(
accel_label: *mut GtkAccelLabel,
accelerator_key: guint,
accelerator_mods: GdkModifierType,
);
}
extern "C" {
pub fn gtk_accel_label_get_accel(
accel_label: *mut GtkAccelLabel,
accelerator_key: *mut guint,
accelerator_mods: *mut GdkModifierType,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAccelMap {
_unused: [u8; 0],
}
pub type GtkAccelMap = _GtkAccelMap;
#[doc = " GtkAccelMapForeach:\n @data: User data passed to gtk_accel_map_foreach() or\n gtk_accel_map_foreach_unfiltered()\n @accel_path: Accel path of the current accelerator\n @accel_key: Key of the current accelerator\n @accel_mods: Modifiers of the current accelerator\n @changed: Changed flag of the accelerator (if %TRUE, accelerator has changed\n during runtime and would need to be saved during an accelerator dump)"]
pub type GtkAccelMapForeach = ::std::option::Option<
unsafe extern "C" fn(
data: gpointer,
accel_path: *const gchar,
accel_key: guint,
accel_mods: GdkModifierType,
changed: gboolean,
),
>;
extern "C" {
pub fn gtk_accel_map_add_entry(
accel_path: *const gchar,
accel_key: guint,
accel_mods: GdkModifierType,
);
}
extern "C" {
pub fn gtk_accel_map_lookup_entry(accel_path: *const gchar, key: *mut GtkAccelKey) -> gboolean;
}
extern "C" {
pub fn gtk_accel_map_change_entry(
accel_path: *const gchar,
accel_key: guint,
accel_mods: GdkModifierType,
replace: gboolean,
) -> gboolean;
}
extern "C" {
pub fn gtk_accel_map_load(file_name: *const gchar);
}
extern "C" {
pub fn gtk_accel_map_save(file_name: *const gchar);
}
extern "C" {
pub fn gtk_accel_map_foreach(data: gpointer, foreach_func: GtkAccelMapForeach);
}
extern "C" {
pub fn gtk_accel_map_load_fd(fd: gint);
}
extern "C" {
pub fn gtk_accel_map_load_scanner(scanner: *mut GScanner);
}
extern "C" {
pub fn gtk_accel_map_save_fd(fd: gint);
}
extern "C" {
pub fn gtk_accel_map_lock_path(accel_path: *const gchar);
}
extern "C" {
pub fn gtk_accel_map_unlock_path(accel_path: *const gchar);
}
extern "C" {
pub fn gtk_accel_map_add_filter(filter_pattern: *const gchar);
}
extern "C" {
pub fn gtk_accel_map_foreach_unfiltered(data: gpointer, foreach_func: GtkAccelMapForeach);
}
extern "C" {
pub fn gtk_accel_map_get_type() -> GType;
}
extern "C" {
pub fn gtk_accel_map_get() -> *mut GtkAccelMap;
}
pub type GtkAccessible = _GtkAccessible;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAccessiblePrivate {
_unused: [u8; 0],
}
pub type GtkAccessiblePrivate = _GtkAccessiblePrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAccessible {
pub parent: AtkObject,
pub priv_: *mut GtkAccessiblePrivate,
}
#[test]
fn bindgen_test_layout__GtkAccessible() {
const UNINIT: ::std::mem::MaybeUninit<_GtkAccessible> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkAccessible>(),
80usize,
concat!("Size of: ", stringify!(_GtkAccessible))
);
assert_eq!(
::std::mem::align_of::<_GtkAccessible>(),
8usize,
concat!("Alignment of ", stringify!(_GtkAccessible))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkAccessible),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_GtkAccessible),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkAccessible {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_accessible_get_type() -> GType;
}
extern "C" {
pub fn gtk_accessible_set_widget(accessible: *mut GtkAccessible, widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_accessible_get_widget(accessible: *mut GtkAccessible) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_accessible_connect_widget_destroyed(accessible: *mut GtkAccessible);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkActionable {
_unused: [u8; 0],
}
pub type GtkActionable = _GtkActionable;
extern "C" {
pub fn gtk_actionable_get_type() -> GType;
}
extern "C" {
pub fn gtk_actionable_get_action_name(actionable: *mut GtkActionable) -> *const gchar;
}
extern "C" {
pub fn gtk_actionable_set_action_name(
actionable: *mut GtkActionable,
action_name: *const gchar,
);
}
extern "C" {
pub fn gtk_actionable_get_action_target_value(actionable: *mut GtkActionable) -> *mut GVariant;
}
extern "C" {
pub fn gtk_actionable_set_action_target_value(
actionable: *mut GtkActionable,
target_value: *mut GVariant,
);
}
extern "C" {
pub fn gtk_actionable_set_action_target(
actionable: *mut GtkActionable,
format_string: *const gchar,
...
);
}
extern "C" {
pub fn gtk_actionable_set_detailed_action_name(
actionable: *mut GtkActionable,
detailed_action_name: *const gchar,
);
}
pub type GtkActionBar = _GtkActionBar;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkActionBar {
pub bin: GtkBin,
}
#[test]
fn bindgen_test_layout__GtkActionBar() {
const UNINIT: ::std::mem::MaybeUninit<_GtkActionBar> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkActionBar>(),
48usize,
concat!("Size of: ", stringify!(_GtkActionBar))
);
assert_eq!(
::std::mem::align_of::<_GtkActionBar>(),
8usize,
concat!("Alignment of ", stringify!(_GtkActionBar))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bin) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkActionBar),
"::",
stringify!(bin)
)
);
}
impl Default for _GtkActionBar {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_action_bar_get_type() -> GType;
}
extern "C" {
pub fn gtk_action_bar_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_action_bar_get_center_widget(action_bar: *mut GtkActionBar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_action_bar_set_center_widget(
action_bar: *mut GtkActionBar,
center_widget: *mut GtkWidget,
);
}
extern "C" {
pub fn gtk_action_bar_pack_start(action_bar: *mut GtkActionBar, child: *mut GtkWidget);
}
extern "C" {
pub fn gtk_action_bar_pack_end(action_bar: *mut GtkActionBar, child: *mut GtkWidget);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAdjustmentPrivate {
_unused: [u8; 0],
}
pub type GtkAdjustmentPrivate = _GtkAdjustmentPrivate;
#[doc = " GtkAdjustment:\n\n The #GtkAdjustment-struct contains only private fields and\n should not be directly accessed."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAdjustment {
pub parent_instance: GInitiallyUnowned,
pub priv_: *mut GtkAdjustmentPrivate,
}
#[test]
fn bindgen_test_layout__GtkAdjustment() {
const UNINIT: ::std::mem::MaybeUninit<_GtkAdjustment> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkAdjustment>(),
32usize,
concat!("Size of: ", stringify!(_GtkAdjustment))
);
assert_eq!(
::std::mem::align_of::<_GtkAdjustment>(),
8usize,
concat!("Alignment of ", stringify!(_GtkAdjustment))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkAdjustment),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkAdjustment),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkAdjustment {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_adjustment_get_type() -> GType;
}
extern "C" {
pub fn gtk_adjustment_new(
value: gdouble,
lower: gdouble,
upper: gdouble,
step_increment: gdouble,
page_increment: gdouble,
page_size: gdouble,
) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_adjustment_changed(adjustment: *mut GtkAdjustment);
}
extern "C" {
pub fn gtk_adjustment_value_changed(adjustment: *mut GtkAdjustment);
}
extern "C" {
pub fn gtk_adjustment_clamp_page(
adjustment: *mut GtkAdjustment,
lower: gdouble,
upper: gdouble,
);
}
extern "C" {
pub fn gtk_adjustment_get_value(adjustment: *mut GtkAdjustment) -> gdouble;
}
extern "C" {
pub fn gtk_adjustment_set_value(adjustment: *mut GtkAdjustment, value: gdouble);
}
extern "C" {
pub fn gtk_adjustment_get_lower(adjustment: *mut GtkAdjustment) -> gdouble;
}
extern "C" {
pub fn gtk_adjustment_set_lower(adjustment: *mut GtkAdjustment, lower: gdouble);
}
extern "C" {
pub fn gtk_adjustment_get_upper(adjustment: *mut GtkAdjustment) -> gdouble;
}
extern "C" {
pub fn gtk_adjustment_set_upper(adjustment: *mut GtkAdjustment, upper: gdouble);
}
extern "C" {
pub fn gtk_adjustment_get_step_increment(adjustment: *mut GtkAdjustment) -> gdouble;
}
extern "C" {
pub fn gtk_adjustment_set_step_increment(
adjustment: *mut GtkAdjustment,
step_increment: gdouble,
);
}
extern "C" {
pub fn gtk_adjustment_get_page_increment(adjustment: *mut GtkAdjustment) -> gdouble;
}
extern "C" {
pub fn gtk_adjustment_set_page_increment(
adjustment: *mut GtkAdjustment,
page_increment: gdouble,
);
}
extern "C" {
pub fn gtk_adjustment_get_page_size(adjustment: *mut GtkAdjustment) -> gdouble;
}
extern "C" {
pub fn gtk_adjustment_set_page_size(adjustment: *mut GtkAdjustment, page_size: gdouble);
}
extern "C" {
pub fn gtk_adjustment_configure(
adjustment: *mut GtkAdjustment,
value: gdouble,
lower: gdouble,
upper: gdouble,
step_increment: gdouble,
page_increment: gdouble,
page_size: gdouble,
);
}
extern "C" {
pub fn gtk_adjustment_get_minimum_increment(adjustment: *mut GtkAdjustment) -> gdouble;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAppChooser {
_unused: [u8; 0],
}
pub type GtkAppChooser = _GtkAppChooser;
extern "C" {
pub fn gtk_app_chooser_get_type() -> GType;
}
extern "C" {
pub fn gtk_app_chooser_get_app_info(self_: *mut GtkAppChooser) -> *mut GAppInfo;
}
extern "C" {
pub fn gtk_app_chooser_get_content_type(self_: *mut GtkAppChooser) -> *mut gchar;
}
extern "C" {
pub fn gtk_app_chooser_refresh(self_: *mut GtkAppChooser);
}
pub type GtkAppChooserDialog = _GtkAppChooserDialog;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAppChooserDialogPrivate {
_unused: [u8; 0],
}
pub type GtkAppChooserDialogPrivate = _GtkAppChooserDialogPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAppChooserDialog {
pub parent: GtkDialog,
pub priv_: *mut GtkAppChooserDialogPrivate,
}
#[test]
fn bindgen_test_layout__GtkAppChooserDialog() {
const UNINIT: ::std::mem::MaybeUninit<_GtkAppChooserDialog> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkAppChooserDialog>(),
72usize,
concat!("Size of: ", stringify!(_GtkAppChooserDialog))
);
assert_eq!(
::std::mem::align_of::<_GtkAppChooserDialog>(),
8usize,
concat!("Alignment of ", stringify!(_GtkAppChooserDialog))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkAppChooserDialog),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GtkAppChooserDialog),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkAppChooserDialog {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_app_chooser_dialog_get_type() -> GType;
}
extern "C" {
pub fn gtk_app_chooser_dialog_new(
parent: *mut GtkWindow,
flags: GtkDialogFlags,
file: *mut GFile,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_app_chooser_dialog_new_for_content_type(
parent: *mut GtkWindow,
flags: GtkDialogFlags,
content_type: *const gchar,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_app_chooser_dialog_get_widget(self_: *mut GtkAppChooserDialog) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_app_chooser_dialog_set_heading(
self_: *mut GtkAppChooserDialog,
heading: *const gchar,
);
}
extern "C" {
pub fn gtk_app_chooser_dialog_get_heading(self_: *mut GtkAppChooserDialog) -> *const gchar;
}
pub type GtkBox = _GtkBox;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkBoxPrivate {
_unused: [u8; 0],
}
pub type GtkBoxPrivate = _GtkBoxPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkBox {
pub container: GtkContainer,
pub priv_: *mut GtkBoxPrivate,
}
#[test]
fn bindgen_test_layout__GtkBox() {
const UNINIT: ::std::mem::MaybeUninit<_GtkBox> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkBox>(),
48usize,
concat!("Size of: ", stringify!(_GtkBox))
);
assert_eq!(
::std::mem::align_of::<_GtkBox>(),
8usize,
concat!("Alignment of ", stringify!(_GtkBox))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).container) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkBox),
"::",
stringify!(container)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkBox),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkBox {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_box_get_type() -> GType;
}
extern "C" {
pub fn gtk_box_new(orientation: GtkOrientation, spacing: gint) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_box_pack_start(
box_: *mut GtkBox,
child: *mut GtkWidget,
expand: gboolean,
fill: gboolean,
padding: guint,
);
}
extern "C" {
pub fn gtk_box_pack_end(
box_: *mut GtkBox,
child: *mut GtkWidget,
expand: gboolean,
fill: gboolean,
padding: guint,
);
}
extern "C" {
pub fn gtk_box_set_homogeneous(box_: *mut GtkBox, homogeneous: gboolean);
}
extern "C" {
pub fn gtk_box_get_homogeneous(box_: *mut GtkBox) -> gboolean;
}
extern "C" {
pub fn gtk_box_set_spacing(box_: *mut GtkBox, spacing: gint);
}
extern "C" {
pub fn gtk_box_get_spacing(box_: *mut GtkBox) -> gint;
}
extern "C" {
pub fn gtk_box_set_baseline_position(box_: *mut GtkBox, position: GtkBaselinePosition);
}
extern "C" {
pub fn gtk_box_get_baseline_position(box_: *mut GtkBox) -> GtkBaselinePosition;
}
extern "C" {
pub fn gtk_box_reorder_child(box_: *mut GtkBox, child: *mut GtkWidget, position: gint);
}
extern "C" {
pub fn gtk_box_query_child_packing(
box_: *mut GtkBox,
child: *mut GtkWidget,
expand: *mut gboolean,
fill: *mut gboolean,
padding: *mut guint,
pack_type: *mut GtkPackType,
);
}
extern "C" {
pub fn gtk_box_set_child_packing(
box_: *mut GtkBox,
child: *mut GtkWidget,
expand: gboolean,
fill: gboolean,
padding: guint,
pack_type: GtkPackType,
);
}
extern "C" {
pub fn gtk_box_set_center_widget(box_: *mut GtkBox, widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_box_get_center_widget(box_: *mut GtkBox) -> *mut GtkWidget;
}
pub type GtkAppChooserWidget = _GtkAppChooserWidget;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAppChooserWidgetPrivate {
_unused: [u8; 0],
}
pub type GtkAppChooserWidgetPrivate = _GtkAppChooserWidgetPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAppChooserWidget {
pub parent: GtkBox,
pub priv_: *mut GtkAppChooserWidgetPrivate,
}
#[test]
fn bindgen_test_layout__GtkAppChooserWidget() {
const UNINIT: ::std::mem::MaybeUninit<_GtkAppChooserWidget> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkAppChooserWidget>(),
56usize,
concat!("Size of: ", stringify!(_GtkAppChooserWidget))
);
assert_eq!(
::std::mem::align_of::<_GtkAppChooserWidget>(),
8usize,
concat!("Alignment of ", stringify!(_GtkAppChooserWidget))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkAppChooserWidget),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkAppChooserWidget),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkAppChooserWidget {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_app_chooser_widget_get_type() -> GType;
}
extern "C" {
pub fn gtk_app_chooser_widget_new(content_type: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_app_chooser_widget_set_show_default(
self_: *mut GtkAppChooserWidget,
setting: gboolean,
);
}
extern "C" {
pub fn gtk_app_chooser_widget_get_show_default(self_: *mut GtkAppChooserWidget) -> gboolean;
}
extern "C" {
pub fn gtk_app_chooser_widget_set_show_recommended(
self_: *mut GtkAppChooserWidget,
setting: gboolean,
);
}
extern "C" {
pub fn gtk_app_chooser_widget_get_show_recommended(self_: *mut GtkAppChooserWidget)
-> gboolean;
}
extern "C" {
pub fn gtk_app_chooser_widget_set_show_fallback(
self_: *mut GtkAppChooserWidget,
setting: gboolean,
);
}
extern "C" {
pub fn gtk_app_chooser_widget_get_show_fallback(self_: *mut GtkAppChooserWidget) -> gboolean;
}
extern "C" {
pub fn gtk_app_chooser_widget_set_show_other(
self_: *mut GtkAppChooserWidget,
setting: gboolean,
);
}
extern "C" {
pub fn gtk_app_chooser_widget_get_show_other(self_: *mut GtkAppChooserWidget) -> gboolean;
}
extern "C" {
pub fn gtk_app_chooser_widget_set_show_all(self_: *mut GtkAppChooserWidget, setting: gboolean);
}
extern "C" {
pub fn gtk_app_chooser_widget_get_show_all(self_: *mut GtkAppChooserWidget) -> gboolean;
}
extern "C" {
pub fn gtk_app_chooser_widget_set_default_text(
self_: *mut GtkAppChooserWidget,
text: *const gchar,
);
}
extern "C" {
pub fn gtk_app_chooser_widget_get_default_text(self_: *mut GtkAppChooserWidget)
-> *const gchar;
}
#[doc = " GtkTreeIter:\n @stamp: a unique stamp to catch invalid iterators\n @user_data: model-specific data\n @user_data2: model-specific data\n @user_data3: model-specific data\n\n The #GtkTreeIter is the primary structure\n for accessing a #GtkTreeModel. Models are expected to put a unique\n integer in the @stamp member, and put\n model-specific data in the three @user_data\n members."]
pub type GtkTreeIter = _GtkTreeIter;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreePath {
_unused: [u8; 0],
}
pub type GtkTreePath = _GtkTreePath;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeRowReference {
_unused: [u8; 0],
}
pub type GtkTreeRowReference = _GtkTreeRowReference;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeModel {
_unused: [u8; 0],
}
pub type GtkTreeModel = _GtkTreeModel;
#[doc = " GtkTreeModelForeachFunc:\n @model: the #GtkTreeModel being iterated\n @path: the current #GtkTreePath\n @iter: the current #GtkTreeIter\n @data: (closure): The user data passed to gtk_tree_model_foreach()\n\n Type of the callback passed to gtk_tree_model_foreach() to\n iterate over the rows in a tree model.\n\n Returns: %TRUE to stop iterating, %FALSE to continue\n"]
pub type GtkTreeModelForeachFunc = ::std::option::Option<
unsafe extern "C" fn(
model: *mut GtkTreeModel,
path: *mut GtkTreePath,
iter: *mut GtkTreeIter,
data: gpointer,
) -> gboolean,
>;
pub const GtkTreeModelFlags_GTK_TREE_MODEL_ITERS_PERSIST: GtkTreeModelFlags = 1;
pub const GtkTreeModelFlags_GTK_TREE_MODEL_LIST_ONLY: GtkTreeModelFlags = 2;
#[doc = " GtkTreeModelFlags:\n @GTK_TREE_MODEL_ITERS_PERSIST: iterators survive all signals\n emitted by the tree\n @GTK_TREE_MODEL_LIST_ONLY: the model is a list only, and never\n has children\n\n These flags indicate various properties of a #GtkTreeModel.\n\n They are returned by gtk_tree_model_get_flags(), and must be\n static for the lifetime of the object. A more complete description\n of #GTK_TREE_MODEL_ITERS_PERSIST can be found in the overview of\n this section."]
pub type GtkTreeModelFlags = ::std::os::raw::c_uint;
#[doc = " GtkTreeIter:\n @stamp: a unique stamp to catch invalid iterators\n @user_data: model-specific data\n @user_data2: model-specific data\n @user_data3: model-specific data\n\n The #GtkTreeIter is the primary structure\n for accessing a #GtkTreeModel. Models are expected to put a unique\n integer in the @stamp member, and put\n model-specific data in the three @user_data\n members."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeIter {
pub stamp: gint,
pub user_data: gpointer,
pub user_data2: gpointer,
pub user_data3: gpointer,
}
#[test]
fn bindgen_test_layout__GtkTreeIter() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTreeIter> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTreeIter>(),
32usize,
concat!("Size of: ", stringify!(_GtkTreeIter))
);
assert_eq!(
::std::mem::align_of::<_GtkTreeIter>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTreeIter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stamp) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeIter),
"::",
stringify!(stamp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).user_data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeIter),
"::",
stringify!(user_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).user_data2) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeIter),
"::",
stringify!(user_data2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).user_data3) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeIter),
"::",
stringify!(user_data3)
)
);
}
impl Default for _GtkTreeIter {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_tree_path_new() -> *mut GtkTreePath;
}
extern "C" {
pub fn gtk_tree_path_new_from_string(path: *const gchar) -> *mut GtkTreePath;
}
extern "C" {
pub fn gtk_tree_path_new_from_indices(first_index: gint, ...) -> *mut GtkTreePath;
}
extern "C" {
pub fn gtk_tree_path_new_from_indicesv(indices: *mut gint, length: gsize) -> *mut GtkTreePath;
}
extern "C" {
pub fn gtk_tree_path_to_string(path: *mut GtkTreePath) -> *mut gchar;
}
extern "C" {
pub fn gtk_tree_path_new_first() -> *mut GtkTreePath;
}
extern "C" {
pub fn gtk_tree_path_append_index(path: *mut GtkTreePath, index_: gint);
}
extern "C" {
pub fn gtk_tree_path_prepend_index(path: *mut GtkTreePath, index_: gint);
}
extern "C" {
pub fn gtk_tree_path_get_depth(path: *mut GtkTreePath) -> gint;
}
extern "C" {
pub fn gtk_tree_path_get_indices(path: *mut GtkTreePath) -> *mut gint;
}
extern "C" {
pub fn gtk_tree_path_get_indices_with_depth(
path: *mut GtkTreePath,
depth: *mut gint,
) -> *mut gint;
}
extern "C" {
pub fn gtk_tree_path_free(path: *mut GtkTreePath);
}
extern "C" {
pub fn gtk_tree_path_copy(path: *const GtkTreePath) -> *mut GtkTreePath;
}
extern "C" {
pub fn gtk_tree_path_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_path_compare(a: *const GtkTreePath, b: *const GtkTreePath) -> gint;
}
extern "C" {
pub fn gtk_tree_path_next(path: *mut GtkTreePath);
}
extern "C" {
pub fn gtk_tree_path_prev(path: *mut GtkTreePath) -> gboolean;
}
extern "C" {
pub fn gtk_tree_path_up(path: *mut GtkTreePath) -> gboolean;
}
extern "C" {
pub fn gtk_tree_path_down(path: *mut GtkTreePath);
}
extern "C" {
pub fn gtk_tree_path_is_ancestor(
path: *mut GtkTreePath,
descendant: *mut GtkTreePath,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_path_is_descendant(
path: *mut GtkTreePath,
ancestor: *mut GtkTreePath,
) -> gboolean;
}
extern "C" {
#[doc = " GtkTreeRowReference:\n\n A GtkTreeRowReference tracks model changes so that it always refers to the\n same row (a #GtkTreePath refers to a position, not a fixed row). Create a\n new GtkTreeRowReference with gtk_tree_row_reference_new()."]
pub fn gtk_tree_row_reference_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_row_reference_new(
model: *mut GtkTreeModel,
path: *mut GtkTreePath,
) -> *mut GtkTreeRowReference;
}
extern "C" {
pub fn gtk_tree_row_reference_new_proxy(
proxy: *mut GObject,
model: *mut GtkTreeModel,
path: *mut GtkTreePath,
) -> *mut GtkTreeRowReference;
}
extern "C" {
pub fn gtk_tree_row_reference_get_path(reference: *mut GtkTreeRowReference)
-> *mut GtkTreePath;
}
extern "C" {
pub fn gtk_tree_row_reference_get_model(
reference: *mut GtkTreeRowReference,
) -> *mut GtkTreeModel;
}
extern "C" {
pub fn gtk_tree_row_reference_valid(reference: *mut GtkTreeRowReference) -> gboolean;
}
extern "C" {
pub fn gtk_tree_row_reference_copy(
reference: *mut GtkTreeRowReference,
) -> *mut GtkTreeRowReference;
}
extern "C" {
pub fn gtk_tree_row_reference_free(reference: *mut GtkTreeRowReference);
}
extern "C" {
pub fn gtk_tree_row_reference_inserted(proxy: *mut GObject, path: *mut GtkTreePath);
}
extern "C" {
pub fn gtk_tree_row_reference_deleted(proxy: *mut GObject, path: *mut GtkTreePath);
}
extern "C" {
pub fn gtk_tree_row_reference_reordered(
proxy: *mut GObject,
path: *mut GtkTreePath,
iter: *mut GtkTreeIter,
new_order: *mut gint,
);
}
extern "C" {
pub fn gtk_tree_iter_copy(iter: *mut GtkTreeIter) -> *mut GtkTreeIter;
}
extern "C" {
pub fn gtk_tree_iter_free(iter: *mut GtkTreeIter);
}
extern "C" {
pub fn gtk_tree_iter_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_model_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_model_get_flags(tree_model: *mut GtkTreeModel) -> GtkTreeModelFlags;
}
extern "C" {
pub fn gtk_tree_model_get_n_columns(tree_model: *mut GtkTreeModel) -> gint;
}
extern "C" {
pub fn gtk_tree_model_get_column_type(tree_model: *mut GtkTreeModel, index_: gint) -> GType;
}
extern "C" {
pub fn gtk_tree_model_get_iter(
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
path: *mut GtkTreePath,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_model_get_iter_from_string(
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
path_string: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_model_get_string_from_iter(
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_tree_model_get_iter_first(
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_model_get_path(
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
) -> *mut GtkTreePath;
}
extern "C" {
pub fn gtk_tree_model_get_value(
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
column: gint,
value: *mut GValue,
);
}
extern "C" {
pub fn gtk_tree_model_iter_previous(
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_model_iter_next(
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_model_iter_children(
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
parent: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_model_iter_has_child(
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_model_iter_n_children(
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
) -> gint;
}
extern "C" {
pub fn gtk_tree_model_iter_nth_child(
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
parent: *mut GtkTreeIter,
n: gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_model_iter_parent(
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
child: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_model_ref_node(tree_model: *mut GtkTreeModel, iter: *mut GtkTreeIter);
}
extern "C" {
pub fn gtk_tree_model_unref_node(tree_model: *mut GtkTreeModel, iter: *mut GtkTreeIter);
}
extern "C" {
pub fn gtk_tree_model_get(tree_model: *mut GtkTreeModel, iter: *mut GtkTreeIter, ...);
}
extern "C" {
pub fn gtk_tree_model_foreach(
model: *mut GtkTreeModel,
func: GtkTreeModelForeachFunc,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_tree_model_row_changed(
tree_model: *mut GtkTreeModel,
path: *mut GtkTreePath,
iter: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_tree_model_row_inserted(
tree_model: *mut GtkTreeModel,
path: *mut GtkTreePath,
iter: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_tree_model_row_has_child_toggled(
tree_model: *mut GtkTreeModel,
path: *mut GtkTreePath,
iter: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_tree_model_row_deleted(tree_model: *mut GtkTreeModel, path: *mut GtkTreePath);
}
extern "C" {
pub fn gtk_tree_model_rows_reordered(
tree_model: *mut GtkTreeModel,
path: *mut GtkTreePath,
iter: *mut GtkTreeIter,
new_order: *mut gint,
);
}
extern "C" {
pub fn gtk_tree_model_rows_reordered_with_length(
tree_model: *mut GtkTreeModel,
path: *mut GtkTreePath,
iter: *mut GtkTreeIter,
new_order: *mut gint,
length: gint,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellEditable {
_unused: [u8; 0],
}
pub type GtkCellEditable = _GtkCellEditable;
extern "C" {
pub fn gtk_cell_editable_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_editable_start_editing(
cell_editable: *mut GtkCellEditable,
event: *mut GdkEvent,
);
}
extern "C" {
pub fn gtk_cell_editable_editing_done(cell_editable: *mut GtkCellEditable);
}
extern "C" {
pub fn gtk_cell_editable_remove_widget(cell_editable: *mut GtkCellEditable);
}
pub const GtkCellRendererState_GTK_CELL_RENDERER_SELECTED: GtkCellRendererState = 1;
pub const GtkCellRendererState_GTK_CELL_RENDERER_PRELIT: GtkCellRendererState = 2;
pub const GtkCellRendererState_GTK_CELL_RENDERER_INSENSITIVE: GtkCellRendererState = 4;
pub const GtkCellRendererState_GTK_CELL_RENDERER_SORTED: GtkCellRendererState = 8;
pub const GtkCellRendererState_GTK_CELL_RENDERER_FOCUSED: GtkCellRendererState = 16;
pub const GtkCellRendererState_GTK_CELL_RENDERER_EXPANDABLE: GtkCellRendererState = 32;
pub const GtkCellRendererState_GTK_CELL_RENDERER_EXPANDED: GtkCellRendererState = 64;
#[doc = " GtkCellRendererState:\n @GTK_CELL_RENDERER_SELECTED: The cell is currently selected, and\n probably has a selection colored background to render to.\n @GTK_CELL_RENDERER_PRELIT: The mouse is hovering over the cell.\n @GTK_CELL_RENDERER_INSENSITIVE: The cell is drawn in an insensitive manner\n @GTK_CELL_RENDERER_SORTED: The cell is in a sorted row\n @GTK_CELL_RENDERER_FOCUSED: The cell is in the focus row.\n @GTK_CELL_RENDERER_EXPANDABLE: The cell is in a row that can be expanded. Since 3.4\n @GTK_CELL_RENDERER_EXPANDED: The cell is in a row that is expanded. Since 3.4\n\n Tells how a cell is to be rendered."]
pub type GtkCellRendererState = ::std::os::raw::c_uint;
pub type GtkCellRenderer = _GtkCellRenderer;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellRendererPrivate {
_unused: [u8; 0],
}
pub type GtkCellRendererPrivate = _GtkCellRendererPrivate;
#[doc = " GtkCellRendererClass:\n @get_request_mode: Called to gets whether the cell renderer prefers\n a height-for-width layout or a width-for-height layout.\n @get_preferred_width: Called to get a renderer’s natural width.\n @get_preferred_height_for_width: Called to get a renderer’s natural height for width.\n @get_preferred_height: Called to get a renderer’s natural height.\n @get_preferred_width_for_height: Called to get a renderer’s natural width for height.\n @get_aligned_area: Called to get the aligned area used by @cell inside @cell_area.\n @get_size: Called to get the width and height needed to render the cell. Deprecated: 3.0.\n @render: Called to render the content of the #GtkCellRenderer.\n @activate: Called to activate the content of the #GtkCellRenderer.\n @start_editing: Called to initiate editing the content of the #GtkCellRenderer.\n @editing_canceled: Signal gets emitted when the user cancels the process of editing a cell.\n @editing_started: Signal gets emitted when a cell starts to be edited."]
pub type GtkCellRendererClass = _GtkCellRendererClass;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellRendererClassPrivate {
_unused: [u8; 0],
}
pub type GtkCellRendererClassPrivate = _GtkCellRendererClassPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellRenderer {
pub parent_instance: GInitiallyUnowned,
pub priv_: *mut GtkCellRendererPrivate,
}
#[test]
fn bindgen_test_layout__GtkCellRenderer() {
const UNINIT: ::std::mem::MaybeUninit<_GtkCellRenderer> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkCellRenderer>(),
32usize,
concat!("Size of: ", stringify!(_GtkCellRenderer))
);
assert_eq!(
::std::mem::align_of::<_GtkCellRenderer>(),
8usize,
concat!("Alignment of ", stringify!(_GtkCellRenderer))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRenderer),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRenderer),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkCellRenderer {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GtkCellRendererClass:\n @get_request_mode: Called to gets whether the cell renderer prefers\n a height-for-width layout or a width-for-height layout.\n @get_preferred_width: Called to get a renderer’s natural width.\n @get_preferred_height_for_width: Called to get a renderer’s natural height for width.\n @get_preferred_height: Called to get a renderer’s natural height.\n @get_preferred_width_for_height: Called to get a renderer’s natural width for height.\n @get_aligned_area: Called to get the aligned area used by @cell inside @cell_area.\n @get_size: Called to get the width and height needed to render the cell. Deprecated: 3.0.\n @render: Called to render the content of the #GtkCellRenderer.\n @activate: Called to activate the content of the #GtkCellRenderer.\n @start_editing: Called to initiate editing the content of the #GtkCellRenderer.\n @editing_canceled: Signal gets emitted when the user cancels the process of editing a cell.\n @editing_started: Signal gets emitted when a cell starts to be edited."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellRendererClass {
pub parent_class: GInitiallyUnownedClass,
pub get_request_mode: ::std::option::Option<
unsafe extern "C" fn(cell: *mut GtkCellRenderer) -> GtkSizeRequestMode,
>,
pub get_preferred_width: ::std::option::Option<
unsafe extern "C" fn(
cell: *mut GtkCellRenderer,
widget: *mut GtkWidget,
minimum_size: *mut gint,
natural_size: *mut gint,
),
>,
pub get_preferred_height_for_width: ::std::option::Option<
unsafe extern "C" fn(
cell: *mut GtkCellRenderer,
widget: *mut GtkWidget,
width: gint,
minimum_height: *mut gint,
natural_height: *mut gint,
),
>,
pub get_preferred_height: ::std::option::Option<
unsafe extern "C" fn(
cell: *mut GtkCellRenderer,
widget: *mut GtkWidget,
minimum_size: *mut gint,
natural_size: *mut gint,
),
>,
pub get_preferred_width_for_height: ::std::option::Option<
unsafe extern "C" fn(
cell: *mut GtkCellRenderer,
widget: *mut GtkWidget,
height: gint,
minimum_width: *mut gint,
natural_width: *mut gint,
),
>,
pub get_aligned_area: ::std::option::Option<
unsafe extern "C" fn(
cell: *mut GtkCellRenderer,
widget: *mut GtkWidget,
flags: GtkCellRendererState,
cell_area: *const GdkRectangle,
aligned_area: *mut GdkRectangle,
),
>,
pub get_size: ::std::option::Option<
unsafe extern "C" fn(
cell: *mut GtkCellRenderer,
widget: *mut GtkWidget,
cell_area: *const GdkRectangle,
x_offset: *mut gint,
y_offset: *mut gint,
width: *mut gint,
height: *mut gint,
),
>,
pub render: ::std::option::Option<
unsafe extern "C" fn(
cell: *mut GtkCellRenderer,
cr: *mut cairo_t,
widget: *mut GtkWidget,
background_area: *const GdkRectangle,
cell_area: *const GdkRectangle,
flags: GtkCellRendererState,
),
>,
pub activate: ::std::option::Option<
unsafe extern "C" fn(
cell: *mut GtkCellRenderer,
event: *mut GdkEvent,
widget: *mut GtkWidget,
path: *const gchar,
background_area: *const GdkRectangle,
cell_area: *const GdkRectangle,
flags: GtkCellRendererState,
) -> gboolean,
>,
pub start_editing: ::std::option::Option<
unsafe extern "C" fn(
cell: *mut GtkCellRenderer,
event: *mut GdkEvent,
widget: *mut GtkWidget,
path: *const gchar,
background_area: *const GdkRectangle,
cell_area: *const GdkRectangle,
flags: GtkCellRendererState,
) -> *mut GtkCellEditable,
>,
pub editing_canceled: ::std::option::Option<unsafe extern "C" fn(cell: *mut GtkCellRenderer)>,
pub editing_started: ::std::option::Option<
unsafe extern "C" fn(
cell: *mut GtkCellRenderer,
editable: *mut GtkCellEditable,
path: *const gchar,
),
>,
pub priv_: *mut GtkCellRendererClassPrivate,
pub _gtk_reserved2: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved3: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved4: ::std::option::Option<unsafe extern "C" fn()>,
}
#[test]
fn bindgen_test_layout__GtkCellRendererClass() {
const UNINIT: ::std::mem::MaybeUninit<_GtkCellRendererClass> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkCellRendererClass>(),
264usize,
concat!("Size of: ", stringify!(_GtkCellRendererClass))
);
assert_eq!(
::std::mem::align_of::<_GtkCellRendererClass>(),
8usize,
concat!("Alignment of ", stringify!(_GtkCellRendererClass))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_class) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(parent_class)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_request_mode) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(get_request_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_preferred_width) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(get_preferred_width)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).get_preferred_height_for_width) as usize - ptr as usize
},
152usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(get_preferred_height_for_width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_preferred_height) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(get_preferred_height)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).get_preferred_width_for_height) as usize - ptr as usize
},
168usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(get_preferred_width_for_height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_aligned_area) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(get_aligned_area)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_size) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(get_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).render) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(render)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).activate) as usize - ptr as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(activate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).start_editing) as usize - ptr as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(start_editing)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).editing_canceled) as usize - ptr as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(editing_canceled)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).editing_started) as usize - ptr as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(editing_started)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(priv_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved2) as usize - ptr as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(_gtk_reserved2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved3) as usize - ptr as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(_gtk_reserved3)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved4) as usize - ptr as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererClass),
"::",
stringify!(_gtk_reserved4)
)
);
}
impl Default for _GtkCellRendererClass {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_cell_renderer_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_renderer_get_request_mode(cell: *mut GtkCellRenderer) -> GtkSizeRequestMode;
}
extern "C" {
pub fn gtk_cell_renderer_get_preferred_width(
cell: *mut GtkCellRenderer,
widget: *mut GtkWidget,
minimum_size: *mut gint,
natural_size: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_renderer_get_preferred_height_for_width(
cell: *mut GtkCellRenderer,
widget: *mut GtkWidget,
width: gint,
minimum_height: *mut gint,
natural_height: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_renderer_get_preferred_height(
cell: *mut GtkCellRenderer,
widget: *mut GtkWidget,
minimum_size: *mut gint,
natural_size: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_renderer_get_preferred_width_for_height(
cell: *mut GtkCellRenderer,
widget: *mut GtkWidget,
height: gint,
minimum_width: *mut gint,
natural_width: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_renderer_get_preferred_size(
cell: *mut GtkCellRenderer,
widget: *mut GtkWidget,
minimum_size: *mut GtkRequisition,
natural_size: *mut GtkRequisition,
);
}
extern "C" {
pub fn gtk_cell_renderer_get_aligned_area(
cell: *mut GtkCellRenderer,
widget: *mut GtkWidget,
flags: GtkCellRendererState,
cell_area: *const GdkRectangle,
aligned_area: *mut GdkRectangle,
);
}
extern "C" {
pub fn gtk_cell_renderer_get_size(
cell: *mut GtkCellRenderer,
widget: *mut GtkWidget,
cell_area: *const GdkRectangle,
x_offset: *mut gint,
y_offset: *mut gint,
width: *mut gint,
height: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_renderer_render(
cell: *mut GtkCellRenderer,
cr: *mut cairo_t,
widget: *mut GtkWidget,
background_area: *const GdkRectangle,
cell_area: *const GdkRectangle,
flags: GtkCellRendererState,
);
}
extern "C" {
pub fn gtk_cell_renderer_activate(
cell: *mut GtkCellRenderer,
event: *mut GdkEvent,
widget: *mut GtkWidget,
path: *const gchar,
background_area: *const GdkRectangle,
cell_area: *const GdkRectangle,
flags: GtkCellRendererState,
) -> gboolean;
}
extern "C" {
pub fn gtk_cell_renderer_start_editing(
cell: *mut GtkCellRenderer,
event: *mut GdkEvent,
widget: *mut GtkWidget,
path: *const gchar,
background_area: *const GdkRectangle,
cell_area: *const GdkRectangle,
flags: GtkCellRendererState,
) -> *mut GtkCellEditable;
}
extern "C" {
pub fn gtk_cell_renderer_set_fixed_size(cell: *mut GtkCellRenderer, width: gint, height: gint);
}
extern "C" {
pub fn gtk_cell_renderer_get_fixed_size(
cell: *mut GtkCellRenderer,
width: *mut gint,
height: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_renderer_set_alignment(
cell: *mut GtkCellRenderer,
xalign: gfloat,
yalign: gfloat,
);
}
extern "C" {
pub fn gtk_cell_renderer_get_alignment(
cell: *mut GtkCellRenderer,
xalign: *mut gfloat,
yalign: *mut gfloat,
);
}
extern "C" {
pub fn gtk_cell_renderer_set_padding(cell: *mut GtkCellRenderer, xpad: gint, ypad: gint);
}
extern "C" {
pub fn gtk_cell_renderer_get_padding(
cell: *mut GtkCellRenderer,
xpad: *mut gint,
ypad: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_renderer_set_visible(cell: *mut GtkCellRenderer, visible: gboolean);
}
extern "C" {
pub fn gtk_cell_renderer_get_visible(cell: *mut GtkCellRenderer) -> gboolean;
}
extern "C" {
pub fn gtk_cell_renderer_set_sensitive(cell: *mut GtkCellRenderer, sensitive: gboolean);
}
extern "C" {
pub fn gtk_cell_renderer_get_sensitive(cell: *mut GtkCellRenderer) -> gboolean;
}
extern "C" {
pub fn gtk_cell_renderer_is_activatable(cell: *mut GtkCellRenderer) -> gboolean;
}
extern "C" {
pub fn gtk_cell_renderer_stop_editing(cell: *mut GtkCellRenderer, canceled: gboolean);
}
extern "C" {
pub fn gtk_cell_renderer_get_state(
cell: *mut GtkCellRenderer,
widget: *mut GtkWidget,
cell_state: GtkCellRendererState,
) -> GtkStateFlags;
}
extern "C" {
pub fn gtk_cell_renderer_class_set_accessible_type(
renderer_class: *mut GtkCellRendererClass,
type_: GType,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeSortable {
_unused: [u8; 0],
}
pub type GtkTreeSortable = _GtkTreeSortable;
#[doc = " GtkTreeIterCompareFunc:\n @model: The #GtkTreeModel the comparison is within\n @a: A #GtkTreeIter in @model\n @b: Another #GtkTreeIter in @model\n @user_data: Data passed when the compare func is assigned e.g. by\n gtk_tree_sortable_set_sort_func()\n\n A GtkTreeIterCompareFunc should return a negative integer, zero, or a positive\n integer if @a sorts before @b, @a sorts with @b, or @a sorts after @b\n respectively. If two iters compare as equal, their order in the sorted model\n is undefined. In order to ensure that the #GtkTreeSortable behaves as\n expected, the GtkTreeIterCompareFunc must define a partial order on\n the model, i.e. it must be reflexive, antisymmetric and transitive.\n\n For example, if @model is a product catalogue, then a compare function\n for the “price” column could be one which returns\n `price_of(@a) - price_of(@b)`.\n\n Returns: a negative integer, zero or a positive integer depending on whether\n @a sorts before, with or after @b"]
pub type GtkTreeIterCompareFunc = ::std::option::Option<
unsafe extern "C" fn(
model: *mut GtkTreeModel,
a: *mut GtkTreeIter,
b: *mut GtkTreeIter,
user_data: gpointer,
) -> gint,
>;
extern "C" {
pub fn gtk_tree_sortable_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_sortable_sort_column_changed(sortable: *mut GtkTreeSortable);
}
extern "C" {
pub fn gtk_tree_sortable_get_sort_column_id(
sortable: *mut GtkTreeSortable,
sort_column_id: *mut gint,
order: *mut GtkSortType,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_sortable_set_sort_column_id(
sortable: *mut GtkTreeSortable,
sort_column_id: gint,
order: GtkSortType,
);
}
extern "C" {
pub fn gtk_tree_sortable_set_sort_func(
sortable: *mut GtkTreeSortable,
sort_column_id: gint,
sort_func: GtkTreeIterCompareFunc,
user_data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_tree_sortable_set_default_sort_func(
sortable: *mut GtkTreeSortable,
sort_func: GtkTreeIterCompareFunc,
user_data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_tree_sortable_has_default_sort_func(sortable: *mut GtkTreeSortable) -> gboolean;
}
pub type GtkCellArea = _GtkCellArea;
#[doc = " GtkCellAreaClass:\n @add: adds a #GtkCellRenderer to the area.\n @remove: removes a #GtkCellRenderer from the area.\n @foreach: calls the #GtkCellCallback function on every #GtkCellRenderer in\n the area with the provided user data until the callback returns %TRUE.\n @foreach_alloc: Calls the #GtkCellAllocCallback function on every\n #GtkCellRenderer in the area with the allocated area for the cell\n and the provided user data until the callback returns %TRUE.\n @event: Handle an event in the area, this is generally used to activate\n a cell at the event location for button events but can also be used\n to generically pass events to #GtkWidgets drawn onto the area.\n @render: Actually render the area’s cells to the specified rectangle,\n @background_area should be correctly distributed to the cells\n corresponding background areas.\n @apply_attributes: Apply the cell attributes to the cells. This is\n implemented as a signal and generally #GtkCellArea subclasses don't\n need to implement it since it is handled by the base class.\n @create_context: Creates and returns a class specific #GtkCellAreaContext\n to store cell alignment and allocation details for a said #GtkCellArea\n class.\n @copy_context: Creates a new #GtkCellAreaContext in the same state as\n the passed @context with any cell alignment data and allocations intact.\n @get_request_mode: This allows an area to tell its layouting widget whether\n it prefers to be allocated in %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH or\n %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT mode.\n @get_preferred_width: Calculates the minimum and natural width of the\n areas cells with the current attributes applied while considering\n the particular layouting details of the said #GtkCellArea. While\n requests are performed over a series of rows, alignments and overall\n minimum and natural sizes should be stored in the corresponding\n #GtkCellAreaContext.\n @get_preferred_height_for_width: Calculates the minimum and natural height\n for the area if the passed @context would be allocated the given width.\n When implementing this virtual method it is safe to assume that @context\n has already stored the aligned cell widths for every #GtkTreeModel row\n that @context will be allocated for since this information was stored\n at #GtkCellAreaClass.get_preferred_width() time. This virtual method\n should also store any necessary alignments of cell heights for the\n case that the context is allocated a height.\n @get_preferred_height: Calculates the minimum and natural height of the\n areas cells with the current attributes applied. Essentially this is\n the same as #GtkCellAreaClass.get_preferred_width() only for areas\n that are being requested as %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT.\n @get_preferred_width_for_height: Calculates the minimum and natural width\n for the area if the passed @context would be allocated the given\n height. The same as #GtkCellAreaClass.get_preferred_height_for_width()\n only for handling requests in the %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT\n mode.\n @set_cell_property: This should be implemented to handle changes in child\n cell properties for a given #GtkCellRenderer that were previously\n installed on the #GtkCellAreaClass with gtk_cell_area_class_install_cell_property().\n @get_cell_property: This should be implemented to report the values of\n child cell properties for a given child #GtkCellRenderer.\n @focus: This virtual method should be implemented to navigate focus from\n cell to cell inside the #GtkCellArea. The #GtkCellArea should move\n focus from cell to cell inside the area and return %FALSE if focus\n logically leaves the area with the following exceptions: When the\n area contains no activatable cells, the entire area recieves focus.\n Focus should not be given to cells that are actually “focus siblings”\n of other sibling cells (see gtk_cell_area_get_focus_from_sibling()).\n Focus is set by calling gtk_cell_area_set_focus_cell().\n @is_activatable: Returns whether the #GtkCellArea can respond to\n #GtkCellAreaClass.activate(), usually this does not need to be\n implemented since the base class takes care of this however it can\n be enhanced if the #GtkCellArea subclass can handle activation in\n other ways than activating its #GtkCellRenderers.\n @activate: This is called when the layouting widget rendering the\n #GtkCellArea activates the focus cell (see gtk_cell_area_get_focus_cell())."]
pub type GtkCellAreaClass = _GtkCellAreaClass;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellAreaPrivate {
_unused: [u8; 0],
}
pub type GtkCellAreaPrivate = _GtkCellAreaPrivate;
pub type GtkCellAreaContext = _GtkCellAreaContext;
#[doc = " GtkCellCallback:\n @renderer: the cell renderer to operate on\n @data: (closure): user-supplied data\n\n The type of the callback functions used for iterating over\n the cell renderers of a #GtkCellArea, see gtk_cell_area_foreach().\n\n Returns: %TRUE to stop iterating over cells."]
pub type GtkCellCallback = ::std::option::Option<
unsafe extern "C" fn(renderer: *mut GtkCellRenderer, data: gpointer) -> gboolean,
>;
#[doc = " GtkCellAllocCallback:\n @renderer: the cell renderer to operate on\n @cell_area: the area allocated to @renderer inside the rectangle\n provided to gtk_cell_area_foreach_alloc().\n @cell_background: the background area for @renderer inside the\n background area provided to gtk_cell_area_foreach_alloc().\n @data: (closure): user-supplied data\n\n The type of the callback functions used for iterating over the\n cell renderers and their allocated areas inside a #GtkCellArea,\n see gtk_cell_area_foreach_alloc().\n\n Returns: %TRUE to stop iterating over cells."]
pub type GtkCellAllocCallback = ::std::option::Option<
unsafe extern "C" fn(
renderer: *mut GtkCellRenderer,
cell_area: *const GdkRectangle,
cell_background: *const GdkRectangle,
data: gpointer,
) -> gboolean,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellArea {
pub parent_instance: GInitiallyUnowned,
pub priv_: *mut GtkCellAreaPrivate,
}
#[test]
fn bindgen_test_layout__GtkCellArea() {
const UNINIT: ::std::mem::MaybeUninit<_GtkCellArea> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkCellArea>(),
32usize,
concat!("Size of: ", stringify!(_GtkCellArea))
);
assert_eq!(
::std::mem::align_of::<_GtkCellArea>(),
8usize,
concat!("Alignment of ", stringify!(_GtkCellArea))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellArea),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellArea),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkCellArea {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GtkCellAreaClass:\n @add: adds a #GtkCellRenderer to the area.\n @remove: removes a #GtkCellRenderer from the area.\n @foreach: calls the #GtkCellCallback function on every #GtkCellRenderer in\n the area with the provided user data until the callback returns %TRUE.\n @foreach_alloc: Calls the #GtkCellAllocCallback function on every\n #GtkCellRenderer in the area with the allocated area for the cell\n and the provided user data until the callback returns %TRUE.\n @event: Handle an event in the area, this is generally used to activate\n a cell at the event location for button events but can also be used\n to generically pass events to #GtkWidgets drawn onto the area.\n @render: Actually render the area’s cells to the specified rectangle,\n @background_area should be correctly distributed to the cells\n corresponding background areas.\n @apply_attributes: Apply the cell attributes to the cells. This is\n implemented as a signal and generally #GtkCellArea subclasses don't\n need to implement it since it is handled by the base class.\n @create_context: Creates and returns a class specific #GtkCellAreaContext\n to store cell alignment and allocation details for a said #GtkCellArea\n class.\n @copy_context: Creates a new #GtkCellAreaContext in the same state as\n the passed @context with any cell alignment data and allocations intact.\n @get_request_mode: This allows an area to tell its layouting widget whether\n it prefers to be allocated in %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH or\n %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT mode.\n @get_preferred_width: Calculates the minimum and natural width of the\n areas cells with the current attributes applied while considering\n the particular layouting details of the said #GtkCellArea. While\n requests are performed over a series of rows, alignments and overall\n minimum and natural sizes should be stored in the corresponding\n #GtkCellAreaContext.\n @get_preferred_height_for_width: Calculates the minimum and natural height\n for the area if the passed @context would be allocated the given width.\n When implementing this virtual method it is safe to assume that @context\n has already stored the aligned cell widths for every #GtkTreeModel row\n that @context will be allocated for since this information was stored\n at #GtkCellAreaClass.get_preferred_width() time. This virtual method\n should also store any necessary alignments of cell heights for the\n case that the context is allocated a height.\n @get_preferred_height: Calculates the minimum and natural height of the\n areas cells with the current attributes applied. Essentially this is\n the same as #GtkCellAreaClass.get_preferred_width() only for areas\n that are being requested as %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT.\n @get_preferred_width_for_height: Calculates the minimum and natural width\n for the area if the passed @context would be allocated the given\n height. The same as #GtkCellAreaClass.get_preferred_height_for_width()\n only for handling requests in the %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT\n mode.\n @set_cell_property: This should be implemented to handle changes in child\n cell properties for a given #GtkCellRenderer that were previously\n installed on the #GtkCellAreaClass with gtk_cell_area_class_install_cell_property().\n @get_cell_property: This should be implemented to report the values of\n child cell properties for a given child #GtkCellRenderer.\n @focus: This virtual method should be implemented to navigate focus from\n cell to cell inside the #GtkCellArea. The #GtkCellArea should move\n focus from cell to cell inside the area and return %FALSE if focus\n logically leaves the area with the following exceptions: When the\n area contains no activatable cells, the entire area recieves focus.\n Focus should not be given to cells that are actually “focus siblings”\n of other sibling cells (see gtk_cell_area_get_focus_from_sibling()).\n Focus is set by calling gtk_cell_area_set_focus_cell().\n @is_activatable: Returns whether the #GtkCellArea can respond to\n #GtkCellAreaClass.activate(), usually this does not need to be\n implemented since the base class takes care of this however it can\n be enhanced if the #GtkCellArea subclass can handle activation in\n other ways than activating its #GtkCellRenderers.\n @activate: This is called when the layouting widget rendering the\n #GtkCellArea activates the focus cell (see gtk_cell_area_get_focus_cell())."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellAreaClass {
pub parent_class: GInitiallyUnownedClass,
pub add: ::std::option::Option<
unsafe extern "C" fn(area: *mut GtkCellArea, renderer: *mut GtkCellRenderer),
>,
pub remove: ::std::option::Option<
unsafe extern "C" fn(area: *mut GtkCellArea, renderer: *mut GtkCellRenderer),
>,
pub foreach: ::std::option::Option<
unsafe extern "C" fn(
area: *mut GtkCellArea,
callback: GtkCellCallback,
callback_data: gpointer,
),
>,
pub foreach_alloc: ::std::option::Option<
unsafe extern "C" fn(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
cell_area: *const GdkRectangle,
background_area: *const GdkRectangle,
callback: GtkCellAllocCallback,
callback_data: gpointer,
),
>,
pub event: ::std::option::Option<
unsafe extern "C" fn(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
event: *mut GdkEvent,
cell_area: *const GdkRectangle,
flags: GtkCellRendererState,
) -> gint,
>,
pub render: ::std::option::Option<
unsafe extern "C" fn(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
cr: *mut cairo_t,
background_area: *const GdkRectangle,
cell_area: *const GdkRectangle,
flags: GtkCellRendererState,
paint_focus: gboolean,
),
>,
pub apply_attributes: ::std::option::Option<
unsafe extern "C" fn(
area: *mut GtkCellArea,
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
is_expander: gboolean,
is_expanded: gboolean,
),
>,
pub create_context: ::std::option::Option<
unsafe extern "C" fn(area: *mut GtkCellArea) -> *mut GtkCellAreaContext,
>,
pub copy_context: ::std::option::Option<
unsafe extern "C" fn(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
) -> *mut GtkCellAreaContext,
>,
pub get_request_mode:
::std::option::Option<unsafe extern "C" fn(area: *mut GtkCellArea) -> GtkSizeRequestMode>,
pub get_preferred_width: ::std::option::Option<
unsafe extern "C" fn(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
minimum_width: *mut gint,
natural_width: *mut gint,
),
>,
pub get_preferred_height_for_width: ::std::option::Option<
unsafe extern "C" fn(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
width: gint,
minimum_height: *mut gint,
natural_height: *mut gint,
),
>,
pub get_preferred_height: ::std::option::Option<
unsafe extern "C" fn(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
minimum_height: *mut gint,
natural_height: *mut gint,
),
>,
pub get_preferred_width_for_height: ::std::option::Option<
unsafe extern "C" fn(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
height: gint,
minimum_width: *mut gint,
natural_width: *mut gint,
),
>,
pub set_cell_property: ::std::option::Option<
unsafe extern "C" fn(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
property_id: guint,
value: *const GValue,
pspec: *mut GParamSpec,
),
>,
pub get_cell_property: ::std::option::Option<
unsafe extern "C" fn(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
property_id: guint,
value: *mut GValue,
pspec: *mut GParamSpec,
),
>,
pub focus: ::std::option::Option<
unsafe extern "C" fn(area: *mut GtkCellArea, direction: GtkDirectionType) -> gboolean,
>,
pub is_activatable:
::std::option::Option<unsafe extern "C" fn(area: *mut GtkCellArea) -> gboolean>,
pub activate: ::std::option::Option<
unsafe extern "C" fn(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
cell_area: *const GdkRectangle,
flags: GtkCellRendererState,
edit_only: gboolean,
) -> gboolean,
>,
pub _gtk_reserved1: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved2: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved3: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved4: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved5: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved6: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved7: ::std::option::Option<unsafe extern "C" fn()>,
pub _gtk_reserved8: ::std::option::Option<unsafe extern "C" fn()>,
}
#[test]
fn bindgen_test_layout__GtkCellAreaClass() {
const UNINIT: ::std::mem::MaybeUninit<_GtkCellAreaClass> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkCellAreaClass>(),
352usize,
concat!("Size of: ", stringify!(_GtkCellAreaClass))
);
assert_eq!(
::std::mem::align_of::<_GtkCellAreaClass>(),
8usize,
concat!("Alignment of ", stringify!(_GtkCellAreaClass))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_class) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(parent_class)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).add) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(add)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).remove) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(remove)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).foreach) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(foreach)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).foreach_alloc) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(foreach_alloc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).event) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).render) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(render)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).apply_attributes) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(apply_attributes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).create_context) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(create_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).copy_context) as usize - ptr as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(copy_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_request_mode) as usize - ptr as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(get_request_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_preferred_width) as usize - ptr as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(get_preferred_width)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).get_preferred_height_for_width) as usize - ptr as usize
},
224usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(get_preferred_height_for_width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_preferred_height) as usize - ptr as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(get_preferred_height)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).get_preferred_width_for_height) as usize - ptr as usize
},
240usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(get_preferred_width_for_height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).set_cell_property) as usize - ptr as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(set_cell_property)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_cell_property) as usize - ptr as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(get_cell_property)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).focus) as usize - ptr as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(focus)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_activatable) as usize - ptr as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(is_activatable)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).activate) as usize - ptr as usize },
280usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(activate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved1) as usize - ptr as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(_gtk_reserved1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved2) as usize - ptr as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(_gtk_reserved2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved3) as usize - ptr as usize },
304usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(_gtk_reserved3)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved4) as usize - ptr as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(_gtk_reserved4)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved5) as usize - ptr as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(_gtk_reserved5)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved6) as usize - ptr as usize },
328usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(_gtk_reserved6)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved7) as usize - ptr as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(_gtk_reserved7)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._gtk_reserved8) as usize - ptr as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaClass),
"::",
stringify!(_gtk_reserved8)
)
);
}
impl Default for _GtkCellAreaClass {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_cell_area_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_area_add(area: *mut GtkCellArea, renderer: *mut GtkCellRenderer);
}
extern "C" {
pub fn gtk_cell_area_remove(area: *mut GtkCellArea, renderer: *mut GtkCellRenderer);
}
extern "C" {
pub fn gtk_cell_area_has_renderer(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
) -> gboolean;
}
extern "C" {
pub fn gtk_cell_area_foreach(
area: *mut GtkCellArea,
callback: GtkCellCallback,
callback_data: gpointer,
);
}
extern "C" {
pub fn gtk_cell_area_foreach_alloc(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
cell_area: *const GdkRectangle,
background_area: *const GdkRectangle,
callback: GtkCellAllocCallback,
callback_data: gpointer,
);
}
extern "C" {
pub fn gtk_cell_area_event(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
event: *mut GdkEvent,
cell_area: *const GdkRectangle,
flags: GtkCellRendererState,
) -> gint;
}
extern "C" {
pub fn gtk_cell_area_render(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
cr: *mut cairo_t,
background_area: *const GdkRectangle,
cell_area: *const GdkRectangle,
flags: GtkCellRendererState,
paint_focus: gboolean,
);
}
extern "C" {
pub fn gtk_cell_area_get_cell_allocation(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
renderer: *mut GtkCellRenderer,
cell_area: *const GdkRectangle,
allocation: *mut GdkRectangle,
);
}
extern "C" {
pub fn gtk_cell_area_get_cell_at_position(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
cell_area: *const GdkRectangle,
x: gint,
y: gint,
alloc_area: *mut GdkRectangle,
) -> *mut GtkCellRenderer;
}
extern "C" {
pub fn gtk_cell_area_create_context(area: *mut GtkCellArea) -> *mut GtkCellAreaContext;
}
extern "C" {
pub fn gtk_cell_area_copy_context(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
) -> *mut GtkCellAreaContext;
}
extern "C" {
pub fn gtk_cell_area_get_request_mode(area: *mut GtkCellArea) -> GtkSizeRequestMode;
}
extern "C" {
pub fn gtk_cell_area_get_preferred_width(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
minimum_width: *mut gint,
natural_width: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_area_get_preferred_height_for_width(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
width: gint,
minimum_height: *mut gint,
natural_height: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_area_get_preferred_height(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
minimum_height: *mut gint,
natural_height: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_area_get_preferred_width_for_height(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
height: gint,
minimum_width: *mut gint,
natural_width: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_area_get_current_path_string(area: *mut GtkCellArea) -> *const gchar;
}
extern "C" {
pub fn gtk_cell_area_apply_attributes(
area: *mut GtkCellArea,
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
is_expander: gboolean,
is_expanded: gboolean,
);
}
extern "C" {
pub fn gtk_cell_area_attribute_connect(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
attribute: *const gchar,
column: gint,
);
}
extern "C" {
pub fn gtk_cell_area_attribute_disconnect(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
attribute: *const gchar,
);
}
extern "C" {
pub fn gtk_cell_area_attribute_get_column(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
attribute: *const gchar,
) -> gint;
}
extern "C" {
pub fn gtk_cell_area_class_install_cell_property(
aclass: *mut GtkCellAreaClass,
property_id: guint,
pspec: *mut GParamSpec,
);
}
extern "C" {
pub fn gtk_cell_area_class_find_cell_property(
aclass: *mut GtkCellAreaClass,
property_name: *const gchar,
) -> *mut GParamSpec;
}
extern "C" {
pub fn gtk_cell_area_class_list_cell_properties(
aclass: *mut GtkCellAreaClass,
n_properties: *mut guint,
) -> *mut *mut GParamSpec;
}
extern "C" {
pub fn gtk_cell_area_add_with_properties(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
first_prop_name: *const gchar,
...
);
}
extern "C" {
pub fn gtk_cell_area_cell_set(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
first_prop_name: *const gchar,
...
);
}
extern "C" {
pub fn gtk_cell_area_cell_get(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
first_prop_name: *const gchar,
...
);
}
extern "C" {
pub fn gtk_cell_area_cell_set_property(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
property_name: *const gchar,
value: *const GValue,
);
}
extern "C" {
pub fn gtk_cell_area_cell_get_property(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
property_name: *const gchar,
value: *mut GValue,
);
}
extern "C" {
pub fn gtk_cell_area_is_activatable(area: *mut GtkCellArea) -> gboolean;
}
extern "C" {
pub fn gtk_cell_area_activate(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
widget: *mut GtkWidget,
cell_area: *const GdkRectangle,
flags: GtkCellRendererState,
edit_only: gboolean,
) -> gboolean;
}
extern "C" {
pub fn gtk_cell_area_focus(area: *mut GtkCellArea, direction: GtkDirectionType) -> gboolean;
}
extern "C" {
pub fn gtk_cell_area_set_focus_cell(area: *mut GtkCellArea, renderer: *mut GtkCellRenderer);
}
extern "C" {
pub fn gtk_cell_area_get_focus_cell(area: *mut GtkCellArea) -> *mut GtkCellRenderer;
}
extern "C" {
pub fn gtk_cell_area_add_focus_sibling(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
sibling: *mut GtkCellRenderer,
);
}
extern "C" {
pub fn gtk_cell_area_remove_focus_sibling(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
sibling: *mut GtkCellRenderer,
);
}
extern "C" {
pub fn gtk_cell_area_is_focus_sibling(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
sibling: *mut GtkCellRenderer,
) -> gboolean;
}
extern "C" {
pub fn gtk_cell_area_get_focus_siblings(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
) -> *const GList;
}
extern "C" {
pub fn gtk_cell_area_get_focus_from_sibling(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
) -> *mut GtkCellRenderer;
}
extern "C" {
pub fn gtk_cell_area_get_edited_cell(area: *mut GtkCellArea) -> *mut GtkCellRenderer;
}
extern "C" {
pub fn gtk_cell_area_get_edit_widget(area: *mut GtkCellArea) -> *mut GtkCellEditable;
}
extern "C" {
pub fn gtk_cell_area_activate_cell(
area: *mut GtkCellArea,
widget: *mut GtkWidget,
renderer: *mut GtkCellRenderer,
event: *mut GdkEvent,
cell_area: *const GdkRectangle,
flags: GtkCellRendererState,
) -> gboolean;
}
extern "C" {
pub fn gtk_cell_area_stop_editing(area: *mut GtkCellArea, canceled: gboolean);
}
extern "C" {
pub fn gtk_cell_area_inner_cell_area(
area: *mut GtkCellArea,
widget: *mut GtkWidget,
cell_area: *const GdkRectangle,
inner_area: *mut GdkRectangle,
);
}
extern "C" {
pub fn gtk_cell_area_request_renderer(
area: *mut GtkCellArea,
renderer: *mut GtkCellRenderer,
orientation: GtkOrientation,
widget: *mut GtkWidget,
for_size: gint,
minimum_size: *mut gint,
natural_size: *mut gint,
);
}
pub type GtkTreeViewColumn = _GtkTreeViewColumn;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeViewColumnPrivate {
_unused: [u8; 0],
}
pub type GtkTreeViewColumnPrivate = _GtkTreeViewColumnPrivate;
pub const GtkTreeViewColumnSizing_GTK_TREE_VIEW_COLUMN_GROW_ONLY: GtkTreeViewColumnSizing = 0;
pub const GtkTreeViewColumnSizing_GTK_TREE_VIEW_COLUMN_AUTOSIZE: GtkTreeViewColumnSizing = 1;
pub const GtkTreeViewColumnSizing_GTK_TREE_VIEW_COLUMN_FIXED: GtkTreeViewColumnSizing = 2;
#[doc = " GtkTreeViewColumnSizing:\n @GTK_TREE_VIEW_COLUMN_GROW_ONLY: Columns only get bigger in reaction to changes in the model\n @GTK_TREE_VIEW_COLUMN_AUTOSIZE: Columns resize to be the optimal size everytime the model changes.\n @GTK_TREE_VIEW_COLUMN_FIXED: Columns are a fixed numbers of pixels wide.\n\n The sizing method the column uses to determine its width. Please note\n that @GTK_TREE_VIEW_COLUMN_AUTOSIZE are inefficient for large views, and\n can make columns appear choppy."]
pub type GtkTreeViewColumnSizing = ::std::os::raw::c_uint;
#[doc = " GtkTreeCellDataFunc:\n @tree_column: A #GtkTreeViewColumn\n @cell: The #GtkCellRenderer that is being rendered by @tree_column\n @tree_model: The #GtkTreeModel being rendered\n @iter: A #GtkTreeIter of the current row rendered\n @data: (closure): user data\n\n A function to set the properties of a cell instead of just using the\n straight mapping between the cell and the model. This is useful for\n customizing the cell renderer. For example, a function might get an\n integer from the @tree_model, and render it to the “text” attribute of\n “cell” by converting it to its written equivilent. This is set by\n calling gtk_tree_view_column_set_cell_data_func()"]
pub type GtkTreeCellDataFunc = ::std::option::Option<
unsafe extern "C" fn(
tree_column: *mut GtkTreeViewColumn,
cell: *mut GtkCellRenderer,
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
data: gpointer,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeViewColumn {
pub parent_instance: GInitiallyUnowned,
pub priv_: *mut GtkTreeViewColumnPrivate,
}
#[test]
fn bindgen_test_layout__GtkTreeViewColumn() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTreeViewColumn> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTreeViewColumn>(),
32usize,
concat!("Size of: ", stringify!(_GtkTreeViewColumn))
);
assert_eq!(
::std::mem::align_of::<_GtkTreeViewColumn>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTreeViewColumn))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeViewColumn),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeViewColumn),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkTreeViewColumn {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_tree_view_column_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_view_column_new() -> *mut GtkTreeViewColumn;
}
extern "C" {
pub fn gtk_tree_view_column_new_with_area(area: *mut GtkCellArea) -> *mut GtkTreeViewColumn;
}
extern "C" {
pub fn gtk_tree_view_column_new_with_attributes(
title: *const gchar,
cell: *mut GtkCellRenderer,
...
) -> *mut GtkTreeViewColumn;
}
extern "C" {
pub fn gtk_tree_view_column_pack_start(
tree_column: *mut GtkTreeViewColumn,
cell: *mut GtkCellRenderer,
expand: gboolean,
);
}
extern "C" {
pub fn gtk_tree_view_column_pack_end(
tree_column: *mut GtkTreeViewColumn,
cell: *mut GtkCellRenderer,
expand: gboolean,
);
}
extern "C" {
pub fn gtk_tree_view_column_clear(tree_column: *mut GtkTreeViewColumn);
}
extern "C" {
pub fn gtk_tree_view_column_add_attribute(
tree_column: *mut GtkTreeViewColumn,
cell_renderer: *mut GtkCellRenderer,
attribute: *const gchar,
column: gint,
);
}
extern "C" {
pub fn gtk_tree_view_column_set_attributes(
tree_column: *mut GtkTreeViewColumn,
cell_renderer: *mut GtkCellRenderer,
...
);
}
extern "C" {
pub fn gtk_tree_view_column_set_cell_data_func(
tree_column: *mut GtkTreeViewColumn,
cell_renderer: *mut GtkCellRenderer,
func: GtkTreeCellDataFunc,
func_data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_tree_view_column_clear_attributes(
tree_column: *mut GtkTreeViewColumn,
cell_renderer: *mut GtkCellRenderer,
);
}
extern "C" {
pub fn gtk_tree_view_column_set_spacing(tree_column: *mut GtkTreeViewColumn, spacing: gint);
}
extern "C" {
pub fn gtk_tree_view_column_get_spacing(tree_column: *mut GtkTreeViewColumn) -> gint;
}
extern "C" {
pub fn gtk_tree_view_column_set_visible(tree_column: *mut GtkTreeViewColumn, visible: gboolean);
}
extern "C" {
pub fn gtk_tree_view_column_get_visible(tree_column: *mut GtkTreeViewColumn) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_column_set_resizable(
tree_column: *mut GtkTreeViewColumn,
resizable: gboolean,
);
}
extern "C" {
pub fn gtk_tree_view_column_get_resizable(tree_column: *mut GtkTreeViewColumn) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_column_set_sizing(
tree_column: *mut GtkTreeViewColumn,
type_: GtkTreeViewColumnSizing,
);
}
extern "C" {
pub fn gtk_tree_view_column_get_sizing(
tree_column: *mut GtkTreeViewColumn,
) -> GtkTreeViewColumnSizing;
}
extern "C" {
pub fn gtk_tree_view_column_get_x_offset(tree_column: *mut GtkTreeViewColumn) -> gint;
}
extern "C" {
pub fn gtk_tree_view_column_get_width(tree_column: *mut GtkTreeViewColumn) -> gint;
}
extern "C" {
pub fn gtk_tree_view_column_get_fixed_width(tree_column: *mut GtkTreeViewColumn) -> gint;
}
extern "C" {
pub fn gtk_tree_view_column_set_fixed_width(
tree_column: *mut GtkTreeViewColumn,
fixed_width: gint,
);
}
extern "C" {
pub fn gtk_tree_view_column_set_min_width(tree_column: *mut GtkTreeViewColumn, min_width: gint);
}
extern "C" {
pub fn gtk_tree_view_column_get_min_width(tree_column: *mut GtkTreeViewColumn) -> gint;
}
extern "C" {
pub fn gtk_tree_view_column_set_max_width(tree_column: *mut GtkTreeViewColumn, max_width: gint);
}
extern "C" {
pub fn gtk_tree_view_column_get_max_width(tree_column: *mut GtkTreeViewColumn) -> gint;
}
extern "C" {
pub fn gtk_tree_view_column_clicked(tree_column: *mut GtkTreeViewColumn);
}
extern "C" {
pub fn gtk_tree_view_column_set_title(tree_column: *mut GtkTreeViewColumn, title: *const gchar);
}
extern "C" {
pub fn gtk_tree_view_column_get_title(tree_column: *mut GtkTreeViewColumn) -> *const gchar;
}
extern "C" {
pub fn gtk_tree_view_column_set_expand(tree_column: *mut GtkTreeViewColumn, expand: gboolean);
}
extern "C" {
pub fn gtk_tree_view_column_get_expand(tree_column: *mut GtkTreeViewColumn) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_column_set_clickable(
tree_column: *mut GtkTreeViewColumn,
clickable: gboolean,
);
}
extern "C" {
pub fn gtk_tree_view_column_get_clickable(tree_column: *mut GtkTreeViewColumn) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_column_set_widget(
tree_column: *mut GtkTreeViewColumn,
widget: *mut GtkWidget,
);
}
extern "C" {
pub fn gtk_tree_view_column_get_widget(tree_column: *mut GtkTreeViewColumn) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_tree_view_column_set_alignment(tree_column: *mut GtkTreeViewColumn, xalign: gfloat);
}
extern "C" {
pub fn gtk_tree_view_column_get_alignment(tree_column: *mut GtkTreeViewColumn) -> gfloat;
}
extern "C" {
pub fn gtk_tree_view_column_set_reorderable(
tree_column: *mut GtkTreeViewColumn,
reorderable: gboolean,
);
}
extern "C" {
pub fn gtk_tree_view_column_get_reorderable(tree_column: *mut GtkTreeViewColumn) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_column_set_sort_column_id(
tree_column: *mut GtkTreeViewColumn,
sort_column_id: gint,
);
}
extern "C" {
pub fn gtk_tree_view_column_get_sort_column_id(tree_column: *mut GtkTreeViewColumn) -> gint;
}
extern "C" {
pub fn gtk_tree_view_column_set_sort_indicator(
tree_column: *mut GtkTreeViewColumn,
setting: gboolean,
);
}
extern "C" {
pub fn gtk_tree_view_column_get_sort_indicator(tree_column: *mut GtkTreeViewColumn)
-> gboolean;
}
extern "C" {
pub fn gtk_tree_view_column_set_sort_order(
tree_column: *mut GtkTreeViewColumn,
order: GtkSortType,
);
}
extern "C" {
pub fn gtk_tree_view_column_get_sort_order(tree_column: *mut GtkTreeViewColumn) -> GtkSortType;
}
extern "C" {
pub fn gtk_tree_view_column_cell_set_cell_data(
tree_column: *mut GtkTreeViewColumn,
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
is_expander: gboolean,
is_expanded: gboolean,
);
}
extern "C" {
pub fn gtk_tree_view_column_cell_get_size(
tree_column: *mut GtkTreeViewColumn,
cell_area: *const GdkRectangle,
x_offset: *mut gint,
y_offset: *mut gint,
width: *mut gint,
height: *mut gint,
);
}
extern "C" {
pub fn gtk_tree_view_column_cell_is_visible(tree_column: *mut GtkTreeViewColumn) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_column_focus_cell(
tree_column: *mut GtkTreeViewColumn,
cell: *mut GtkCellRenderer,
);
}
extern "C" {
pub fn gtk_tree_view_column_cell_get_position(
tree_column: *mut GtkTreeViewColumn,
cell_renderer: *mut GtkCellRenderer,
x_offset: *mut gint,
width: *mut gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_column_queue_resize(tree_column: *mut GtkTreeViewColumn);
}
extern "C" {
pub fn gtk_tree_view_column_get_tree_view(
tree_column: *mut GtkTreeViewColumn,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_tree_view_column_get_button(tree_column: *mut GtkTreeViewColumn) -> *mut GtkWidget;
}
#[doc = " GtkTextAttributes:\n @appearance: #GtkTextAppearance for text.\n @justification: #GtkJustification for text.\n @direction: #GtkTextDirection for text.\n @font: #PangoFontDescription for text.\n @font_scale: Font scale factor.\n @left_margin: Width of the left margin in pixels.\n @right_margin: Width of the right margin in pixels.\n @indent: Amount to indent the paragraph, in pixels.\n @pixels_above_lines: Pixels of blank space above paragraphs.\n @pixels_below_lines: Pixels of blank space below paragraphs.\n @pixels_inside_wrap: Pixels of blank space between wrapped lines in\n a paragraph.\n @tabs: Custom #PangoTabArray for this text.\n @wrap_mode: #GtkWrapMode for text.\n @language: #PangoLanguage for text.\n @invisible: Hide the text.\n @bg_full_height: Background is fit to full line height rather than\n baseline +/- ascent/descent (font height).\n @editable: Can edit this text.\n\n Using #GtkTextAttributes directly should rarely be necessary.\n It’s primarily useful with gtk_text_iter_get_attributes().\n As with most GTK+ structs, the fields in this struct should only\n be read, never modified directly."]
pub type GtkTextAttributes = _GtkTextAttributes;
#[doc = " GtkTextAppearance:\n @bg_color: Background #GdkColor.\n @fg_color: Foreground #GdkColor.\n @rise: Super/subscript rise, can be negative.\n @underline: #PangoUnderline\n @strikethrough: Strikethrough style\n @draw_bg: Whether to use background-related values; this is\n irrelevant for the values struct when in a tag, but is used for\n the composite values struct; it’s true if any of the tags being\n composited had background stuff set.\n @inside_selection: This are only used when we are actually laying\n out and rendering a paragraph; not when a #GtkTextAppearance is\n part of a #GtkTextAttributes.\n @is_text: This are only used when we are actually laying\n out and rendering a paragraph; not when a #GtkTextAppearance is\n part of a #GtkTextAttributes.\n @rgba: #GdkRGBA"]
pub type GtkTextAppearance = _GtkTextAppearance;
#[doc = " GtkTextAppearance:\n @bg_color: Background #GdkColor.\n @fg_color: Foreground #GdkColor.\n @rise: Super/subscript rise, can be negative.\n @underline: #PangoUnderline\n @strikethrough: Strikethrough style\n @draw_bg: Whether to use background-related values; this is\n irrelevant for the values struct when in a tag, but is used for\n the composite values struct; it’s true if any of the tags being\n composited had background stuff set.\n @inside_selection: This are only used when we are actually laying\n out and rendering a paragraph; not when a #GtkTextAppearance is\n part of a #GtkTextAttributes.\n @is_text: This are only used when we are actually laying\n out and rendering a paragraph; not when a #GtkTextAppearance is\n part of a #GtkTextAttributes.\n @rgba: #GdkRGBA"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTextAppearance {
pub bg_color: GdkColor,
pub fg_color: GdkColor,
pub rise: gint,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub rgba: [*mut GdkRGBA; 2usize],
}
#[test]
fn bindgen_test_layout__GtkTextAppearance() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTextAppearance> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTextAppearance>(),
48usize,
concat!("Size of: ", stringify!(_GtkTextAppearance))
);
assert_eq!(
::std::mem::align_of::<_GtkTextAppearance>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTextAppearance))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_color) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAppearance),
"::",
stringify!(bg_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fg_color) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAppearance),
"::",
stringify!(fg_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rise) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAppearance),
"::",
stringify!(rise)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rgba) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAppearance),
"::",
stringify!(rgba)
)
);
}
impl Default for _GtkTextAppearance {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl _GtkTextAppearance {
#[inline]
pub fn underline(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
}
#[inline]
pub fn set_underline(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 4u8, val as u64)
}
}
#[inline]
pub fn strikethrough(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
}
#[inline]
pub fn set_strikethrough(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn draw_bg(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
}
#[inline]
pub fn set_draw_bg(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 1u8, val as u64)
}
}
#[inline]
pub fn inside_selection(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
}
#[inline]
pub fn set_inside_selection(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 1u8, val as u64)
}
}
#[inline]
pub fn is_text(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
}
#[inline]
pub fn set_is_text(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(7usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
underline: guint,
strikethrough: guint,
draw_bg: guint,
inside_selection: guint,
is_text: guint,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 4u8, {
let underline: u32 = unsafe { ::std::mem::transmute(underline) };
underline as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let strikethrough: u32 = unsafe { ::std::mem::transmute(strikethrough) };
strikethrough as u64
});
__bindgen_bitfield_unit.set(5usize, 1u8, {
let draw_bg: u32 = unsafe { ::std::mem::transmute(draw_bg) };
draw_bg as u64
});
__bindgen_bitfield_unit.set(6usize, 1u8, {
let inside_selection: u32 = unsafe { ::std::mem::transmute(inside_selection) };
inside_selection as u64
});
__bindgen_bitfield_unit.set(7usize, 1u8, {
let is_text: u32 = unsafe { ::std::mem::transmute(is_text) };
is_text as u64
});
__bindgen_bitfield_unit
}
}
#[doc = " GtkTextAttributes:\n @appearance: #GtkTextAppearance for text.\n @justification: #GtkJustification for text.\n @direction: #GtkTextDirection for text.\n @font: #PangoFontDescription for text.\n @font_scale: Font scale factor.\n @left_margin: Width of the left margin in pixels.\n @right_margin: Width of the right margin in pixels.\n @indent: Amount to indent the paragraph, in pixels.\n @pixels_above_lines: Pixels of blank space above paragraphs.\n @pixels_below_lines: Pixels of blank space below paragraphs.\n @pixels_inside_wrap: Pixels of blank space between wrapped lines in\n a paragraph.\n @tabs: Custom #PangoTabArray for this text.\n @wrap_mode: #GtkWrapMode for text.\n @language: #PangoLanguage for text.\n @invisible: Hide the text.\n @bg_full_height: Background is fit to full line height rather than\n baseline +/- ascent/descent (font height).\n @editable: Can edit this text.\n\n Using #GtkTextAttributes directly should rarely be necessary.\n It’s primarily useful with gtk_text_iter_get_attributes().\n As with most GTK+ structs, the fields in this struct should only\n be read, never modified directly."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTextAttributes {
pub refcount: guint,
pub appearance: GtkTextAppearance,
pub justification: GtkJustification,
pub direction: GtkTextDirection,
pub font: *mut PangoFontDescription,
pub font_scale: gdouble,
pub left_margin: gint,
pub right_margin: gint,
pub indent: gint,
pub pixels_above_lines: gint,
pub pixels_below_lines: gint,
pub pixels_inside_wrap: gint,
pub tabs: *mut PangoTabArray,
pub wrap_mode: GtkWrapMode,
pub language: *mut PangoLanguage,
pub pg_bg_color: *mut GdkColor,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub pg_bg_rgba: *mut GdkRGBA,
pub padding: [guint; 3usize],
}
#[test]
fn bindgen_test_layout__GtkTextAttributes() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTextAttributes> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTextAttributes>(),
168usize,
concat!("Size of: ", stringify!(_GtkTextAttributes))
);
assert_eq!(
::std::mem::align_of::<_GtkTextAttributes>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTextAttributes))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).refcount) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(refcount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).appearance) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(appearance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).justification) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(justification)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(direction)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(font)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_scale) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(font_scale)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).left_margin) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(left_margin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).right_margin) as usize - ptr as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(right_margin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).indent) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(indent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pixels_above_lines) as usize - ptr as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(pixels_above_lines)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pixels_below_lines) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(pixels_below_lines)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pixels_inside_wrap) as usize - ptr as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(pixels_inside_wrap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tabs) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(tabs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wrap_mode) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(wrap_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).language) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(language)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pg_bg_color) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(pg_bg_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pg_bg_rgba) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(pg_bg_rgba)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextAttributes),
"::",
stringify!(padding)
)
);
}
impl Default for _GtkTextAttributes {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl _GtkTextAttributes {
#[inline]
pub fn invisible(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
}
#[inline]
pub fn set_invisible(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn bg_full_height(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
}
#[inline]
pub fn set_bg_full_height(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn editable(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
}
#[inline]
pub fn set_editable(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
invisible: guint,
bg_full_height: guint,
editable: guint,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let invisible: u32 = unsafe { ::std::mem::transmute(invisible) };
invisible as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let bg_full_height: u32 = unsafe { ::std::mem::transmute(bg_full_height) };
bg_full_height as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let editable: u32 = unsafe { ::std::mem::transmute(editable) };
editable as u64
});
__bindgen_bitfield_unit
}
}
extern "C" {
pub fn gtk_text_attributes_new() -> *mut GtkTextAttributes;
}
extern "C" {
pub fn gtk_text_attributes_copy(src: *mut GtkTextAttributes) -> *mut GtkTextAttributes;
}
extern "C" {
pub fn gtk_text_attributes_copy_values(
src: *mut GtkTextAttributes,
dest: *mut GtkTextAttributes,
);
}
extern "C" {
pub fn gtk_text_attributes_unref(values: *mut GtkTextAttributes);
}
extern "C" {
pub fn gtk_text_attributes_ref(values: *mut GtkTextAttributes) -> *mut GtkTextAttributes;
}
extern "C" {
pub fn gtk_text_attributes_get_type() -> GType;
}
#[doc = " GtkTextChildAnchor:\n\n A #GtkTextChildAnchor is a spot in the buffer where child widgets can\n be “anchored” (inserted inline, as if they were characters). The anchor\n can have multiple widgets anchored, to allow for multiple views."]
pub type GtkTextChildAnchor = _GtkTextChildAnchor;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTextChildAnchor {
pub parent_instance: GObject,
pub segment: gpointer,
}
#[test]
fn bindgen_test_layout__GtkTextChildAnchor() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTextChildAnchor> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTextChildAnchor>(),
32usize,
concat!("Size of: ", stringify!(_GtkTextChildAnchor))
);
assert_eq!(
::std::mem::align_of::<_GtkTextChildAnchor>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTextChildAnchor))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextChildAnchor),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).segment) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextChildAnchor),
"::",
stringify!(segment)
)
);
}
impl Default for _GtkTextChildAnchor {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_text_child_anchor_get_type() -> GType;
}
extern "C" {
pub fn gtk_text_child_anchor_new() -> *mut GtkTextChildAnchor;
}
extern "C" {
pub fn gtk_text_child_anchor_get_widgets(anchor: *mut GtkTextChildAnchor) -> *mut GList;
}
extern "C" {
pub fn gtk_text_child_anchor_get_deleted(anchor: *mut GtkTextChildAnchor) -> gboolean;
}
pub type GtkTextIter = _GtkTextIter;
pub type GtkTextTagTable = _GtkTextTagTable;
pub type GtkTextTag = _GtkTextTag;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTextTagPrivate {
_unused: [u8; 0],
}
pub type GtkTextTagPrivate = _GtkTextTagPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTextTag {
pub parent_instance: GObject,
pub priv_: *mut GtkTextTagPrivate,
}
#[test]
fn bindgen_test_layout__GtkTextTag() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTextTag> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTextTag>(),
32usize,
concat!("Size of: ", stringify!(_GtkTextTag))
);
assert_eq!(
::std::mem::align_of::<_GtkTextTag>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTextTag))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextTag),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextTag),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkTextTag {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_text_tag_get_type() -> GType;
}
extern "C" {
pub fn gtk_text_tag_new(name: *const gchar) -> *mut GtkTextTag;
}
extern "C" {
pub fn gtk_text_tag_get_priority(tag: *mut GtkTextTag) -> gint;
}
extern "C" {
pub fn gtk_text_tag_set_priority(tag: *mut GtkTextTag, priority: gint);
}
extern "C" {
pub fn gtk_text_tag_event(
tag: *mut GtkTextTag,
event_object: *mut GObject,
event: *mut GdkEvent,
iter: *const GtkTextIter,
) -> gboolean;
}
pub const GtkTextSearchFlags_GTK_TEXT_SEARCH_VISIBLE_ONLY: GtkTextSearchFlags = 1;
pub const GtkTextSearchFlags_GTK_TEXT_SEARCH_TEXT_ONLY: GtkTextSearchFlags = 2;
pub const GtkTextSearchFlags_GTK_TEXT_SEARCH_CASE_INSENSITIVE: GtkTextSearchFlags = 4;
#[doc = " GtkTextSearchFlags:\n @GTK_TEXT_SEARCH_VISIBLE_ONLY: Search only visible data. A search match may\n have invisible text interspersed.\n @GTK_TEXT_SEARCH_TEXT_ONLY: Search only text. A match may have pixbufs or\n child widgets mixed inside the matched range.\n @GTK_TEXT_SEARCH_CASE_INSENSITIVE: The text will be matched regardless of\n what case it is in.\n\n Flags affecting how a search is done.\n\n If neither #GTK_TEXT_SEARCH_VISIBLE_ONLY nor #GTK_TEXT_SEARCH_TEXT_ONLY are\n enabled, the match must be exact; the special 0xFFFC character will match\n embedded pixbufs or child widgets."]
pub type GtkTextSearchFlags = ::std::os::raw::c_uint;
pub type GtkTextBuffer = _GtkTextBuffer;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTextIter {
pub dummy1: gpointer,
pub dummy2: gpointer,
pub dummy3: gint,
pub dummy4: gint,
pub dummy5: gint,
pub dummy6: gint,
pub dummy7: gint,
pub dummy8: gint,
pub dummy9: gpointer,
pub dummy10: gpointer,
pub dummy11: gint,
pub dummy12: gint,
pub dummy13: gint,
pub dummy14: gpointer,
}
#[test]
fn bindgen_test_layout__GtkTextIter() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTextIter> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTextIter>(),
80usize,
concat!("Size of: ", stringify!(_GtkTextIter))
);
assert_eq!(
::std::mem::align_of::<_GtkTextIter>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTextIter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dummy1) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextIter),
"::",
stringify!(dummy1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dummy2) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextIter),
"::",
stringify!(dummy2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dummy3) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextIter),
"::",
stringify!(dummy3)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dummy4) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextIter),
"::",
stringify!(dummy4)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dummy5) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextIter),
"::",
stringify!(dummy5)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dummy6) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextIter),
"::",
stringify!(dummy6)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dummy7) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextIter),
"::",
stringify!(dummy7)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dummy8) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextIter),
"::",
stringify!(dummy8)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dummy9) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextIter),
"::",
stringify!(dummy9)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dummy10) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextIter),
"::",
stringify!(dummy10)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dummy11) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextIter),
"::",
stringify!(dummy11)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dummy12) as usize - ptr as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextIter),
"::",
stringify!(dummy12)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dummy13) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextIter),
"::",
stringify!(dummy13)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dummy14) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextIter),
"::",
stringify!(dummy14)
)
);
}
impl Default for _GtkTextIter {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_text_iter_get_buffer(iter: *const GtkTextIter) -> *mut GtkTextBuffer;
}
extern "C" {
pub fn gtk_text_iter_copy(iter: *const GtkTextIter) -> *mut GtkTextIter;
}
extern "C" {
pub fn gtk_text_iter_free(iter: *mut GtkTextIter);
}
extern "C" {
pub fn gtk_text_iter_assign(iter: *mut GtkTextIter, other: *const GtkTextIter);
}
extern "C" {
pub fn gtk_text_iter_get_type() -> GType;
}
extern "C" {
pub fn gtk_text_iter_get_offset(iter: *const GtkTextIter) -> gint;
}
extern "C" {
pub fn gtk_text_iter_get_line(iter: *const GtkTextIter) -> gint;
}
extern "C" {
pub fn gtk_text_iter_get_line_offset(iter: *const GtkTextIter) -> gint;
}
extern "C" {
pub fn gtk_text_iter_get_line_index(iter: *const GtkTextIter) -> gint;
}
extern "C" {
pub fn gtk_text_iter_get_visible_line_offset(iter: *const GtkTextIter) -> gint;
}
extern "C" {
pub fn gtk_text_iter_get_visible_line_index(iter: *const GtkTextIter) -> gint;
}
extern "C" {
pub fn gtk_text_iter_get_char(iter: *const GtkTextIter) -> gunichar;
}
extern "C" {
pub fn gtk_text_iter_get_slice(
start: *const GtkTextIter,
end: *const GtkTextIter,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_text_iter_get_text(start: *const GtkTextIter, end: *const GtkTextIter)
-> *mut gchar;
}
extern "C" {
pub fn gtk_text_iter_get_visible_slice(
start: *const GtkTextIter,
end: *const GtkTextIter,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_text_iter_get_visible_text(
start: *const GtkTextIter,
end: *const GtkTextIter,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_text_iter_get_pixbuf(iter: *const GtkTextIter) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_text_iter_get_marks(iter: *const GtkTextIter) -> *mut GSList;
}
extern "C" {
pub fn gtk_text_iter_get_child_anchor(iter: *const GtkTextIter) -> *mut GtkTextChildAnchor;
}
extern "C" {
pub fn gtk_text_iter_get_toggled_tags(
iter: *const GtkTextIter,
toggled_on: gboolean,
) -> *mut GSList;
}
extern "C" {
pub fn gtk_text_iter_begins_tag(iter: *const GtkTextIter, tag: *mut GtkTextTag) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_ends_tag(iter: *const GtkTextIter, tag: *mut GtkTextTag) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_toggles_tag(iter: *const GtkTextIter, tag: *mut GtkTextTag) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_has_tag(iter: *const GtkTextIter, tag: *mut GtkTextTag) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_get_tags(iter: *const GtkTextIter) -> *mut GSList;
}
extern "C" {
pub fn gtk_text_iter_editable(iter: *const GtkTextIter, default_setting: gboolean) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_can_insert(
iter: *const GtkTextIter,
default_editability: gboolean,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_starts_word(iter: *const GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_ends_word(iter: *const GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_inside_word(iter: *const GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_starts_sentence(iter: *const GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_ends_sentence(iter: *const GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_inside_sentence(iter: *const GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_starts_line(iter: *const GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_ends_line(iter: *const GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_is_cursor_position(iter: *const GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_get_chars_in_line(iter: *const GtkTextIter) -> gint;
}
extern "C" {
pub fn gtk_text_iter_get_bytes_in_line(iter: *const GtkTextIter) -> gint;
}
extern "C" {
pub fn gtk_text_iter_get_attributes(
iter: *const GtkTextIter,
values: *mut GtkTextAttributes,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_get_language(iter: *const GtkTextIter) -> *mut PangoLanguage;
}
extern "C" {
pub fn gtk_text_iter_is_end(iter: *const GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_is_start(iter: *const GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_char(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_char(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_chars(iter: *mut GtkTextIter, count: gint) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_chars(iter: *mut GtkTextIter, count: gint) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_line(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_line(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_lines(iter: *mut GtkTextIter, count: gint) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_lines(iter: *mut GtkTextIter, count: gint) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_word_end(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_word_start(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_word_ends(iter: *mut GtkTextIter, count: gint) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_word_starts(iter: *mut GtkTextIter, count: gint) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_visible_line(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_visible_line(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_visible_lines(iter: *mut GtkTextIter, count: gint) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_visible_lines(iter: *mut GtkTextIter, count: gint) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_visible_word_end(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_visible_word_start(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_visible_word_ends(iter: *mut GtkTextIter, count: gint)
-> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_visible_word_starts(
iter: *mut GtkTextIter,
count: gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_sentence_end(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_sentence_start(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_sentence_ends(iter: *mut GtkTextIter, count: gint) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_sentence_starts(iter: *mut GtkTextIter, count: gint) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_cursor_position(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_cursor_position(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_cursor_positions(iter: *mut GtkTextIter, count: gint) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_cursor_positions(iter: *mut GtkTextIter, count: gint)
-> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_visible_cursor_position(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_visible_cursor_position(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_visible_cursor_positions(
iter: *mut GtkTextIter,
count: gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_visible_cursor_positions(
iter: *mut GtkTextIter,
count: gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_set_offset(iter: *mut GtkTextIter, char_offset: gint);
}
extern "C" {
pub fn gtk_text_iter_set_line(iter: *mut GtkTextIter, line_number: gint);
}
extern "C" {
pub fn gtk_text_iter_set_line_offset(iter: *mut GtkTextIter, char_on_line: gint);
}
extern "C" {
pub fn gtk_text_iter_set_line_index(iter: *mut GtkTextIter, byte_on_line: gint);
}
extern "C" {
pub fn gtk_text_iter_forward_to_end(iter: *mut GtkTextIter);
}
extern "C" {
pub fn gtk_text_iter_forward_to_line_end(iter: *mut GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_set_visible_line_offset(iter: *mut GtkTextIter, char_on_line: gint);
}
extern "C" {
pub fn gtk_text_iter_set_visible_line_index(iter: *mut GtkTextIter, byte_on_line: gint);
}
extern "C" {
pub fn gtk_text_iter_forward_to_tag_toggle(
iter: *mut GtkTextIter,
tag: *mut GtkTextTag,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_to_tag_toggle(
iter: *mut GtkTextIter,
tag: *mut GtkTextTag,
) -> gboolean;
}
pub type GtkTextCharPredicate =
::std::option::Option<unsafe extern "C" fn(ch: gunichar, user_data: gpointer) -> gboolean>;
extern "C" {
pub fn gtk_text_iter_forward_find_char(
iter: *mut GtkTextIter,
pred: GtkTextCharPredicate,
user_data: gpointer,
limit: *const GtkTextIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_find_char(
iter: *mut GtkTextIter,
pred: GtkTextCharPredicate,
user_data: gpointer,
limit: *const GtkTextIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_forward_search(
iter: *const GtkTextIter,
str_: *const gchar,
flags: GtkTextSearchFlags,
match_start: *mut GtkTextIter,
match_end: *mut GtkTextIter,
limit: *const GtkTextIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_backward_search(
iter: *const GtkTextIter,
str_: *const gchar,
flags: GtkTextSearchFlags,
match_start: *mut GtkTextIter,
match_end: *mut GtkTextIter,
limit: *const GtkTextIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_equal(lhs: *const GtkTextIter, rhs: *const GtkTextIter) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_compare(lhs: *const GtkTextIter, rhs: *const GtkTextIter) -> gint;
}
extern "C" {
pub fn gtk_text_iter_in_range(
iter: *const GtkTextIter,
start: *const GtkTextIter,
end: *const GtkTextIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_iter_order(first: *mut GtkTextIter, second: *mut GtkTextIter);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTargetList {
_unused: [u8; 0],
}
#[doc = " GtkTargetList:\n\n A #GtkTargetList-struct is a reference counted list\n of #GtkTargetPair and should be treated as\n opaque."]
pub type GtkTargetList = _GtkTargetList;
#[doc = " GtkTargetEntry:\n @target: a string representation of the target type\n @flags: #GtkTargetFlags for DND\n @info: an application-assigned integer ID which will\n get passed as a parameter to e.g the #GtkWidget::selection-get\n signal. It allows the application to identify the target\n type without extensive string compares.\n\n A #GtkTargetEntry represents a single type of\n data than can be supplied for by a widget for a selection\n or for supplied or received during drag-and-drop."]
pub type GtkTargetEntry = _GtkTargetEntry;
#[doc = " GtkTargetEntry:\n @target: a string representation of the target type\n @flags: #GtkTargetFlags for DND\n @info: an application-assigned integer ID which will\n get passed as a parameter to e.g the #GtkWidget::selection-get\n signal. It allows the application to identify the target\n type without extensive string compares.\n\n A #GtkTargetEntry represents a single type of\n data than can be supplied for by a widget for a selection\n or for supplied or received during drag-and-drop."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTargetEntry {
pub target: *mut gchar,
pub flags: guint,
pub info: guint,
}
#[test]
fn bindgen_test_layout__GtkTargetEntry() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTargetEntry> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTargetEntry>(),
16usize,
concat!("Size of: ", stringify!(_GtkTargetEntry))
);
assert_eq!(
::std::mem::align_of::<_GtkTargetEntry>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTargetEntry))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTargetEntry),
"::",
stringify!(target)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkTargetEntry),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).info) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_GtkTargetEntry),
"::",
stringify!(info)
)
);
}
impl Default for _GtkTargetEntry {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_target_list_get_type() -> GType;
}
extern "C" {
pub fn gtk_target_list_new(
targets: *const GtkTargetEntry,
ntargets: guint,
) -> *mut GtkTargetList;
}
extern "C" {
pub fn gtk_target_list_ref(list: *mut GtkTargetList) -> *mut GtkTargetList;
}
extern "C" {
pub fn gtk_target_list_unref(list: *mut GtkTargetList);
}
extern "C" {
pub fn gtk_target_list_add(
list: *mut GtkTargetList,
target: GdkAtom,
flags: guint,
info: guint,
);
}
extern "C" {
pub fn gtk_target_list_add_text_targets(list: *mut GtkTargetList, info: guint);
}
extern "C" {
pub fn gtk_target_list_add_rich_text_targets(
list: *mut GtkTargetList,
info: guint,
deserializable: gboolean,
buffer: *mut GtkTextBuffer,
);
}
extern "C" {
pub fn gtk_target_list_add_image_targets(
list: *mut GtkTargetList,
info: guint,
writable: gboolean,
);
}
extern "C" {
pub fn gtk_target_list_add_uri_targets(list: *mut GtkTargetList, info: guint);
}
extern "C" {
pub fn gtk_target_list_add_table(
list: *mut GtkTargetList,
targets: *const GtkTargetEntry,
ntargets: guint,
);
}
extern "C" {
pub fn gtk_target_list_remove(list: *mut GtkTargetList, target: GdkAtom);
}
extern "C" {
pub fn gtk_target_list_find(
list: *mut GtkTargetList,
target: GdkAtom,
info: *mut guint,
) -> gboolean;
}
extern "C" {
pub fn gtk_target_table_new_from_list(
list: *mut GtkTargetList,
n_targets: *mut gint,
) -> *mut GtkTargetEntry;
}
extern "C" {
pub fn gtk_target_table_free(targets: *mut GtkTargetEntry, n_targets: gint);
}
extern "C" {
pub fn gtk_selection_owner_set(
widget: *mut GtkWidget,
selection: GdkAtom,
time_: guint32,
) -> gboolean;
}
extern "C" {
pub fn gtk_selection_owner_set_for_display(
display: *mut GdkDisplay,
widget: *mut GtkWidget,
selection: GdkAtom,
time_: guint32,
) -> gboolean;
}
extern "C" {
pub fn gtk_selection_add_target(
widget: *mut GtkWidget,
selection: GdkAtom,
target: GdkAtom,
info: guint,
);
}
extern "C" {
pub fn gtk_selection_add_targets(
widget: *mut GtkWidget,
selection: GdkAtom,
targets: *const GtkTargetEntry,
ntargets: guint,
);
}
extern "C" {
pub fn gtk_selection_clear_targets(widget: *mut GtkWidget, selection: GdkAtom);
}
extern "C" {
pub fn gtk_selection_convert(
widget: *mut GtkWidget,
selection: GdkAtom,
target: GdkAtom,
time_: guint32,
) -> gboolean;
}
extern "C" {
pub fn gtk_selection_remove_all(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_selection_data_get_selection(selection_data: *const GtkSelectionData) -> GdkAtom;
}
extern "C" {
pub fn gtk_selection_data_get_target(selection_data: *const GtkSelectionData) -> GdkAtom;
}
extern "C" {
pub fn gtk_selection_data_get_data_type(selection_data: *const GtkSelectionData) -> GdkAtom;
}
extern "C" {
pub fn gtk_selection_data_get_format(selection_data: *const GtkSelectionData) -> gint;
}
extern "C" {
pub fn gtk_selection_data_get_data(selection_data: *const GtkSelectionData) -> *const guchar;
}
extern "C" {
pub fn gtk_selection_data_get_length(selection_data: *const GtkSelectionData) -> gint;
}
extern "C" {
pub fn gtk_selection_data_get_data_with_length(
selection_data: *const GtkSelectionData,
length: *mut gint,
) -> *const guchar;
}
extern "C" {
pub fn gtk_selection_data_get_display(
selection_data: *const GtkSelectionData,
) -> *mut GdkDisplay;
}
extern "C" {
pub fn gtk_selection_data_set(
selection_data: *mut GtkSelectionData,
type_: GdkAtom,
format: gint,
data: *const guchar,
length: gint,
);
}
extern "C" {
pub fn gtk_selection_data_set_text(
selection_data: *mut GtkSelectionData,
str_: *const gchar,
len: gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_selection_data_get_text(selection_data: *const GtkSelectionData) -> *mut guchar;
}
extern "C" {
pub fn gtk_selection_data_set_pixbuf(
selection_data: *mut GtkSelectionData,
pixbuf: *mut GdkPixbuf,
) -> gboolean;
}
extern "C" {
pub fn gtk_selection_data_get_pixbuf(selection_data: *const GtkSelectionData)
-> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_selection_data_set_uris(
selection_data: *mut GtkSelectionData,
uris: *mut *mut gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_selection_data_get_uris(selection_data: *const GtkSelectionData) -> *mut *mut gchar;
}
extern "C" {
pub fn gtk_selection_data_get_targets(
selection_data: *const GtkSelectionData,
targets: *mut *mut GdkAtom,
n_atoms: *mut gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_selection_data_targets_include_text(
selection_data: *const GtkSelectionData,
) -> gboolean;
}
extern "C" {
pub fn gtk_selection_data_targets_include_rich_text(
selection_data: *const GtkSelectionData,
buffer: *mut GtkTextBuffer,
) -> gboolean;
}
extern "C" {
pub fn gtk_selection_data_targets_include_image(
selection_data: *const GtkSelectionData,
writable: gboolean,
) -> gboolean;
}
extern "C" {
pub fn gtk_selection_data_targets_include_uri(
selection_data: *const GtkSelectionData,
) -> gboolean;
}
extern "C" {
pub fn gtk_targets_include_text(targets: *mut GdkAtom, n_targets: gint) -> gboolean;
}
extern "C" {
pub fn gtk_targets_include_rich_text(
targets: *mut GdkAtom,
n_targets: gint,
buffer: *mut GtkTextBuffer,
) -> gboolean;
}
extern "C" {
pub fn gtk_targets_include_image(
targets: *mut GdkAtom,
n_targets: gint,
writable: gboolean,
) -> gboolean;
}
extern "C" {
pub fn gtk_targets_include_uri(targets: *mut GdkAtom, n_targets: gint) -> gboolean;
}
extern "C" {
pub fn gtk_selection_data_get_type() -> GType;
}
extern "C" {
pub fn gtk_selection_data_copy(data: *const GtkSelectionData) -> *mut GtkSelectionData;
}
extern "C" {
pub fn gtk_selection_data_free(data: *mut GtkSelectionData);
}
extern "C" {
pub fn gtk_target_entry_get_type() -> GType;
}
extern "C" {
pub fn gtk_target_entry_new(
target: *const gchar,
flags: guint,
info: guint,
) -> *mut GtkTargetEntry;
}
extern "C" {
pub fn gtk_target_entry_copy(data: *mut GtkTargetEntry) -> *mut GtkTargetEntry;
}
extern "C" {
pub fn gtk_target_entry_free(data: *mut GtkTargetEntry);
}
pub const GtkDestDefaults_GTK_DEST_DEFAULT_MOTION: GtkDestDefaults = 1;
pub const GtkDestDefaults_GTK_DEST_DEFAULT_HIGHLIGHT: GtkDestDefaults = 2;
pub const GtkDestDefaults_GTK_DEST_DEFAULT_DROP: GtkDestDefaults = 4;
pub const GtkDestDefaults_GTK_DEST_DEFAULT_ALL: GtkDestDefaults = 7;
#[doc = " GtkDestDefaults:\n @GTK_DEST_DEFAULT_MOTION: If set for a widget, GTK+, during a drag over this\n widget will check if the drag matches this widget’s list of possible targets\n and actions.\n GTK+ will then call gdk_drag_status() as appropriate.\n @GTK_DEST_DEFAULT_HIGHLIGHT: If set for a widget, GTK+ will draw a highlight on\n this widget as long as a drag is over this widget and the widget drag format\n and action are acceptable.\n @GTK_DEST_DEFAULT_DROP: If set for a widget, when a drop occurs, GTK+ will\n will check if the drag matches this widget’s list of possible targets and\n actions. If so, GTK+ will call gtk_drag_get_data() on behalf of the widget.\n Whether or not the drop is successful, GTK+ will call gtk_drag_finish(). If\n the action was a move, then if the drag was successful, then %TRUE will be\n passed for the @delete parameter to gtk_drag_finish().\n @GTK_DEST_DEFAULT_ALL: If set, specifies that all default actions should\n be taken.\n\n The #GtkDestDefaults enumeration specifies the various\n types of action that will be taken on behalf\n of the user for a drag destination site."]
pub type GtkDestDefaults = ::std::os::raw::c_uint;
extern "C" {
pub fn gtk_drag_get_data(
widget: *mut GtkWidget,
context: *mut GdkDragContext,
target: GdkAtom,
time_: guint32,
);
}
extern "C" {
pub fn gtk_drag_finish(
context: *mut GdkDragContext,
success: gboolean,
del: gboolean,
time_: guint32,
);
}
extern "C" {
pub fn gtk_drag_get_source_widget(context: *mut GdkDragContext) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_drag_highlight(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_drag_unhighlight(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_drag_dest_set(
widget: *mut GtkWidget,
flags: GtkDestDefaults,
targets: *const GtkTargetEntry,
n_targets: gint,
actions: GdkDragAction,
);
}
extern "C" {
pub fn gtk_drag_dest_set_proxy(
widget: *mut GtkWidget,
proxy_window: *mut GdkWindow,
protocol: GdkDragProtocol,
use_coordinates: gboolean,
);
}
extern "C" {
pub fn gtk_drag_dest_unset(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_drag_dest_find_target(
widget: *mut GtkWidget,
context: *mut GdkDragContext,
target_list: *mut GtkTargetList,
) -> GdkAtom;
}
extern "C" {
pub fn gtk_drag_dest_get_target_list(widget: *mut GtkWidget) -> *mut GtkTargetList;
}
extern "C" {
pub fn gtk_drag_dest_set_target_list(widget: *mut GtkWidget, target_list: *mut GtkTargetList);
}
extern "C" {
pub fn gtk_drag_dest_add_text_targets(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_drag_dest_add_image_targets(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_drag_dest_add_uri_targets(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_drag_dest_set_track_motion(widget: *mut GtkWidget, track_motion: gboolean);
}
extern "C" {
pub fn gtk_drag_dest_get_track_motion(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_drag_source_set(
widget: *mut GtkWidget,
start_button_mask: GdkModifierType,
targets: *const GtkTargetEntry,
n_targets: gint,
actions: GdkDragAction,
);
}
extern "C" {
pub fn gtk_drag_source_unset(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_drag_source_get_target_list(widget: *mut GtkWidget) -> *mut GtkTargetList;
}
extern "C" {
pub fn gtk_drag_source_set_target_list(widget: *mut GtkWidget, target_list: *mut GtkTargetList);
}
extern "C" {
pub fn gtk_drag_source_add_text_targets(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_drag_source_add_image_targets(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_drag_source_add_uri_targets(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_drag_source_set_icon_pixbuf(widget: *mut GtkWidget, pixbuf: *mut GdkPixbuf);
}
extern "C" {
pub fn gtk_drag_source_set_icon_stock(widget: *mut GtkWidget, stock_id: *const gchar);
}
extern "C" {
pub fn gtk_drag_source_set_icon_name(widget: *mut GtkWidget, icon_name: *const gchar);
}
extern "C" {
pub fn gtk_drag_source_set_icon_gicon(widget: *mut GtkWidget, icon: *mut GIcon);
}
extern "C" {
pub fn gtk_drag_begin_with_coordinates(
widget: *mut GtkWidget,
targets: *mut GtkTargetList,
actions: GdkDragAction,
button: gint,
event: *mut GdkEvent,
x: gint,
y: gint,
) -> *mut GdkDragContext;
}
extern "C" {
pub fn gtk_drag_begin(
widget: *mut GtkWidget,
targets: *mut GtkTargetList,
actions: GdkDragAction,
button: gint,
event: *mut GdkEvent,
) -> *mut GdkDragContext;
}
extern "C" {
pub fn gtk_drag_set_icon_widget(
context: *mut GdkDragContext,
widget: *mut GtkWidget,
hot_x: gint,
hot_y: gint,
);
}
extern "C" {
pub fn gtk_drag_set_icon_pixbuf(
context: *mut GdkDragContext,
pixbuf: *mut GdkPixbuf,
hot_x: gint,
hot_y: gint,
);
}
extern "C" {
pub fn gtk_drag_set_icon_stock(
context: *mut GdkDragContext,
stock_id: *const gchar,
hot_x: gint,
hot_y: gint,
);
}
extern "C" {
pub fn gtk_drag_set_icon_surface(context: *mut GdkDragContext, surface: *mut cairo_surface_t);
}
extern "C" {
pub fn gtk_drag_set_icon_name(
context: *mut GdkDragContext,
icon_name: *const gchar,
hot_x: gint,
hot_y: gint,
);
}
extern "C" {
pub fn gtk_drag_set_icon_gicon(
context: *mut GdkDragContext,
icon: *mut GIcon,
hot_x: gint,
hot_y: gint,
);
}
extern "C" {
pub fn gtk_drag_set_icon_default(context: *mut GdkDragContext);
}
extern "C" {
pub fn gtk_drag_check_threshold(
widget: *mut GtkWidget,
start_x: gint,
start_y: gint,
current_x: gint,
current_y: gint,
) -> gboolean;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkEditable {
_unused: [u8; 0],
}
pub type GtkEditable = _GtkEditable;
extern "C" {
pub fn gtk_editable_get_type() -> GType;
}
extern "C" {
pub fn gtk_editable_select_region(editable: *mut GtkEditable, start_pos: gint, end_pos: gint);
}
extern "C" {
pub fn gtk_editable_get_selection_bounds(
editable: *mut GtkEditable,
start_pos: *mut gint,
end_pos: *mut gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_editable_insert_text(
editable: *mut GtkEditable,
new_text: *const gchar,
new_text_length: gint,
position: *mut gint,
);
}
extern "C" {
pub fn gtk_editable_delete_text(editable: *mut GtkEditable, start_pos: gint, end_pos: gint);
}
extern "C" {
pub fn gtk_editable_get_chars(
editable: *mut GtkEditable,
start_pos: gint,
end_pos: gint,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_editable_cut_clipboard(editable: *mut GtkEditable);
}
extern "C" {
pub fn gtk_editable_copy_clipboard(editable: *mut GtkEditable);
}
extern "C" {
pub fn gtk_editable_paste_clipboard(editable: *mut GtkEditable);
}
extern "C" {
pub fn gtk_editable_delete_selection(editable: *mut GtkEditable);
}
extern "C" {
pub fn gtk_editable_set_position(editable: *mut GtkEditable, position: gint);
}
extern "C" {
pub fn gtk_editable_get_position(editable: *mut GtkEditable) -> gint;
}
extern "C" {
pub fn gtk_editable_set_editable(editable: *mut GtkEditable, is_editable: gboolean);
}
extern "C" {
pub fn gtk_editable_get_editable(editable: *mut GtkEditable) -> gboolean;
}
pub type GtkIMContext = _GtkIMContext;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkIMContext {
pub parent_instance: GObject,
}
#[test]
fn bindgen_test_layout__GtkIMContext() {
const UNINIT: ::std::mem::MaybeUninit<_GtkIMContext> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkIMContext>(),
24usize,
concat!("Size of: ", stringify!(_GtkIMContext))
);
assert_eq!(
::std::mem::align_of::<_GtkIMContext>(),
8usize,
concat!("Alignment of ", stringify!(_GtkIMContext))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkIMContext),
"::",
stringify!(parent_instance)
)
);
}
impl Default for _GtkIMContext {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_im_context_get_type() -> GType;
}
extern "C" {
pub fn gtk_im_context_set_client_window(context: *mut GtkIMContext, window: *mut GdkWindow);
}
extern "C" {
pub fn gtk_im_context_get_preedit_string(
context: *mut GtkIMContext,
str_: *mut *mut gchar,
attrs: *mut *mut PangoAttrList,
cursor_pos: *mut gint,
);
}
extern "C" {
pub fn gtk_im_context_filter_keypress(
context: *mut GtkIMContext,
event: *mut GdkEventKey,
) -> gboolean;
}
extern "C" {
pub fn gtk_im_context_focus_in(context: *mut GtkIMContext);
}
extern "C" {
pub fn gtk_im_context_focus_out(context: *mut GtkIMContext);
}
extern "C" {
pub fn gtk_im_context_reset(context: *mut GtkIMContext);
}
extern "C" {
pub fn gtk_im_context_set_cursor_location(
context: *mut GtkIMContext,
area: *const GdkRectangle,
);
}
extern "C" {
pub fn gtk_im_context_set_use_preedit(context: *mut GtkIMContext, use_preedit: gboolean);
}
extern "C" {
pub fn gtk_im_context_set_surrounding(
context: *mut GtkIMContext,
text: *const gchar,
len: gint,
cursor_index: gint,
);
}
extern "C" {
pub fn gtk_im_context_get_surrounding(
context: *mut GtkIMContext,
text: *mut *mut gchar,
cursor_index: *mut gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_im_context_delete_surrounding(
context: *mut GtkIMContext,
offset: gint,
n_chars: gint,
) -> gboolean;
}
pub type GtkEntryBuffer = _GtkEntryBuffer;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkEntryBufferPrivate {
_unused: [u8; 0],
}
pub type GtkEntryBufferPrivate = _GtkEntryBufferPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkEntryBuffer {
pub parent_instance: GObject,
pub priv_: *mut GtkEntryBufferPrivate,
}
#[test]
fn bindgen_test_layout__GtkEntryBuffer() {
const UNINIT: ::std::mem::MaybeUninit<_GtkEntryBuffer> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkEntryBuffer>(),
32usize,
concat!("Size of: ", stringify!(_GtkEntryBuffer))
);
assert_eq!(
::std::mem::align_of::<_GtkEntryBuffer>(),
8usize,
concat!("Alignment of ", stringify!(_GtkEntryBuffer))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkEntryBuffer),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkEntryBuffer),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkEntryBuffer {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_entry_buffer_get_type() -> GType;
}
extern "C" {
pub fn gtk_entry_buffer_new(
initial_chars: *const gchar,
n_initial_chars: gint,
) -> *mut GtkEntryBuffer;
}
extern "C" {
pub fn gtk_entry_buffer_get_bytes(buffer: *mut GtkEntryBuffer) -> gsize;
}
extern "C" {
pub fn gtk_entry_buffer_get_length(buffer: *mut GtkEntryBuffer) -> guint;
}
extern "C" {
pub fn gtk_entry_buffer_get_text(buffer: *mut GtkEntryBuffer) -> *const gchar;
}
extern "C" {
pub fn gtk_entry_buffer_set_text(
buffer: *mut GtkEntryBuffer,
chars: *const gchar,
n_chars: gint,
);
}
extern "C" {
pub fn gtk_entry_buffer_set_max_length(buffer: *mut GtkEntryBuffer, max_length: gint);
}
extern "C" {
pub fn gtk_entry_buffer_get_max_length(buffer: *mut GtkEntryBuffer) -> gint;
}
extern "C" {
pub fn gtk_entry_buffer_insert_text(
buffer: *mut GtkEntryBuffer,
position: guint,
chars: *const gchar,
n_chars: gint,
) -> guint;
}
extern "C" {
pub fn gtk_entry_buffer_delete_text(
buffer: *mut GtkEntryBuffer,
position: guint,
n_chars: gint,
) -> guint;
}
extern "C" {
pub fn gtk_entry_buffer_emit_inserted_text(
buffer: *mut GtkEntryBuffer,
position: guint,
chars: *const gchar,
n_chars: guint,
);
}
extern "C" {
pub fn gtk_entry_buffer_emit_deleted_text(
buffer: *mut GtkEntryBuffer,
position: guint,
n_chars: guint,
);
}
pub type GtkListStore = _GtkListStore;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkListStorePrivate {
_unused: [u8; 0],
}
pub type GtkListStorePrivate = _GtkListStorePrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkListStore {
pub parent: GObject,
pub priv_: *mut GtkListStorePrivate,
}
#[test]
fn bindgen_test_layout__GtkListStore() {
const UNINIT: ::std::mem::MaybeUninit<_GtkListStore> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkListStore>(),
32usize,
concat!("Size of: ", stringify!(_GtkListStore))
);
assert_eq!(
::std::mem::align_of::<_GtkListStore>(),
8usize,
concat!("Alignment of ", stringify!(_GtkListStore))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkListStore),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkListStore),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkListStore {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_list_store_get_type() -> GType;
}
extern "C" {
pub fn gtk_list_store_new(n_columns: gint, ...) -> *mut GtkListStore;
}
extern "C" {
pub fn gtk_list_store_newv(n_columns: gint, types: *mut GType) -> *mut GtkListStore;
}
extern "C" {
pub fn gtk_list_store_set_column_types(
list_store: *mut GtkListStore,
n_columns: gint,
types: *mut GType,
);
}
extern "C" {
pub fn gtk_list_store_set_value(
list_store: *mut GtkListStore,
iter: *mut GtkTreeIter,
column: gint,
value: *mut GValue,
);
}
extern "C" {
pub fn gtk_list_store_set(list_store: *mut GtkListStore, iter: *mut GtkTreeIter, ...);
}
extern "C" {
pub fn gtk_list_store_set_valuesv(
list_store: *mut GtkListStore,
iter: *mut GtkTreeIter,
columns: *mut gint,
values: *mut GValue,
n_values: gint,
);
}
extern "C" {
pub fn gtk_list_store_remove(list_store: *mut GtkListStore, iter: *mut GtkTreeIter)
-> gboolean;
}
extern "C" {
pub fn gtk_list_store_insert(
list_store: *mut GtkListStore,
iter: *mut GtkTreeIter,
position: gint,
);
}
extern "C" {
pub fn gtk_list_store_insert_before(
list_store: *mut GtkListStore,
iter: *mut GtkTreeIter,
sibling: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_list_store_insert_after(
list_store: *mut GtkListStore,
iter: *mut GtkTreeIter,
sibling: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_list_store_insert_with_values(
list_store: *mut GtkListStore,
iter: *mut GtkTreeIter,
position: gint,
...
);
}
extern "C" {
pub fn gtk_list_store_insert_with_valuesv(
list_store: *mut GtkListStore,
iter: *mut GtkTreeIter,
position: gint,
columns: *mut gint,
values: *mut GValue,
n_values: gint,
);
}
extern "C" {
pub fn gtk_list_store_prepend(list_store: *mut GtkListStore, iter: *mut GtkTreeIter);
}
extern "C" {
pub fn gtk_list_store_append(list_store: *mut GtkListStore, iter: *mut GtkTreeIter);
}
extern "C" {
pub fn gtk_list_store_clear(list_store: *mut GtkListStore);
}
extern "C" {
pub fn gtk_list_store_iter_is_valid(
list_store: *mut GtkListStore,
iter: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_list_store_reorder(store: *mut GtkListStore, new_order: *mut gint);
}
extern "C" {
pub fn gtk_list_store_swap(store: *mut GtkListStore, a: *mut GtkTreeIter, b: *mut GtkTreeIter);
}
extern "C" {
pub fn gtk_list_store_move_after(
store: *mut GtkListStore,
iter: *mut GtkTreeIter,
position: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_list_store_move_before(
store: *mut GtkListStore,
iter: *mut GtkTreeIter,
position: *mut GtkTreeIter,
);
}
#[doc = " GtkTreeModelFilterVisibleFunc:\n @model: the child model of the #GtkTreeModelFilter\n @iter: a #GtkTreeIter pointing to the row in @model whose visibility\n is determined\n @data: (closure): user data given to gtk_tree_model_filter_set_visible_func()\n\n A function which decides whether the row indicated by @iter is visible.\n\n Returns: Whether the row indicated by @iter is visible."]
pub type GtkTreeModelFilterVisibleFunc = ::std::option::Option<
unsafe extern "C" fn(
model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
data: gpointer,
) -> gboolean,
>;
#[doc = " GtkTreeModelFilterModifyFunc:\n @model: the #GtkTreeModelFilter\n @iter: a #GtkTreeIter pointing to the row whose display values are determined\n @value: (out caller-allocates): A #GValue which is already initialized for\n with the correct type for the column @column.\n @column: the column whose display value is determined\n @data: (closure): user data given to gtk_tree_model_filter_set_modify_func()\n\n A function which calculates display values from raw values in the model.\n It must fill @value with the display value for the column @column in the\n row indicated by @iter.\n\n Since this function is called for each data access, it’s not a\n particularly efficient operation."]
pub type GtkTreeModelFilterModifyFunc = ::std::option::Option<
unsafe extern "C" fn(
model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
value: *mut GValue,
column: gint,
data: gpointer,
),
>;
pub type GtkTreeModelFilter = _GtkTreeModelFilter;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeModelFilterPrivate {
_unused: [u8; 0],
}
pub type GtkTreeModelFilterPrivate = _GtkTreeModelFilterPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeModelFilter {
pub parent: GObject,
pub priv_: *mut GtkTreeModelFilterPrivate,
}
#[test]
fn bindgen_test_layout__GtkTreeModelFilter() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTreeModelFilter> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTreeModelFilter>(),
32usize,
concat!("Size of: ", stringify!(_GtkTreeModelFilter))
);
assert_eq!(
::std::mem::align_of::<_GtkTreeModelFilter>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTreeModelFilter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeModelFilter),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeModelFilter),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkTreeModelFilter {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_tree_model_filter_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_model_filter_new(
child_model: *mut GtkTreeModel,
root: *mut GtkTreePath,
) -> *mut GtkTreeModel;
}
extern "C" {
pub fn gtk_tree_model_filter_set_visible_func(
filter: *mut GtkTreeModelFilter,
func: GtkTreeModelFilterVisibleFunc,
data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_tree_model_filter_set_modify_func(
filter: *mut GtkTreeModelFilter,
n_columns: gint,
types: *mut GType,
func: GtkTreeModelFilterModifyFunc,
data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_tree_model_filter_set_visible_column(filter: *mut GtkTreeModelFilter, column: gint);
}
extern "C" {
pub fn gtk_tree_model_filter_get_model(filter: *mut GtkTreeModelFilter) -> *mut GtkTreeModel;
}
extern "C" {
pub fn gtk_tree_model_filter_convert_child_iter_to_iter(
filter: *mut GtkTreeModelFilter,
filter_iter: *mut GtkTreeIter,
child_iter: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_model_filter_convert_iter_to_child_iter(
filter: *mut GtkTreeModelFilter,
child_iter: *mut GtkTreeIter,
filter_iter: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_tree_model_filter_convert_child_path_to_path(
filter: *mut GtkTreeModelFilter,
child_path: *mut GtkTreePath,
) -> *mut GtkTreePath;
}
extern "C" {
pub fn gtk_tree_model_filter_convert_path_to_child_path(
filter: *mut GtkTreeModelFilter,
filter_path: *mut GtkTreePath,
) -> *mut GtkTreePath;
}
extern "C" {
pub fn gtk_tree_model_filter_refilter(filter: *mut GtkTreeModelFilter);
}
extern "C" {
pub fn gtk_tree_model_filter_clear_cache(filter: *mut GtkTreeModelFilter);
}
pub type GtkEntryCompletion = _GtkEntryCompletion;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkEntryCompletionPrivate {
_unused: [u8; 0],
}
pub type GtkEntryCompletionPrivate = _GtkEntryCompletionPrivate;
#[doc = " GtkEntryCompletionMatchFunc:\n @completion: the #GtkEntryCompletion\n @key: the string to match, normalized and case-folded\n @iter: a #GtkTreeIter indicating the row to match\n @user_data: user data given to gtk_entry_completion_set_match_func()\n\n A function which decides whether the row indicated by @iter matches\n a given @key, and should be displayed as a possible completion for @key.\n Note that @key is normalized and case-folded (see g_utf8_normalize()\n and g_utf8_casefold()). If this is not appropriate, match functions\n have access to the unmodified key via\n `gtk_entry_get_text (GTK_ENTRY (gtk_entry_completion_get_entry ()))`.\n\n Returns: %TRUE if @iter should be displayed as a possible completion\n for @key"]
pub type GtkEntryCompletionMatchFunc = ::std::option::Option<
unsafe extern "C" fn(
completion: *mut GtkEntryCompletion,
key: *const gchar,
iter: *mut GtkTreeIter,
user_data: gpointer,
) -> gboolean,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkEntryCompletion {
pub parent_instance: GObject,
pub priv_: *mut GtkEntryCompletionPrivate,
}
#[test]
fn bindgen_test_layout__GtkEntryCompletion() {
const UNINIT: ::std::mem::MaybeUninit<_GtkEntryCompletion> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkEntryCompletion>(),
32usize,
concat!("Size of: ", stringify!(_GtkEntryCompletion))
);
assert_eq!(
::std::mem::align_of::<_GtkEntryCompletion>(),
8usize,
concat!("Alignment of ", stringify!(_GtkEntryCompletion))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkEntryCompletion),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkEntryCompletion),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkEntryCompletion {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_entry_completion_get_type() -> GType;
}
extern "C" {
pub fn gtk_entry_completion_new() -> *mut GtkEntryCompletion;
}
extern "C" {
pub fn gtk_entry_completion_new_with_area(area: *mut GtkCellArea) -> *mut GtkEntryCompletion;
}
extern "C" {
pub fn gtk_entry_completion_get_entry(completion: *mut GtkEntryCompletion) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_entry_completion_set_model(
completion: *mut GtkEntryCompletion,
model: *mut GtkTreeModel,
);
}
extern "C" {
pub fn gtk_entry_completion_get_model(completion: *mut GtkEntryCompletion)
-> *mut GtkTreeModel;
}
extern "C" {
pub fn gtk_entry_completion_set_match_func(
completion: *mut GtkEntryCompletion,
func: GtkEntryCompletionMatchFunc,
func_data: gpointer,
func_notify: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_entry_completion_set_minimum_key_length(
completion: *mut GtkEntryCompletion,
length: gint,
);
}
extern "C" {
pub fn gtk_entry_completion_get_minimum_key_length(completion: *mut GtkEntryCompletion)
-> gint;
}
extern "C" {
pub fn gtk_entry_completion_compute_prefix(
completion: *mut GtkEntryCompletion,
key: *const ::std::os::raw::c_char,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_entry_completion_complete(completion: *mut GtkEntryCompletion);
}
extern "C" {
pub fn gtk_entry_completion_insert_prefix(completion: *mut GtkEntryCompletion);
}
extern "C" {
pub fn gtk_entry_completion_insert_action_text(
completion: *mut GtkEntryCompletion,
index_: gint,
text: *const gchar,
);
}
extern "C" {
pub fn gtk_entry_completion_insert_action_markup(
completion: *mut GtkEntryCompletion,
index_: gint,
markup: *const gchar,
);
}
extern "C" {
pub fn gtk_entry_completion_delete_action(completion: *mut GtkEntryCompletion, index_: gint);
}
extern "C" {
pub fn gtk_entry_completion_set_inline_completion(
completion: *mut GtkEntryCompletion,
inline_completion: gboolean,
);
}
extern "C" {
pub fn gtk_entry_completion_get_inline_completion(
completion: *mut GtkEntryCompletion,
) -> gboolean;
}
extern "C" {
pub fn gtk_entry_completion_set_inline_selection(
completion: *mut GtkEntryCompletion,
inline_selection: gboolean,
);
}
extern "C" {
pub fn gtk_entry_completion_get_inline_selection(
completion: *mut GtkEntryCompletion,
) -> gboolean;
}
extern "C" {
pub fn gtk_entry_completion_set_popup_completion(
completion: *mut GtkEntryCompletion,
popup_completion: gboolean,
);
}
extern "C" {
pub fn gtk_entry_completion_get_popup_completion(
completion: *mut GtkEntryCompletion,
) -> gboolean;
}
extern "C" {
pub fn gtk_entry_completion_set_popup_set_width(
completion: *mut GtkEntryCompletion,
popup_set_width: gboolean,
);
}
extern "C" {
pub fn gtk_entry_completion_get_popup_set_width(
completion: *mut GtkEntryCompletion,
) -> gboolean;
}
extern "C" {
pub fn gtk_entry_completion_set_popup_single_match(
completion: *mut GtkEntryCompletion,
popup_single_match: gboolean,
);
}
extern "C" {
pub fn gtk_entry_completion_get_popup_single_match(
completion: *mut GtkEntryCompletion,
) -> gboolean;
}
extern "C" {
pub fn gtk_entry_completion_get_completion_prefix(
completion: *mut GtkEntryCompletion,
) -> *const gchar;
}
extern "C" {
pub fn gtk_entry_completion_set_text_column(completion: *mut GtkEntryCompletion, column: gint);
}
extern "C" {
pub fn gtk_entry_completion_get_text_column(completion: *mut GtkEntryCompletion) -> gint;
}
#[doc = " GtkImage:\n\n This struct contain private data only and should be accessed by the functions\n below."]
pub type GtkImage = _GtkImage;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkImagePrivate {
_unused: [u8; 0],
}
pub type GtkImagePrivate = _GtkImagePrivate;
pub const GtkImageType_GTK_IMAGE_EMPTY: GtkImageType = 0;
pub const GtkImageType_GTK_IMAGE_PIXBUF: GtkImageType = 1;
pub const GtkImageType_GTK_IMAGE_STOCK: GtkImageType = 2;
pub const GtkImageType_GTK_IMAGE_ICON_SET: GtkImageType = 3;
pub const GtkImageType_GTK_IMAGE_ANIMATION: GtkImageType = 4;
pub const GtkImageType_GTK_IMAGE_ICON_NAME: GtkImageType = 5;
pub const GtkImageType_GTK_IMAGE_GICON: GtkImageType = 6;
pub const GtkImageType_GTK_IMAGE_SURFACE: GtkImageType = 7;
#[doc = " GtkImageType:\n @GTK_IMAGE_EMPTY: there is no image displayed by the widget\n @GTK_IMAGE_PIXBUF: the widget contains a #GdkPixbuf\n @GTK_IMAGE_STOCK: the widget contains a [stock item name][gtkstock]\n @GTK_IMAGE_ICON_SET: the widget contains a #GtkIconSet\n @GTK_IMAGE_ANIMATION: the widget contains a #GdkPixbufAnimation\n @GTK_IMAGE_ICON_NAME: the widget contains a named icon.\n This image type was added in GTK+ 2.6\n @GTK_IMAGE_GICON: the widget contains a #GIcon.\n This image type was added in GTK+ 2.14\n @GTK_IMAGE_SURFACE: the widget contains a #cairo_surface_t.\n This image type was added in GTK+ 3.10\n\n Describes the image data representation used by a #GtkImage. If you\n want to get the image from the widget, you can only get the\n currently-stored representation. e.g. if the\n gtk_image_get_storage_type() returns #GTK_IMAGE_PIXBUF, then you can\n call gtk_image_get_pixbuf() but not gtk_image_get_stock(). For empty\n images, you can request any storage type (call any of the \"get\"\n functions), but they will all return %NULL values."]
pub type GtkImageType = ::std::os::raw::c_uint;
#[doc = " GtkImage:\n\n This struct contain private data only and should be accessed by the functions\n below."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkImage {
pub misc: GtkMisc,
pub priv_: *mut GtkImagePrivate,
}
#[test]
fn bindgen_test_layout__GtkImage() {
const UNINIT: ::std::mem::MaybeUninit<_GtkImage> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkImage>(),
48usize,
concat!("Size of: ", stringify!(_GtkImage))
);
assert_eq!(
::std::mem::align_of::<_GtkImage>(),
8usize,
concat!("Alignment of ", stringify!(_GtkImage))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).misc) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkImage),
"::",
stringify!(misc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkImage),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkImage {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_image_get_type() -> GType;
}
extern "C" {
pub fn gtk_image_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_image_new_from_file(filename: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_image_new_from_resource(resource_path: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_image_new_from_pixbuf(pixbuf: *mut GdkPixbuf) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_image_new_from_stock(stock_id: *const gchar, size: GtkIconSize) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_image_new_from_icon_set(
icon_set: *mut GtkIconSet,
size: GtkIconSize,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_image_new_from_animation(animation: *mut GdkPixbufAnimation) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_image_new_from_icon_name(
icon_name: *const gchar,
size: GtkIconSize,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_image_new_from_gicon(icon: *mut GIcon, size: GtkIconSize) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_image_new_from_surface(surface: *mut cairo_surface_t) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_image_clear(image: *mut GtkImage);
}
extern "C" {
pub fn gtk_image_set_from_file(image: *mut GtkImage, filename: *const gchar);
}
extern "C" {
pub fn gtk_image_set_from_resource(image: *mut GtkImage, resource_path: *const gchar);
}
extern "C" {
pub fn gtk_image_set_from_pixbuf(image: *mut GtkImage, pixbuf: *mut GdkPixbuf);
}
extern "C" {
pub fn gtk_image_set_from_stock(
image: *mut GtkImage,
stock_id: *const gchar,
size: GtkIconSize,
);
}
extern "C" {
pub fn gtk_image_set_from_icon_set(
image: *mut GtkImage,
icon_set: *mut GtkIconSet,
size: GtkIconSize,
);
}
extern "C" {
pub fn gtk_image_set_from_animation(image: *mut GtkImage, animation: *mut GdkPixbufAnimation);
}
extern "C" {
pub fn gtk_image_set_from_icon_name(
image: *mut GtkImage,
icon_name: *const gchar,
size: GtkIconSize,
);
}
extern "C" {
pub fn gtk_image_set_from_gicon(image: *mut GtkImage, icon: *mut GIcon, size: GtkIconSize);
}
extern "C" {
pub fn gtk_image_set_from_surface(image: *mut GtkImage, surface: *mut cairo_surface_t);
}
extern "C" {
pub fn gtk_image_set_pixel_size(image: *mut GtkImage, pixel_size: gint);
}
extern "C" {
pub fn gtk_image_get_storage_type(image: *mut GtkImage) -> GtkImageType;
}
extern "C" {
pub fn gtk_image_get_pixbuf(image: *mut GtkImage) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_image_get_stock(
image: *mut GtkImage,
stock_id: *mut *mut gchar,
size: *mut GtkIconSize,
);
}
extern "C" {
pub fn gtk_image_get_icon_set(
image: *mut GtkImage,
icon_set: *mut *mut GtkIconSet,
size: *mut GtkIconSize,
);
}
extern "C" {
pub fn gtk_image_get_animation(image: *mut GtkImage) -> *mut GdkPixbufAnimation;
}
extern "C" {
pub fn gtk_image_get_icon_name(
image: *mut GtkImage,
icon_name: *mut *const gchar,
size: *mut GtkIconSize,
);
}
extern "C" {
pub fn gtk_image_get_gicon(
image: *mut GtkImage,
gicon: *mut *mut GIcon,
size: *mut GtkIconSize,
);
}
extern "C" {
pub fn gtk_image_get_pixel_size(image: *mut GtkImage) -> gint;
}
pub const GtkEntryIconPosition_GTK_ENTRY_ICON_PRIMARY: GtkEntryIconPosition = 0;
pub const GtkEntryIconPosition_GTK_ENTRY_ICON_SECONDARY: GtkEntryIconPosition = 1;
#[doc = " GtkEntryIconPosition:\n @GTK_ENTRY_ICON_PRIMARY: At the beginning of the entry (depending on the text direction).\n @GTK_ENTRY_ICON_SECONDARY: At the end of the entry (depending on the text direction).\n\n Specifies the side of the entry at which an icon is placed.\n\n Since: 2.16"]
pub type GtkEntryIconPosition = ::std::os::raw::c_uint;
pub type GtkEntry = _GtkEntry;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkEntryPrivate {
_unused: [u8; 0],
}
pub type GtkEntryPrivate = _GtkEntryPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkEntry {
pub parent_instance: GtkWidget,
pub priv_: *mut GtkEntryPrivate,
}
#[test]
fn bindgen_test_layout__GtkEntry() {
const UNINIT: ::std::mem::MaybeUninit<_GtkEntry> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkEntry>(),
40usize,
concat!("Size of: ", stringify!(_GtkEntry))
);
assert_eq!(
::std::mem::align_of::<_GtkEntry>(),
8usize,
concat!("Alignment of ", stringify!(_GtkEntry))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkEntry),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkEntry),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkEntry {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_entry_get_type() -> GType;
}
extern "C" {
pub fn gtk_entry_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_entry_new_with_buffer(buffer: *mut GtkEntryBuffer) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_entry_get_buffer(entry: *mut GtkEntry) -> *mut GtkEntryBuffer;
}
extern "C" {
pub fn gtk_entry_set_buffer(entry: *mut GtkEntry, buffer: *mut GtkEntryBuffer);
}
extern "C" {
pub fn gtk_entry_get_text_area(entry: *mut GtkEntry, text_area: *mut GdkRectangle);
}
extern "C" {
pub fn gtk_entry_set_visibility(entry: *mut GtkEntry, visible: gboolean);
}
extern "C" {
pub fn gtk_entry_get_visibility(entry: *mut GtkEntry) -> gboolean;
}
extern "C" {
pub fn gtk_entry_set_invisible_char(entry: *mut GtkEntry, ch: gunichar);
}
extern "C" {
pub fn gtk_entry_get_invisible_char(entry: *mut GtkEntry) -> gunichar;
}
extern "C" {
pub fn gtk_entry_unset_invisible_char(entry: *mut GtkEntry);
}
extern "C" {
pub fn gtk_entry_set_has_frame(entry: *mut GtkEntry, setting: gboolean);
}
extern "C" {
pub fn gtk_entry_get_has_frame(entry: *mut GtkEntry) -> gboolean;
}
extern "C" {
pub fn gtk_entry_set_inner_border(entry: *mut GtkEntry, border: *const GtkBorder);
}
extern "C" {
pub fn gtk_entry_get_inner_border(entry: *mut GtkEntry) -> *const GtkBorder;
}
extern "C" {
pub fn gtk_entry_set_overwrite_mode(entry: *mut GtkEntry, overwrite: gboolean);
}
extern "C" {
pub fn gtk_entry_get_overwrite_mode(entry: *mut GtkEntry) -> gboolean;
}
extern "C" {
pub fn gtk_entry_set_max_length(entry: *mut GtkEntry, max: gint);
}
extern "C" {
pub fn gtk_entry_get_max_length(entry: *mut GtkEntry) -> gint;
}
extern "C" {
pub fn gtk_entry_get_text_length(entry: *mut GtkEntry) -> guint16;
}
extern "C" {
pub fn gtk_entry_set_activates_default(entry: *mut GtkEntry, setting: gboolean);
}
extern "C" {
pub fn gtk_entry_get_activates_default(entry: *mut GtkEntry) -> gboolean;
}
extern "C" {
pub fn gtk_entry_set_width_chars(entry: *mut GtkEntry, n_chars: gint);
}
extern "C" {
pub fn gtk_entry_get_width_chars(entry: *mut GtkEntry) -> gint;
}
extern "C" {
pub fn gtk_entry_set_max_width_chars(entry: *mut GtkEntry, n_chars: gint);
}
extern "C" {
pub fn gtk_entry_get_max_width_chars(entry: *mut GtkEntry) -> gint;
}
extern "C" {
pub fn gtk_entry_set_text(entry: *mut GtkEntry, text: *const gchar);
}
extern "C" {
pub fn gtk_entry_get_text(entry: *mut GtkEntry) -> *const gchar;
}
extern "C" {
pub fn gtk_entry_get_layout(entry: *mut GtkEntry) -> *mut PangoLayout;
}
extern "C" {
pub fn gtk_entry_get_layout_offsets(entry: *mut GtkEntry, x: *mut gint, y: *mut gint);
}
extern "C" {
pub fn gtk_entry_set_alignment(entry: *mut GtkEntry, xalign: gfloat);
}
extern "C" {
pub fn gtk_entry_get_alignment(entry: *mut GtkEntry) -> gfloat;
}
extern "C" {
pub fn gtk_entry_set_completion(entry: *mut GtkEntry, completion: *mut GtkEntryCompletion);
}
extern "C" {
pub fn gtk_entry_get_completion(entry: *mut GtkEntry) -> *mut GtkEntryCompletion;
}
extern "C" {
pub fn gtk_entry_layout_index_to_text_index(entry: *mut GtkEntry, layout_index: gint) -> gint;
}
extern "C" {
pub fn gtk_entry_text_index_to_layout_index(entry: *mut GtkEntry, text_index: gint) -> gint;
}
extern "C" {
pub fn gtk_entry_set_cursor_hadjustment(entry: *mut GtkEntry, adjustment: *mut GtkAdjustment);
}
extern "C" {
pub fn gtk_entry_get_cursor_hadjustment(entry: *mut GtkEntry) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_entry_set_progress_fraction(entry: *mut GtkEntry, fraction: gdouble);
}
extern "C" {
pub fn gtk_entry_get_progress_fraction(entry: *mut GtkEntry) -> gdouble;
}
extern "C" {
pub fn gtk_entry_set_progress_pulse_step(entry: *mut GtkEntry, fraction: gdouble);
}
extern "C" {
pub fn gtk_entry_get_progress_pulse_step(entry: *mut GtkEntry) -> gdouble;
}
extern "C" {
pub fn gtk_entry_progress_pulse(entry: *mut GtkEntry);
}
extern "C" {
pub fn gtk_entry_get_placeholder_text(entry: *mut GtkEntry) -> *const gchar;
}
extern "C" {
pub fn gtk_entry_set_placeholder_text(entry: *mut GtkEntry, text: *const gchar);
}
extern "C" {
pub fn gtk_entry_set_icon_from_pixbuf(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
pixbuf: *mut GdkPixbuf,
);
}
extern "C" {
pub fn gtk_entry_set_icon_from_stock(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
stock_id: *const gchar,
);
}
extern "C" {
pub fn gtk_entry_set_icon_from_icon_name(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
icon_name: *const gchar,
);
}
extern "C" {
pub fn gtk_entry_set_icon_from_gicon(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
icon: *mut GIcon,
);
}
extern "C" {
pub fn gtk_entry_get_icon_storage_type(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
) -> GtkImageType;
}
extern "C" {
pub fn gtk_entry_get_icon_pixbuf(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_entry_get_icon_stock(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
) -> *const gchar;
}
extern "C" {
pub fn gtk_entry_get_icon_name(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
) -> *const gchar;
}
extern "C" {
pub fn gtk_entry_get_icon_gicon(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
) -> *mut GIcon;
}
extern "C" {
pub fn gtk_entry_set_icon_activatable(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
activatable: gboolean,
);
}
extern "C" {
pub fn gtk_entry_get_icon_activatable(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
) -> gboolean;
}
extern "C" {
pub fn gtk_entry_set_icon_sensitive(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
sensitive: gboolean,
);
}
extern "C" {
pub fn gtk_entry_get_icon_sensitive(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
) -> gboolean;
}
extern "C" {
pub fn gtk_entry_get_icon_at_pos(entry: *mut GtkEntry, x: gint, y: gint) -> gint;
}
extern "C" {
pub fn gtk_entry_set_icon_tooltip_text(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
tooltip: *const gchar,
);
}
extern "C" {
pub fn gtk_entry_get_icon_tooltip_text(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_entry_set_icon_tooltip_markup(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
tooltip: *const gchar,
);
}
extern "C" {
pub fn gtk_entry_get_icon_tooltip_markup(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_entry_set_icon_drag_source(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
target_list: *mut GtkTargetList,
actions: GdkDragAction,
);
}
extern "C" {
pub fn gtk_entry_get_current_icon_drag_source(entry: *mut GtkEntry) -> gint;
}
extern "C" {
pub fn gtk_entry_get_icon_area(
entry: *mut GtkEntry,
icon_pos: GtkEntryIconPosition,
icon_area: *mut GdkRectangle,
);
}
extern "C" {
pub fn gtk_entry_im_context_filter_keypress(
entry: *mut GtkEntry,
event: *mut GdkEventKey,
) -> gboolean;
}
extern "C" {
pub fn gtk_entry_reset_im_context(entry: *mut GtkEntry);
}
extern "C" {
pub fn gtk_entry_set_input_purpose(entry: *mut GtkEntry, purpose: GtkInputPurpose);
}
extern "C" {
pub fn gtk_entry_get_input_purpose(entry: *mut GtkEntry) -> GtkInputPurpose;
}
extern "C" {
pub fn gtk_entry_set_input_hints(entry: *mut GtkEntry, hints: GtkInputHints);
}
extern "C" {
pub fn gtk_entry_get_input_hints(entry: *mut GtkEntry) -> GtkInputHints;
}
extern "C" {
pub fn gtk_entry_set_attributes(entry: *mut GtkEntry, attrs: *mut PangoAttrList);
}
extern "C" {
pub fn gtk_entry_get_attributes(entry: *mut GtkEntry) -> *mut PangoAttrList;
}
extern "C" {
pub fn gtk_entry_set_tabs(entry: *mut GtkEntry, tabs: *mut PangoTabArray);
}
extern "C" {
pub fn gtk_entry_get_tabs(entry: *mut GtkEntry) -> *mut PangoTabArray;
}
pub const GtkTreeViewDropPosition_GTK_TREE_VIEW_DROP_BEFORE: GtkTreeViewDropPosition = 0;
pub const GtkTreeViewDropPosition_GTK_TREE_VIEW_DROP_AFTER: GtkTreeViewDropPosition = 1;
pub const GtkTreeViewDropPosition_GTK_TREE_VIEW_DROP_INTO_OR_BEFORE: GtkTreeViewDropPosition = 2;
pub const GtkTreeViewDropPosition_GTK_TREE_VIEW_DROP_INTO_OR_AFTER: GtkTreeViewDropPosition = 3;
#[doc = " GtkTreeViewDropPosition:\n @GTK_TREE_VIEW_DROP_BEFORE: dropped row is inserted before\n @GTK_TREE_VIEW_DROP_AFTER: dropped row is inserted after\n @GTK_TREE_VIEW_DROP_INTO_OR_BEFORE: dropped row becomes a child or is inserted before\n @GTK_TREE_VIEW_DROP_INTO_OR_AFTER: dropped row becomes a child or is inserted after\n\n An enum for determining where a dropped row goes."]
pub type GtkTreeViewDropPosition = ::std::os::raw::c_uint;
pub type GtkTreeView = _GtkTreeView;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeViewPrivate {
_unused: [u8; 0],
}
pub type GtkTreeViewPrivate = _GtkTreeViewPrivate;
pub type GtkTreeSelection = _GtkTreeSelection;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeView {
pub parent: GtkContainer,
pub priv_: *mut GtkTreeViewPrivate,
}
#[test]
fn bindgen_test_layout__GtkTreeView() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTreeView> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTreeView>(),
48usize,
concat!("Size of: ", stringify!(_GtkTreeView))
);
assert_eq!(
::std::mem::align_of::<_GtkTreeView>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTreeView))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeView),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeView),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkTreeView {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GtkTreeViewColumnDropFunc:\n @tree_view: A #GtkTreeView\n @column: The #GtkTreeViewColumn being dragged\n @prev_column: A #GtkTreeViewColumn on one side of @column\n @next_column: A #GtkTreeViewColumn on the other side of @column\n @data: (closure): user data\n\n Function type for determining whether @column can be dropped in a\n particular spot (as determined by @prev_column and @next_column). In\n left to right locales, @prev_column is on the left of the potential drop\n spot, and @next_column is on the right. In right to left mode, this is\n reversed. This function should return %TRUE if the spot is a valid drop\n spot. Please note that returning %TRUE does not actually indicate that\n the column drop was made, but is meant only to indicate a possible drop\n spot to the user.\n\n Returns: %TRUE, if @column can be dropped in this spot"]
pub type GtkTreeViewColumnDropFunc = ::std::option::Option<
unsafe extern "C" fn(
tree_view: *mut GtkTreeView,
column: *mut GtkTreeViewColumn,
prev_column: *mut GtkTreeViewColumn,
next_column: *mut GtkTreeViewColumn,
data: gpointer,
) -> gboolean,
>;
#[doc = " GtkTreeViewMappingFunc:\n @tree_view: A #GtkTreeView\n @path: The path that’s expanded\n @user_data: user data\n\n Function used for gtk_tree_view_map_expanded_rows()."]
pub type GtkTreeViewMappingFunc = ::std::option::Option<
unsafe extern "C" fn(tree_view: *mut GtkTreeView, path: *mut GtkTreePath, user_data: gpointer),
>;
#[doc = " GtkTreeViewSearchEqualFunc:\n @model: the #GtkTreeModel being searched\n @column: the search column set by gtk_tree_view_set_search_column()\n @key: the key string to compare with\n @iter: a #GtkTreeIter pointing the row of @model that should be compared\n with @key.\n @search_data: (closure): user data from gtk_tree_view_set_search_equal_func()\n\n A function used for checking whether a row in @model matches\n a search key string entered by the user. Note the return value\n is reversed from what you would normally expect, though it\n has some similarity to strcmp() returning 0 for equal strings.\n\n Returns: %FALSE if the row matches, %TRUE otherwise."]
pub type GtkTreeViewSearchEqualFunc = ::std::option::Option<
unsafe extern "C" fn(
model: *mut GtkTreeModel,
column: gint,
key: *const gchar,
iter: *mut GtkTreeIter,
search_data: gpointer,
) -> gboolean,
>;
#[doc = " GtkTreeViewRowSeparatorFunc:\n @model: the #GtkTreeModel\n @iter: a #GtkTreeIter pointing at a row in @model\n @data: (closure): user data\n\n Function type for determining whether the row pointed to by @iter should\n be rendered as a separator. A common way to implement this is to have a\n boolean column in the model, whose values the #GtkTreeViewRowSeparatorFunc\n returns.\n\n Returns: %TRUE if the row is a separator"]
pub type GtkTreeViewRowSeparatorFunc = ::std::option::Option<
unsafe extern "C" fn(
model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
data: gpointer,
) -> gboolean,
>;
pub type GtkTreeViewSearchPositionFunc = ::std::option::Option<
unsafe extern "C" fn(
tree_view: *mut GtkTreeView,
search_dialog: *mut GtkWidget,
user_data: gpointer,
),
>;
extern "C" {
pub fn gtk_tree_view_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_view_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_tree_view_new_with_model(model: *mut GtkTreeModel) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_tree_view_get_model(tree_view: *mut GtkTreeView) -> *mut GtkTreeModel;
}
extern "C" {
pub fn gtk_tree_view_set_model(tree_view: *mut GtkTreeView, model: *mut GtkTreeModel);
}
extern "C" {
pub fn gtk_tree_view_get_selection(tree_view: *mut GtkTreeView) -> *mut GtkTreeSelection;
}
extern "C" {
pub fn gtk_tree_view_get_hadjustment(tree_view: *mut GtkTreeView) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_tree_view_set_hadjustment(
tree_view: *mut GtkTreeView,
adjustment: *mut GtkAdjustment,
);
}
extern "C" {
pub fn gtk_tree_view_get_vadjustment(tree_view: *mut GtkTreeView) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_tree_view_set_vadjustment(
tree_view: *mut GtkTreeView,
adjustment: *mut GtkAdjustment,
);
}
extern "C" {
pub fn gtk_tree_view_get_headers_visible(tree_view: *mut GtkTreeView) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_set_headers_visible(
tree_view: *mut GtkTreeView,
headers_visible: gboolean,
);
}
extern "C" {
pub fn gtk_tree_view_columns_autosize(tree_view: *mut GtkTreeView);
}
extern "C" {
pub fn gtk_tree_view_get_headers_clickable(tree_view: *mut GtkTreeView) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_set_headers_clickable(tree_view: *mut GtkTreeView, setting: gboolean);
}
extern "C" {
pub fn gtk_tree_view_set_rules_hint(tree_view: *mut GtkTreeView, setting: gboolean);
}
extern "C" {
pub fn gtk_tree_view_get_rules_hint(tree_view: *mut GtkTreeView) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_get_activate_on_single_click(tree_view: *mut GtkTreeView) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_set_activate_on_single_click(
tree_view: *mut GtkTreeView,
single: gboolean,
);
}
extern "C" {
pub fn gtk_tree_view_append_column(
tree_view: *mut GtkTreeView,
column: *mut GtkTreeViewColumn,
) -> gint;
}
extern "C" {
pub fn gtk_tree_view_remove_column(
tree_view: *mut GtkTreeView,
column: *mut GtkTreeViewColumn,
) -> gint;
}
extern "C" {
pub fn gtk_tree_view_insert_column(
tree_view: *mut GtkTreeView,
column: *mut GtkTreeViewColumn,
position: gint,
) -> gint;
}
extern "C" {
pub fn gtk_tree_view_insert_column_with_attributes(
tree_view: *mut GtkTreeView,
position: gint,
title: *const gchar,
cell: *mut GtkCellRenderer,
...
) -> gint;
}
extern "C" {
pub fn gtk_tree_view_insert_column_with_data_func(
tree_view: *mut GtkTreeView,
position: gint,
title: *const gchar,
cell: *mut GtkCellRenderer,
func: GtkTreeCellDataFunc,
data: gpointer,
dnotify: GDestroyNotify,
) -> gint;
}
extern "C" {
pub fn gtk_tree_view_get_n_columns(tree_view: *mut GtkTreeView) -> guint;
}
extern "C" {
pub fn gtk_tree_view_get_column(tree_view: *mut GtkTreeView, n: gint)
-> *mut GtkTreeViewColumn;
}
extern "C" {
pub fn gtk_tree_view_get_columns(tree_view: *mut GtkTreeView) -> *mut GList;
}
extern "C" {
pub fn gtk_tree_view_move_column_after(
tree_view: *mut GtkTreeView,
column: *mut GtkTreeViewColumn,
base_column: *mut GtkTreeViewColumn,
);
}
extern "C" {
pub fn gtk_tree_view_set_expander_column(
tree_view: *mut GtkTreeView,
column: *mut GtkTreeViewColumn,
);
}
extern "C" {
pub fn gtk_tree_view_get_expander_column(tree_view: *mut GtkTreeView)
-> *mut GtkTreeViewColumn;
}
extern "C" {
pub fn gtk_tree_view_set_column_drag_function(
tree_view: *mut GtkTreeView,
func: GtkTreeViewColumnDropFunc,
user_data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_tree_view_scroll_to_point(tree_view: *mut GtkTreeView, tree_x: gint, tree_y: gint);
}
extern "C" {
pub fn gtk_tree_view_scroll_to_cell(
tree_view: *mut GtkTreeView,
path: *mut GtkTreePath,
column: *mut GtkTreeViewColumn,
use_align: gboolean,
row_align: gfloat,
col_align: gfloat,
);
}
extern "C" {
pub fn gtk_tree_view_row_activated(
tree_view: *mut GtkTreeView,
path: *mut GtkTreePath,
column: *mut GtkTreeViewColumn,
);
}
extern "C" {
pub fn gtk_tree_view_expand_all(tree_view: *mut GtkTreeView);
}
extern "C" {
pub fn gtk_tree_view_collapse_all(tree_view: *mut GtkTreeView);
}
extern "C" {
pub fn gtk_tree_view_expand_to_path(tree_view: *mut GtkTreeView, path: *mut GtkTreePath);
}
extern "C" {
pub fn gtk_tree_view_expand_row(
tree_view: *mut GtkTreeView,
path: *mut GtkTreePath,
open_all: gboolean,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_collapse_row(
tree_view: *mut GtkTreeView,
path: *mut GtkTreePath,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_map_expanded_rows(
tree_view: *mut GtkTreeView,
func: GtkTreeViewMappingFunc,
data: gpointer,
);
}
extern "C" {
pub fn gtk_tree_view_row_expanded(
tree_view: *mut GtkTreeView,
path: *mut GtkTreePath,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_set_reorderable(tree_view: *mut GtkTreeView, reorderable: gboolean);
}
extern "C" {
pub fn gtk_tree_view_get_reorderable(tree_view: *mut GtkTreeView) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_set_cursor(
tree_view: *mut GtkTreeView,
path: *mut GtkTreePath,
focus_column: *mut GtkTreeViewColumn,
start_editing: gboolean,
);
}
extern "C" {
pub fn gtk_tree_view_set_cursor_on_cell(
tree_view: *mut GtkTreeView,
path: *mut GtkTreePath,
focus_column: *mut GtkTreeViewColumn,
focus_cell: *mut GtkCellRenderer,
start_editing: gboolean,
);
}
extern "C" {
pub fn gtk_tree_view_get_cursor(
tree_view: *mut GtkTreeView,
path: *mut *mut GtkTreePath,
focus_column: *mut *mut GtkTreeViewColumn,
);
}
extern "C" {
pub fn gtk_tree_view_get_bin_window(tree_view: *mut GtkTreeView) -> *mut GdkWindow;
}
extern "C" {
pub fn gtk_tree_view_get_path_at_pos(
tree_view: *mut GtkTreeView,
x: gint,
y: gint,
path: *mut *mut GtkTreePath,
column: *mut *mut GtkTreeViewColumn,
cell_x: *mut gint,
cell_y: *mut gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_get_cell_area(
tree_view: *mut GtkTreeView,
path: *mut GtkTreePath,
column: *mut GtkTreeViewColumn,
rect: *mut GdkRectangle,
);
}
extern "C" {
pub fn gtk_tree_view_get_background_area(
tree_view: *mut GtkTreeView,
path: *mut GtkTreePath,
column: *mut GtkTreeViewColumn,
rect: *mut GdkRectangle,
);
}
extern "C" {
pub fn gtk_tree_view_get_visible_rect(
tree_view: *mut GtkTreeView,
visible_rect: *mut GdkRectangle,
);
}
extern "C" {
pub fn gtk_tree_view_get_visible_range(
tree_view: *mut GtkTreeView,
start_path: *mut *mut GtkTreePath,
end_path: *mut *mut GtkTreePath,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_is_blank_at_pos(
tree_view: *mut GtkTreeView,
x: gint,
y: gint,
path: *mut *mut GtkTreePath,
column: *mut *mut GtkTreeViewColumn,
cell_x: *mut gint,
cell_y: *mut gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_enable_model_drag_source(
tree_view: *mut GtkTreeView,
start_button_mask: GdkModifierType,
targets: *const GtkTargetEntry,
n_targets: gint,
actions: GdkDragAction,
);
}
extern "C" {
pub fn gtk_tree_view_enable_model_drag_dest(
tree_view: *mut GtkTreeView,
targets: *const GtkTargetEntry,
n_targets: gint,
actions: GdkDragAction,
);
}
extern "C" {
pub fn gtk_tree_view_unset_rows_drag_source(tree_view: *mut GtkTreeView);
}
extern "C" {
pub fn gtk_tree_view_unset_rows_drag_dest(tree_view: *mut GtkTreeView);
}
extern "C" {
pub fn gtk_tree_view_set_drag_dest_row(
tree_view: *mut GtkTreeView,
path: *mut GtkTreePath,
pos: GtkTreeViewDropPosition,
);
}
extern "C" {
pub fn gtk_tree_view_get_drag_dest_row(
tree_view: *mut GtkTreeView,
path: *mut *mut GtkTreePath,
pos: *mut GtkTreeViewDropPosition,
);
}
extern "C" {
pub fn gtk_tree_view_get_dest_row_at_pos(
tree_view: *mut GtkTreeView,
drag_x: gint,
drag_y: gint,
path: *mut *mut GtkTreePath,
pos: *mut GtkTreeViewDropPosition,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_create_row_drag_icon(
tree_view: *mut GtkTreeView,
path: *mut GtkTreePath,
) -> *mut cairo_surface_t;
}
extern "C" {
pub fn gtk_tree_view_set_enable_search(tree_view: *mut GtkTreeView, enable_search: gboolean);
}
extern "C" {
pub fn gtk_tree_view_get_enable_search(tree_view: *mut GtkTreeView) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_get_search_column(tree_view: *mut GtkTreeView) -> gint;
}
extern "C" {
pub fn gtk_tree_view_set_search_column(tree_view: *mut GtkTreeView, column: gint);
}
extern "C" {
pub fn gtk_tree_view_get_search_equal_func(
tree_view: *mut GtkTreeView,
) -> GtkTreeViewSearchEqualFunc;
}
extern "C" {
pub fn gtk_tree_view_set_search_equal_func(
tree_view: *mut GtkTreeView,
search_equal_func: GtkTreeViewSearchEqualFunc,
search_user_data: gpointer,
search_destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_tree_view_get_search_entry(tree_view: *mut GtkTreeView) -> *mut GtkEntry;
}
extern "C" {
pub fn gtk_tree_view_set_search_entry(tree_view: *mut GtkTreeView, entry: *mut GtkEntry);
}
extern "C" {
pub fn gtk_tree_view_get_search_position_func(
tree_view: *mut GtkTreeView,
) -> GtkTreeViewSearchPositionFunc;
}
extern "C" {
pub fn gtk_tree_view_set_search_position_func(
tree_view: *mut GtkTreeView,
func: GtkTreeViewSearchPositionFunc,
data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_tree_view_convert_widget_to_tree_coords(
tree_view: *mut GtkTreeView,
wx: gint,
wy: gint,
tx: *mut gint,
ty: *mut gint,
);
}
extern "C" {
pub fn gtk_tree_view_convert_tree_to_widget_coords(
tree_view: *mut GtkTreeView,
tx: gint,
ty: gint,
wx: *mut gint,
wy: *mut gint,
);
}
extern "C" {
pub fn gtk_tree_view_convert_widget_to_bin_window_coords(
tree_view: *mut GtkTreeView,
wx: gint,
wy: gint,
bx: *mut gint,
by: *mut gint,
);
}
extern "C" {
pub fn gtk_tree_view_convert_bin_window_to_widget_coords(
tree_view: *mut GtkTreeView,
bx: gint,
by: gint,
wx: *mut gint,
wy: *mut gint,
);
}
extern "C" {
pub fn gtk_tree_view_convert_tree_to_bin_window_coords(
tree_view: *mut GtkTreeView,
tx: gint,
ty: gint,
bx: *mut gint,
by: *mut gint,
);
}
extern "C" {
pub fn gtk_tree_view_convert_bin_window_to_tree_coords(
tree_view: *mut GtkTreeView,
bx: gint,
by: gint,
tx: *mut gint,
ty: *mut gint,
);
}
pub type GtkTreeDestroyCountFunc = ::std::option::Option<
unsafe extern "C" fn(
tree_view: *mut GtkTreeView,
path: *mut GtkTreePath,
children: gint,
user_data: gpointer,
),
>;
extern "C" {
pub fn gtk_tree_view_set_destroy_count_func(
tree_view: *mut GtkTreeView,
func: GtkTreeDestroyCountFunc,
data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_tree_view_set_fixed_height_mode(tree_view: *mut GtkTreeView, enable: gboolean);
}
extern "C" {
pub fn gtk_tree_view_get_fixed_height_mode(tree_view: *mut GtkTreeView) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_set_hover_selection(tree_view: *mut GtkTreeView, hover: gboolean);
}
extern "C" {
pub fn gtk_tree_view_get_hover_selection(tree_view: *mut GtkTreeView) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_set_hover_expand(tree_view: *mut GtkTreeView, expand: gboolean);
}
extern "C" {
pub fn gtk_tree_view_get_hover_expand(tree_view: *mut GtkTreeView) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_set_rubber_banding(tree_view: *mut GtkTreeView, enable: gboolean);
}
extern "C" {
pub fn gtk_tree_view_get_rubber_banding(tree_view: *mut GtkTreeView) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_is_rubber_banding_active(tree_view: *mut GtkTreeView) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_get_row_separator_func(
tree_view: *mut GtkTreeView,
) -> GtkTreeViewRowSeparatorFunc;
}
extern "C" {
pub fn gtk_tree_view_set_row_separator_func(
tree_view: *mut GtkTreeView,
func: GtkTreeViewRowSeparatorFunc,
data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_tree_view_get_grid_lines(tree_view: *mut GtkTreeView) -> GtkTreeViewGridLines;
}
extern "C" {
pub fn gtk_tree_view_set_grid_lines(
tree_view: *mut GtkTreeView,
grid_lines: GtkTreeViewGridLines,
);
}
extern "C" {
pub fn gtk_tree_view_get_enable_tree_lines(tree_view: *mut GtkTreeView) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_set_enable_tree_lines(tree_view: *mut GtkTreeView, enabled: gboolean);
}
extern "C" {
pub fn gtk_tree_view_set_show_expanders(tree_view: *mut GtkTreeView, enabled: gboolean);
}
extern "C" {
pub fn gtk_tree_view_get_show_expanders(tree_view: *mut GtkTreeView) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_set_level_indentation(tree_view: *mut GtkTreeView, indentation: gint);
}
extern "C" {
pub fn gtk_tree_view_get_level_indentation(tree_view: *mut GtkTreeView) -> gint;
}
extern "C" {
pub fn gtk_tree_view_set_tooltip_row(
tree_view: *mut GtkTreeView,
tooltip: *mut GtkTooltip,
path: *mut GtkTreePath,
);
}
extern "C" {
pub fn gtk_tree_view_set_tooltip_cell(
tree_view: *mut GtkTreeView,
tooltip: *mut GtkTooltip,
path: *mut GtkTreePath,
column: *mut GtkTreeViewColumn,
cell: *mut GtkCellRenderer,
);
}
extern "C" {
pub fn gtk_tree_view_get_tooltip_context(
tree_view: *mut GtkTreeView,
x: *mut gint,
y: *mut gint,
keyboard_tip: gboolean,
model: *mut *mut GtkTreeModel,
path: *mut *mut GtkTreePath,
iter: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_view_set_tooltip_column(tree_view: *mut GtkTreeView, column: gint);
}
extern "C" {
pub fn gtk_tree_view_get_tooltip_column(tree_view: *mut GtkTreeView) -> gint;
}
pub type GtkComboBox = _GtkComboBox;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkComboBoxPrivate {
_unused: [u8; 0],
}
pub type GtkComboBoxPrivate = _GtkComboBoxPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkComboBox {
pub parent_instance: GtkBin,
pub priv_: *mut GtkComboBoxPrivate,
}
#[test]
fn bindgen_test_layout__GtkComboBox() {
const UNINIT: ::std::mem::MaybeUninit<_GtkComboBox> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkComboBox>(),
56usize,
concat!("Size of: ", stringify!(_GtkComboBox))
);
assert_eq!(
::std::mem::align_of::<_GtkComboBox>(),
8usize,
concat!("Alignment of ", stringify!(_GtkComboBox))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkComboBox),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkComboBox),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkComboBox {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_combo_box_get_type() -> GType;
}
extern "C" {
pub fn gtk_combo_box_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_combo_box_new_with_area(area: *mut GtkCellArea) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_combo_box_new_with_area_and_entry(area: *mut GtkCellArea) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_combo_box_new_with_entry() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_combo_box_new_with_model(model: *mut GtkTreeModel) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_combo_box_new_with_model_and_entry(model: *mut GtkTreeModel) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_combo_box_get_wrap_width(combo_box: *mut GtkComboBox) -> gint;
}
extern "C" {
pub fn gtk_combo_box_set_wrap_width(combo_box: *mut GtkComboBox, width: gint);
}
extern "C" {
pub fn gtk_combo_box_get_row_span_column(combo_box: *mut GtkComboBox) -> gint;
}
extern "C" {
pub fn gtk_combo_box_set_row_span_column(combo_box: *mut GtkComboBox, row_span: gint);
}
extern "C" {
pub fn gtk_combo_box_get_column_span_column(combo_box: *mut GtkComboBox) -> gint;
}
extern "C" {
pub fn gtk_combo_box_set_column_span_column(combo_box: *mut GtkComboBox, column_span: gint);
}
extern "C" {
pub fn gtk_combo_box_get_add_tearoffs(combo_box: *mut GtkComboBox) -> gboolean;
}
extern "C" {
pub fn gtk_combo_box_set_add_tearoffs(combo_box: *mut GtkComboBox, add_tearoffs: gboolean);
}
extern "C" {
pub fn gtk_combo_box_get_title(combo_box: *mut GtkComboBox) -> *const gchar;
}
extern "C" {
pub fn gtk_combo_box_set_title(combo_box: *mut GtkComboBox, title: *const gchar);
}
extern "C" {
pub fn gtk_combo_box_get_focus_on_click(combo: *mut GtkComboBox) -> gboolean;
}
extern "C" {
pub fn gtk_combo_box_set_focus_on_click(combo: *mut GtkComboBox, focus_on_click: gboolean);
}
extern "C" {
pub fn gtk_combo_box_get_active(combo_box: *mut GtkComboBox) -> gint;
}
extern "C" {
pub fn gtk_combo_box_set_active(combo_box: *mut GtkComboBox, index_: gint);
}
extern "C" {
pub fn gtk_combo_box_get_active_iter(
combo_box: *mut GtkComboBox,
iter: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_combo_box_set_active_iter(combo_box: *mut GtkComboBox, iter: *mut GtkTreeIter);
}
extern "C" {
pub fn gtk_combo_box_set_model(combo_box: *mut GtkComboBox, model: *mut GtkTreeModel);
}
extern "C" {
pub fn gtk_combo_box_get_model(combo_box: *mut GtkComboBox) -> *mut GtkTreeModel;
}
extern "C" {
pub fn gtk_combo_box_get_row_separator_func(
combo_box: *mut GtkComboBox,
) -> GtkTreeViewRowSeparatorFunc;
}
extern "C" {
pub fn gtk_combo_box_set_row_separator_func(
combo_box: *mut GtkComboBox,
func: GtkTreeViewRowSeparatorFunc,
data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_combo_box_set_button_sensitivity(
combo_box: *mut GtkComboBox,
sensitivity: GtkSensitivityType,
);
}
extern "C" {
pub fn gtk_combo_box_get_button_sensitivity(combo_box: *mut GtkComboBox) -> GtkSensitivityType;
}
extern "C" {
pub fn gtk_combo_box_get_has_entry(combo_box: *mut GtkComboBox) -> gboolean;
}
extern "C" {
pub fn gtk_combo_box_set_entry_text_column(combo_box: *mut GtkComboBox, text_column: gint);
}
extern "C" {
pub fn gtk_combo_box_get_entry_text_column(combo_box: *mut GtkComboBox) -> gint;
}
extern "C" {
pub fn gtk_combo_box_set_popup_fixed_width(combo_box: *mut GtkComboBox, fixed: gboolean);
}
extern "C" {
pub fn gtk_combo_box_get_popup_fixed_width(combo_box: *mut GtkComboBox) -> gboolean;
}
extern "C" {
pub fn gtk_combo_box_popup(combo_box: *mut GtkComboBox);
}
extern "C" {
pub fn gtk_combo_box_popup_for_device(combo_box: *mut GtkComboBox, device: *mut GdkDevice);
}
extern "C" {
pub fn gtk_combo_box_popdown(combo_box: *mut GtkComboBox);
}
extern "C" {
pub fn gtk_combo_box_get_popup_accessible(combo_box: *mut GtkComboBox) -> *mut AtkObject;
}
extern "C" {
pub fn gtk_combo_box_get_id_column(combo_box: *mut GtkComboBox) -> gint;
}
extern "C" {
pub fn gtk_combo_box_set_id_column(combo_box: *mut GtkComboBox, id_column: gint);
}
extern "C" {
pub fn gtk_combo_box_get_active_id(combo_box: *mut GtkComboBox) -> *const gchar;
}
extern "C" {
pub fn gtk_combo_box_set_active_id(
combo_box: *mut GtkComboBox,
active_id: *const gchar,
) -> gboolean;
}
pub type GtkAppChooserButton = _GtkAppChooserButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAppChooserButtonPrivate {
_unused: [u8; 0],
}
pub type GtkAppChooserButtonPrivate = _GtkAppChooserButtonPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAppChooserButton {
pub parent: GtkComboBox,
pub priv_: *mut GtkAppChooserButtonPrivate,
}
#[test]
fn bindgen_test_layout__GtkAppChooserButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkAppChooserButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkAppChooserButton>(),
64usize,
concat!("Size of: ", stringify!(_GtkAppChooserButton))
);
assert_eq!(
::std::mem::align_of::<_GtkAppChooserButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkAppChooserButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkAppChooserButton),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkAppChooserButton),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkAppChooserButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_app_chooser_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_app_chooser_button_new(content_type: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_app_chooser_button_append_separator(self_: *mut GtkAppChooserButton);
}
extern "C" {
pub fn gtk_app_chooser_button_append_custom_item(
self_: *mut GtkAppChooserButton,
name: *const gchar,
label: *const gchar,
icon: *mut GIcon,
);
}
extern "C" {
pub fn gtk_app_chooser_button_set_active_custom_item(
self_: *mut GtkAppChooserButton,
name: *const gchar,
);
}
extern "C" {
pub fn gtk_app_chooser_button_set_show_dialog_item(
self_: *mut GtkAppChooserButton,
setting: gboolean,
);
}
extern "C" {
pub fn gtk_app_chooser_button_get_show_dialog_item(self_: *mut GtkAppChooserButton)
-> gboolean;
}
extern "C" {
pub fn gtk_app_chooser_button_set_heading(
self_: *mut GtkAppChooserButton,
heading: *const gchar,
);
}
extern "C" {
pub fn gtk_app_chooser_button_get_heading(self_: *mut GtkAppChooserButton) -> *const gchar;
}
extern "C" {
pub fn gtk_app_chooser_button_set_show_default_item(
self_: *mut GtkAppChooserButton,
setting: gboolean,
);
}
extern "C" {
pub fn gtk_app_chooser_button_get_show_default_item(
self_: *mut GtkAppChooserButton,
) -> gboolean;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkApplicationWindowPrivate {
_unused: [u8; 0],
}
pub type GtkApplicationWindowPrivate = _GtkApplicationWindowPrivate;
pub type GtkApplicationWindow = _GtkApplicationWindow;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkApplicationWindow {
pub parent_instance: GtkWindow,
pub priv_: *mut GtkApplicationWindowPrivate,
}
#[test]
fn bindgen_test_layout__GtkApplicationWindow() {
const UNINIT: ::std::mem::MaybeUninit<_GtkApplicationWindow> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkApplicationWindow>(),
64usize,
concat!("Size of: ", stringify!(_GtkApplicationWindow))
);
assert_eq!(
::std::mem::align_of::<_GtkApplicationWindow>(),
8usize,
concat!("Alignment of ", stringify!(_GtkApplicationWindow))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkApplicationWindow),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkApplicationWindow),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkApplicationWindow {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_application_window_get_type() -> GType;
}
extern "C" {
pub fn gtk_application_window_new(application: *mut GtkApplication) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_application_window_set_show_menubar(
window: *mut GtkApplicationWindow,
show_menubar: gboolean,
);
}
extern "C" {
pub fn gtk_application_window_get_show_menubar(window: *mut GtkApplicationWindow) -> gboolean;
}
extern "C" {
pub fn gtk_application_window_get_id(window: *mut GtkApplicationWindow) -> guint;
}
pub type GtkFrame = _GtkFrame;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFramePrivate {
_unused: [u8; 0],
}
pub type GtkFramePrivate = _GtkFramePrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFrame {
pub bin: GtkBin,
pub priv_: *mut GtkFramePrivate,
}
#[test]
fn bindgen_test_layout__GtkFrame() {
const UNINIT: ::std::mem::MaybeUninit<_GtkFrame> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkFrame>(),
56usize,
concat!("Size of: ", stringify!(_GtkFrame))
);
assert_eq!(
::std::mem::align_of::<_GtkFrame>(),
8usize,
concat!("Alignment of ", stringify!(_GtkFrame))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bin) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkFrame),
"::",
stringify!(bin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkFrame),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkFrame {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_frame_get_type() -> GType;
}
extern "C" {
pub fn gtk_frame_new(label: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_frame_set_label(frame: *mut GtkFrame, label: *const gchar);
}
extern "C" {
pub fn gtk_frame_get_label(frame: *mut GtkFrame) -> *const gchar;
}
extern "C" {
pub fn gtk_frame_set_label_widget(frame: *mut GtkFrame, label_widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_frame_get_label_widget(frame: *mut GtkFrame) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_frame_set_label_align(frame: *mut GtkFrame, xalign: gfloat, yalign: gfloat);
}
extern "C" {
pub fn gtk_frame_get_label_align(
frame: *mut GtkFrame,
xalign: *mut gfloat,
yalign: *mut gfloat,
);
}
extern "C" {
pub fn gtk_frame_set_shadow_type(frame: *mut GtkFrame, type_: GtkShadowType);
}
extern "C" {
pub fn gtk_frame_get_shadow_type(frame: *mut GtkFrame) -> GtkShadowType;
}
pub type GtkAspectFrame = _GtkAspectFrame;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAspectFramePrivate {
_unused: [u8; 0],
}
pub type GtkAspectFramePrivate = _GtkAspectFramePrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAspectFrame {
pub frame: GtkFrame,
pub priv_: *mut GtkAspectFramePrivate,
}
#[test]
fn bindgen_test_layout__GtkAspectFrame() {
const UNINIT: ::std::mem::MaybeUninit<_GtkAspectFrame> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkAspectFrame>(),
64usize,
concat!("Size of: ", stringify!(_GtkAspectFrame))
);
assert_eq!(
::std::mem::align_of::<_GtkAspectFrame>(),
8usize,
concat!("Alignment of ", stringify!(_GtkAspectFrame))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).frame) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkAspectFrame),
"::",
stringify!(frame)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkAspectFrame),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkAspectFrame {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_aspect_frame_get_type() -> GType;
}
extern "C" {
pub fn gtk_aspect_frame_new(
label: *const gchar,
xalign: gfloat,
yalign: gfloat,
ratio: gfloat,
obey_child: gboolean,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_aspect_frame_set(
aspect_frame: *mut GtkAspectFrame,
xalign: gfloat,
yalign: gfloat,
ratio: gfloat,
obey_child: gboolean,
);
}
pub const GtkAssistantPageType_GTK_ASSISTANT_PAGE_CONTENT: GtkAssistantPageType = 0;
pub const GtkAssistantPageType_GTK_ASSISTANT_PAGE_INTRO: GtkAssistantPageType = 1;
pub const GtkAssistantPageType_GTK_ASSISTANT_PAGE_CONFIRM: GtkAssistantPageType = 2;
pub const GtkAssistantPageType_GTK_ASSISTANT_PAGE_SUMMARY: GtkAssistantPageType = 3;
pub const GtkAssistantPageType_GTK_ASSISTANT_PAGE_PROGRESS: GtkAssistantPageType = 4;
pub const GtkAssistantPageType_GTK_ASSISTANT_PAGE_CUSTOM: GtkAssistantPageType = 5;
#[doc = " GtkAssistantPageType:\n @GTK_ASSISTANT_PAGE_CONTENT: The page has regular contents. Both the\n Back and forward buttons will be shown.\n @GTK_ASSISTANT_PAGE_INTRO: The page contains an introduction to the\n assistant task. Only the Forward button will be shown if there is a\n next page.\n @GTK_ASSISTANT_PAGE_CONFIRM: The page lets the user confirm or deny the\n changes. The Back and Apply buttons will be shown.\n @GTK_ASSISTANT_PAGE_SUMMARY: The page informs the user of the changes\n done. Only the Close button will be shown.\n @GTK_ASSISTANT_PAGE_PROGRESS: Used for tasks that take a long time to\n complete, blocks the assistant until the page is marked as complete.\n Only the back button will be shown.\n @GTK_ASSISTANT_PAGE_CUSTOM: Used for when other page types are not\n appropriate. No buttons will be shown, and the application must\n add its own buttons through gtk_assistant_add_action_widget().\n\n An enum for determining the page role inside the #GtkAssistant. It's\n used to handle buttons sensitivity and visibility.\n\n Note that an assistant needs to end its page flow with a page of type\n %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or\n %GTK_ASSISTANT_PAGE_PROGRESS to be correct.\n\n The Cancel button will only be shown if the page isn’t “committed”.\n See gtk_assistant_commit() for details."]
pub type GtkAssistantPageType = ::std::os::raw::c_uint;
pub type GtkAssistant = _GtkAssistant;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAssistantPrivate {
_unused: [u8; 0],
}
pub type GtkAssistantPrivate = _GtkAssistantPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAssistant {
pub parent: GtkWindow,
pub priv_: *mut GtkAssistantPrivate,
}
#[test]
fn bindgen_test_layout__GtkAssistant() {
const UNINIT: ::std::mem::MaybeUninit<_GtkAssistant> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkAssistant>(),
64usize,
concat!("Size of: ", stringify!(_GtkAssistant))
);
assert_eq!(
::std::mem::align_of::<_GtkAssistant>(),
8usize,
concat!("Alignment of ", stringify!(_GtkAssistant))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkAssistant),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkAssistant),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkAssistant {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GtkAssistantPageFunc:\n @current_page: The page number used to calculate the next page.\n @data: (closure): user data.\n\n A function used by gtk_assistant_set_forward_page_func() to know which\n is the next page given a current one. It’s called both for computing the\n next page when the user presses the “forward” button and for handling\n the behavior of the “last” button.\n\n Returns: The next page number."]
pub type GtkAssistantPageFunc =
::std::option::Option<unsafe extern "C" fn(current_page: gint, data: gpointer) -> gint>;
extern "C" {
pub fn gtk_assistant_get_type() -> GType;
}
extern "C" {
pub fn gtk_assistant_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_assistant_next_page(assistant: *mut GtkAssistant);
}
extern "C" {
pub fn gtk_assistant_previous_page(assistant: *mut GtkAssistant);
}
extern "C" {
pub fn gtk_assistant_get_current_page(assistant: *mut GtkAssistant) -> gint;
}
extern "C" {
pub fn gtk_assistant_set_current_page(assistant: *mut GtkAssistant, page_num: gint);
}
extern "C" {
pub fn gtk_assistant_get_n_pages(assistant: *mut GtkAssistant) -> gint;
}
extern "C" {
pub fn gtk_assistant_get_nth_page(
assistant: *mut GtkAssistant,
page_num: gint,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_assistant_prepend_page(assistant: *mut GtkAssistant, page: *mut GtkWidget) -> gint;
}
extern "C" {
pub fn gtk_assistant_append_page(assistant: *mut GtkAssistant, page: *mut GtkWidget) -> gint;
}
extern "C" {
pub fn gtk_assistant_insert_page(
assistant: *mut GtkAssistant,
page: *mut GtkWidget,
position: gint,
) -> gint;
}
extern "C" {
pub fn gtk_assistant_remove_page(assistant: *mut GtkAssistant, page_num: gint);
}
extern "C" {
pub fn gtk_assistant_set_forward_page_func(
assistant: *mut GtkAssistant,
page_func: GtkAssistantPageFunc,
data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_assistant_set_page_type(
assistant: *mut GtkAssistant,
page: *mut GtkWidget,
type_: GtkAssistantPageType,
);
}
extern "C" {
pub fn gtk_assistant_get_page_type(
assistant: *mut GtkAssistant,
page: *mut GtkWidget,
) -> GtkAssistantPageType;
}
extern "C" {
pub fn gtk_assistant_set_page_title(
assistant: *mut GtkAssistant,
page: *mut GtkWidget,
title: *const gchar,
);
}
extern "C" {
pub fn gtk_assistant_get_page_title(
assistant: *mut GtkAssistant,
page: *mut GtkWidget,
) -> *const gchar;
}
extern "C" {
pub fn gtk_assistant_set_page_header_image(
assistant: *mut GtkAssistant,
page: *mut GtkWidget,
pixbuf: *mut GdkPixbuf,
);
}
extern "C" {
pub fn gtk_assistant_get_page_header_image(
assistant: *mut GtkAssistant,
page: *mut GtkWidget,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_assistant_set_page_side_image(
assistant: *mut GtkAssistant,
page: *mut GtkWidget,
pixbuf: *mut GdkPixbuf,
);
}
extern "C" {
pub fn gtk_assistant_get_page_side_image(
assistant: *mut GtkAssistant,
page: *mut GtkWidget,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_assistant_set_page_complete(
assistant: *mut GtkAssistant,
page: *mut GtkWidget,
complete: gboolean,
);
}
extern "C" {
pub fn gtk_assistant_get_page_complete(
assistant: *mut GtkAssistant,
page: *mut GtkWidget,
) -> gboolean;
}
extern "C" {
pub fn gtk_assistant_add_action_widget(assistant: *mut GtkAssistant, child: *mut GtkWidget);
}
extern "C" {
pub fn gtk_assistant_remove_action_widget(assistant: *mut GtkAssistant, child: *mut GtkWidget);
}
extern "C" {
pub fn gtk_assistant_update_buttons_state(assistant: *mut GtkAssistant);
}
extern "C" {
pub fn gtk_assistant_commit(assistant: *mut GtkAssistant);
}
pub type GtkButtonBox = _GtkButtonBox;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkButtonBoxPrivate {
_unused: [u8; 0],
}
pub type GtkButtonBoxPrivate = _GtkButtonBoxPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkButtonBox {
pub box_: GtkBox,
pub priv_: *mut GtkButtonBoxPrivate,
}
#[test]
fn bindgen_test_layout__GtkButtonBox() {
const UNINIT: ::std::mem::MaybeUninit<_GtkButtonBox> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkButtonBox>(),
56usize,
concat!("Size of: ", stringify!(_GtkButtonBox))
);
assert_eq!(
::std::mem::align_of::<_GtkButtonBox>(),
8usize,
concat!("Alignment of ", stringify!(_GtkButtonBox))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).box_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkButtonBox),
"::",
stringify!(box_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkButtonBox),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkButtonBox {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const GtkButtonBoxStyle_GTK_BUTTONBOX_SPREAD: GtkButtonBoxStyle = 1;
pub const GtkButtonBoxStyle_GTK_BUTTONBOX_EDGE: GtkButtonBoxStyle = 2;
pub const GtkButtonBoxStyle_GTK_BUTTONBOX_START: GtkButtonBoxStyle = 3;
pub const GtkButtonBoxStyle_GTK_BUTTONBOX_END: GtkButtonBoxStyle = 4;
pub const GtkButtonBoxStyle_GTK_BUTTONBOX_CENTER: GtkButtonBoxStyle = 5;
pub const GtkButtonBoxStyle_GTK_BUTTONBOX_EXPAND: GtkButtonBoxStyle = 6;
#[doc = " GtkButtonBoxStyle:\n @GTK_BUTTONBOX_SPREAD: Buttons are evenly spread across the box.\n @GTK_BUTTONBOX_EDGE: Buttons are placed at the edges of the box.\n @GTK_BUTTONBOX_START: Buttons are grouped towards the start of the box,\n (on the left for a HBox, or the top for a VBox).\n @GTK_BUTTONBOX_END: Buttons are grouped towards the end of the box,\n (on the right for a HBox, or the bottom for a VBox).\n @GTK_BUTTONBOX_CENTER: Buttons are centered in the box. Since 2.12.\n @GTK_BUTTONBOX_EXPAND: Buttons expand to fill the box. Since 3.12.\n\n Used to dictate the style that a #GtkButtonBox uses to layout the buttons it\n contains."]
pub type GtkButtonBoxStyle = ::std::os::raw::c_uint;
extern "C" {
pub fn gtk_button_box_get_type() -> GType;
}
extern "C" {
pub fn gtk_button_box_new(orientation: GtkOrientation) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_button_box_get_layout(widget: *mut GtkButtonBox) -> GtkButtonBoxStyle;
}
extern "C" {
pub fn gtk_button_box_set_layout(widget: *mut GtkButtonBox, layout_style: GtkButtonBoxStyle);
}
extern "C" {
pub fn gtk_button_box_get_child_secondary(
widget: *mut GtkButtonBox,
child: *mut GtkWidget,
) -> gboolean;
}
extern "C" {
pub fn gtk_button_box_set_child_secondary(
widget: *mut GtkButtonBox,
child: *mut GtkWidget,
is_secondary: gboolean,
);
}
extern "C" {
pub fn gtk_button_box_get_child_non_homogeneous(
widget: *mut GtkButtonBox,
child: *mut GtkWidget,
) -> gboolean;
}
extern "C" {
pub fn gtk_button_box_set_child_non_homogeneous(
widget: *mut GtkButtonBox,
child: *mut GtkWidget,
non_homogeneous: gboolean,
);
}
#[doc = " GtkBindingSet:\n @set_name: unique name of this binding set\n @priority: unused\n @widget_path_pspecs: unused\n @widget_class_pspecs: unused\n @class_branch_pspecs: unused\n @entries: the key binding entries in this binding set\n @current: implementation detail\n @parsed: whether this binding set stems from a CSS file and is reset upon theme changes\n\n A binding set maintains a list of activatable key bindings.\n A single binding set can match multiple types of widgets.\n Similar to style contexts, can be matched by any information contained\n in a widgets #GtkWidgetPath. When a binding within a set is matched upon\n activation, an action signal is emitted on the target widget to carry out\n the actual activation."]
pub type GtkBindingSet = _GtkBindingSet;
#[doc = " GtkBindingEntry:\n @keyval: key value to match\n @modifiers: key modifiers to match\n @binding_set: binding set this entry belongs to\n @destroyed: implementation detail\n @in_emission: implementation detail\n @marks_unbound: implementation detail\n @set_next: linked list of entries maintained by binding set\n @hash_next: implementation detail\n @signals: action signals of this entry\n\n Each key binding element of a binding sets binding list is\n represented by a GtkBindingEntry."]
pub type GtkBindingEntry = _GtkBindingEntry;
#[doc = " GtkBindingSignal:\n @next: implementation detail\n @signal_name: the action signal to be emitted\n @n_args: number of arguments specified for the signal\n @args: (array length=n_args): the arguments specified for the signal\n\n A GtkBindingSignal stores the necessary information to\n activate a widget in response to a key press via a signal\n emission."]
pub type GtkBindingSignal = _GtkBindingSignal;
#[doc = " GtkBindingArg:\n @arg_type: implementation detail\n\n A #GtkBindingArg holds the data associated with\n an argument for a key binding signal emission as\n stored in #GtkBindingSignal."]
pub type GtkBindingArg = _GtkBindingArg;
#[doc = " GtkBindingSet:\n @set_name: unique name of this binding set\n @priority: unused\n @widget_path_pspecs: unused\n @widget_class_pspecs: unused\n @class_branch_pspecs: unused\n @entries: the key binding entries in this binding set\n @current: implementation detail\n @parsed: whether this binding set stems from a CSS file and is reset upon theme changes\n\n A binding set maintains a list of activatable key bindings.\n A single binding set can match multiple types of widgets.\n Similar to style contexts, can be matched by any information contained\n in a widgets #GtkWidgetPath. When a binding within a set is matched upon\n activation, an action signal is emitted on the target widget to carry out\n the actual activation."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkBindingSet {
pub set_name: *mut gchar,
pub priority: gint,
pub widget_path_pspecs: *mut GSList,
pub widget_class_pspecs: *mut GSList,
pub class_branch_pspecs: *mut GSList,
pub entries: *mut GtkBindingEntry,
pub current: *mut GtkBindingEntry,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub __bindgen_padding_0: [u8; 7usize],
}
#[test]
fn bindgen_test_layout__GtkBindingSet() {
const UNINIT: ::std::mem::MaybeUninit<_GtkBindingSet> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkBindingSet>(),
64usize,
concat!("Size of: ", stringify!(_GtkBindingSet))
);
assert_eq!(
::std::mem::align_of::<_GtkBindingSet>(),
8usize,
concat!("Alignment of ", stringify!(_GtkBindingSet))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).set_name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingSet),
"::",
stringify!(set_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priority) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingSet),
"::",
stringify!(priority)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).widget_path_pspecs) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingSet),
"::",
stringify!(widget_path_pspecs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).widget_class_pspecs) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingSet),
"::",
stringify!(widget_class_pspecs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).class_branch_pspecs) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingSet),
"::",
stringify!(class_branch_pspecs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).entries) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingSet),
"::",
stringify!(entries)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).current) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingSet),
"::",
stringify!(current)
)
);
}
impl Default for _GtkBindingSet {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl _GtkBindingSet {
#[inline]
pub fn parsed(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
}
#[inline]
pub fn set_parsed(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(parsed: guint) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let parsed: u32 = unsafe { ::std::mem::transmute(parsed) };
parsed as u64
});
__bindgen_bitfield_unit
}
}
#[doc = " GtkBindingEntry:\n @keyval: key value to match\n @modifiers: key modifiers to match\n @binding_set: binding set this entry belongs to\n @destroyed: implementation detail\n @in_emission: implementation detail\n @marks_unbound: implementation detail\n @set_next: linked list of entries maintained by binding set\n @hash_next: implementation detail\n @signals: action signals of this entry\n\n Each key binding element of a binding sets binding list is\n represented by a GtkBindingEntry."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkBindingEntry {
pub keyval: guint,
pub modifiers: GdkModifierType,
pub binding_set: *mut GtkBindingSet,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub set_next: *mut GtkBindingEntry,
pub hash_next: *mut GtkBindingEntry,
pub signals: *mut GtkBindingSignal,
}
#[test]
fn bindgen_test_layout__GtkBindingEntry() {
const UNINIT: ::std::mem::MaybeUninit<_GtkBindingEntry> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkBindingEntry>(),
48usize,
concat!("Size of: ", stringify!(_GtkBindingEntry))
);
assert_eq!(
::std::mem::align_of::<_GtkBindingEntry>(),
8usize,
concat!("Alignment of ", stringify!(_GtkBindingEntry))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).keyval) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingEntry),
"::",
stringify!(keyval)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).modifiers) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingEntry),
"::",
stringify!(modifiers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).binding_set) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingEntry),
"::",
stringify!(binding_set)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).set_next) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingEntry),
"::",
stringify!(set_next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash_next) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingEntry),
"::",
stringify!(hash_next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).signals) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingEntry),
"::",
stringify!(signals)
)
);
}
impl Default for _GtkBindingEntry {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl _GtkBindingEntry {
#[inline]
pub fn destroyed(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
}
#[inline]
pub fn set_destroyed(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn in_emission(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
}
#[inline]
pub fn set_in_emission(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn marks_unbound(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
}
#[inline]
pub fn set_marks_unbound(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
destroyed: guint,
in_emission: guint,
marks_unbound: guint,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let destroyed: u32 = unsafe { ::std::mem::transmute(destroyed) };
destroyed as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let in_emission: u32 = unsafe { ::std::mem::transmute(in_emission) };
in_emission as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let marks_unbound: u32 = unsafe { ::std::mem::transmute(marks_unbound) };
marks_unbound as u64
});
__bindgen_bitfield_unit
}
}
#[doc = " GtkBindingArg:\n @arg_type: implementation detail\n\n A #GtkBindingArg holds the data associated with\n an argument for a key binding signal emission as\n stored in #GtkBindingSignal."]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _GtkBindingArg {
pub arg_type: GType,
pub d: _GtkBindingArg__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _GtkBindingArg__bindgen_ty_1 {
pub long_data: glong,
pub double_data: gdouble,
pub string_data: *mut gchar,
}
#[test]
fn bindgen_test_layout__GtkBindingArg__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<_GtkBindingArg__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkBindingArg__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(_GtkBindingArg__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<_GtkBindingArg__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(_GtkBindingArg__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).long_data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingArg__bindgen_ty_1),
"::",
stringify!(long_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).double_data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingArg__bindgen_ty_1),
"::",
stringify!(double_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).string_data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingArg__bindgen_ty_1),
"::",
stringify!(string_data)
)
);
}
impl Default for _GtkBindingArg__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[test]
fn bindgen_test_layout__GtkBindingArg() {
const UNINIT: ::std::mem::MaybeUninit<_GtkBindingArg> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkBindingArg>(),
16usize,
concat!("Size of: ", stringify!(_GtkBindingArg))
);
assert_eq!(
::std::mem::align_of::<_GtkBindingArg>(),
8usize,
concat!("Alignment of ", stringify!(_GtkBindingArg))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).arg_type) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingArg),
"::",
stringify!(arg_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingArg),
"::",
stringify!(d)
)
);
}
impl Default for _GtkBindingArg {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GtkBindingSignal:\n @next: implementation detail\n @signal_name: the action signal to be emitted\n @n_args: number of arguments specified for the signal\n @args: (array length=n_args): the arguments specified for the signal\n\n A GtkBindingSignal stores the necessary information to\n activate a widget in response to a key press via a signal\n emission."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkBindingSignal {
pub next: *mut GtkBindingSignal,
pub signal_name: *mut gchar,
pub n_args: guint,
pub args: *mut GtkBindingArg,
}
#[test]
fn bindgen_test_layout__GtkBindingSignal() {
const UNINIT: ::std::mem::MaybeUninit<_GtkBindingSignal> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkBindingSignal>(),
32usize,
concat!("Size of: ", stringify!(_GtkBindingSignal))
);
assert_eq!(
::std::mem::align_of::<_GtkBindingSignal>(),
8usize,
concat!("Alignment of ", stringify!(_GtkBindingSignal))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingSignal),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).signal_name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingSignal),
"::",
stringify!(signal_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).n_args) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingSignal),
"::",
stringify!(n_args)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).args) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkBindingSignal),
"::",
stringify!(args)
)
);
}
impl Default for _GtkBindingSignal {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_binding_set_new(set_name: *const gchar) -> *mut GtkBindingSet;
}
extern "C" {
pub fn gtk_binding_set_by_class(object_class: gpointer) -> *mut GtkBindingSet;
}
extern "C" {
pub fn gtk_binding_set_find(set_name: *const gchar) -> *mut GtkBindingSet;
}
extern "C" {
pub fn gtk_bindings_activate(
object: *mut GObject,
keyval: guint,
modifiers: GdkModifierType,
) -> gboolean;
}
extern "C" {
pub fn gtk_bindings_activate_event(object: *mut GObject, event: *mut GdkEventKey) -> gboolean;
}
extern "C" {
pub fn gtk_binding_set_activate(
binding_set: *mut GtkBindingSet,
keyval: guint,
modifiers: GdkModifierType,
object: *mut GObject,
) -> gboolean;
}
extern "C" {
pub fn gtk_binding_entry_skip(
binding_set: *mut GtkBindingSet,
keyval: guint,
modifiers: GdkModifierType,
);
}
extern "C" {
pub fn gtk_binding_entry_add_signal(
binding_set: *mut GtkBindingSet,
keyval: guint,
modifiers: GdkModifierType,
signal_name: *const gchar,
n_args: guint,
...
);
}
extern "C" {
pub fn gtk_binding_entry_add_signall(
binding_set: *mut GtkBindingSet,
keyval: guint,
modifiers: GdkModifierType,
signal_name: *const gchar,
binding_args: *mut GSList,
);
}
extern "C" {
pub fn gtk_binding_entry_add_signal_from_string(
binding_set: *mut GtkBindingSet,
signal_desc: *const gchar,
) -> GTokenType;
}
extern "C" {
pub fn gtk_binding_entry_remove(
binding_set: *mut GtkBindingSet,
keyval: guint,
modifiers: GdkModifierType,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkBuilderPrivate {
_unused: [u8; 0],
}
pub type GtkBuilderPrivate = _GtkBuilderPrivate;
extern "C" {
pub fn gtk_builder_error_quark() -> GQuark;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkBuilder {
pub parent_instance: GObject,
pub priv_: *mut GtkBuilderPrivate,
}
#[test]
fn bindgen_test_layout__GtkBuilder() {
const UNINIT: ::std::mem::MaybeUninit<_GtkBuilder> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkBuilder>(),
32usize,
concat!("Size of: ", stringify!(_GtkBuilder))
);
assert_eq!(
::std::mem::align_of::<_GtkBuilder>(),
8usize,
concat!("Alignment of ", stringify!(_GtkBuilder))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkBuilder),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkBuilder),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkBuilder {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_builder_get_type() -> GType;
}
extern "C" {
pub fn gtk_builder_new() -> *mut GtkBuilder;
}
extern "C" {
pub fn gtk_builder_add_from_file(
builder: *mut GtkBuilder,
filename: *const gchar,
error: *mut *mut GError,
) -> guint;
}
extern "C" {
pub fn gtk_builder_add_from_resource(
builder: *mut GtkBuilder,
resource_path: *const gchar,
error: *mut *mut GError,
) -> guint;
}
extern "C" {
pub fn gtk_builder_add_from_string(
builder: *mut GtkBuilder,
buffer: *const gchar,
length: gsize,
error: *mut *mut GError,
) -> guint;
}
extern "C" {
pub fn gtk_builder_add_objects_from_file(
builder: *mut GtkBuilder,
filename: *const gchar,
object_ids: *mut *mut gchar,
error: *mut *mut GError,
) -> guint;
}
extern "C" {
pub fn gtk_builder_add_objects_from_resource(
builder: *mut GtkBuilder,
resource_path: *const gchar,
object_ids: *mut *mut gchar,
error: *mut *mut GError,
) -> guint;
}
extern "C" {
pub fn gtk_builder_add_objects_from_string(
builder: *mut GtkBuilder,
buffer: *const gchar,
length: gsize,
object_ids: *mut *mut gchar,
error: *mut *mut GError,
) -> guint;
}
extern "C" {
pub fn gtk_builder_get_object(builder: *mut GtkBuilder, name: *const gchar) -> *mut GObject;
}
extern "C" {
pub fn gtk_builder_get_objects(builder: *mut GtkBuilder) -> *mut GSList;
}
extern "C" {
pub fn gtk_builder_expose_object(
builder: *mut GtkBuilder,
name: *const gchar,
object: *mut GObject,
);
}
extern "C" {
pub fn gtk_builder_connect_signals(builder: *mut GtkBuilder, user_data: gpointer);
}
extern "C" {
pub fn gtk_builder_connect_signals_full(
builder: *mut GtkBuilder,
func: GtkBuilderConnectFunc,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_builder_set_translation_domain(builder: *mut GtkBuilder, domain: *const gchar);
}
extern "C" {
pub fn gtk_builder_get_translation_domain(builder: *mut GtkBuilder) -> *const gchar;
}
extern "C" {
pub fn gtk_builder_get_type_from_name(
builder: *mut GtkBuilder,
type_name: *const ::std::os::raw::c_char,
) -> GType;
}
extern "C" {
pub fn gtk_builder_value_from_string(
builder: *mut GtkBuilder,
pspec: *mut GParamSpec,
string: *const gchar,
value: *mut GValue,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_builder_value_from_string_type(
builder: *mut GtkBuilder,
type_: GType,
string: *const gchar,
value: *mut GValue,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_builder_new_from_file(filename: *const gchar) -> *mut GtkBuilder;
}
extern "C" {
pub fn gtk_builder_new_from_resource(resource_path: *const gchar) -> *mut GtkBuilder;
}
extern "C" {
pub fn gtk_builder_new_from_string(string: *const gchar, length: gssize) -> *mut GtkBuilder;
}
extern "C" {
pub fn gtk_builder_add_callback_symbol(
builder: *mut GtkBuilder,
callback_name: *const gchar,
callback_symbol: GCallback,
);
}
extern "C" {
pub fn gtk_builder_add_callback_symbols(
builder: *mut GtkBuilder,
first_callback_name: *const gchar,
first_callback_symbol: GCallback,
...
);
}
extern "C" {
pub fn gtk_builder_lookup_callback_symbol(
builder: *mut GtkBuilder,
callback_name: *const gchar,
) -> GCallback;
}
extern "C" {
pub fn gtk_builder_set_application(builder: *mut GtkBuilder, application: *mut GtkApplication);
}
extern "C" {
pub fn gtk_builder_get_application(builder: *mut GtkBuilder) -> *mut GtkApplication;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkBuildable {
_unused: [u8; 0],
}
pub type GtkBuildable = _GtkBuildable;
extern "C" {
pub fn gtk_buildable_get_type() -> GType;
}
extern "C" {
pub fn gtk_buildable_set_name(buildable: *mut GtkBuildable, name: *const gchar);
}
extern "C" {
pub fn gtk_buildable_get_name(buildable: *mut GtkBuildable) -> *const gchar;
}
extern "C" {
pub fn gtk_buildable_add_child(
buildable: *mut GtkBuildable,
builder: *mut GtkBuilder,
child: *mut GObject,
type_: *const gchar,
);
}
extern "C" {
pub fn gtk_buildable_set_buildable_property(
buildable: *mut GtkBuildable,
builder: *mut GtkBuilder,
name: *const gchar,
value: *const GValue,
);
}
extern "C" {
pub fn gtk_buildable_construct_child(
buildable: *mut GtkBuildable,
builder: *mut GtkBuilder,
name: *const gchar,
) -> *mut GObject;
}
extern "C" {
pub fn gtk_buildable_custom_tag_start(
buildable: *mut GtkBuildable,
builder: *mut GtkBuilder,
child: *mut GObject,
tagname: *const gchar,
parser: *mut GMarkupParser,
data: *mut gpointer,
) -> gboolean;
}
extern "C" {
pub fn gtk_buildable_custom_tag_end(
buildable: *mut GtkBuildable,
builder: *mut GtkBuilder,
child: *mut GObject,
tagname: *const gchar,
data: *mut gpointer,
);
}
extern "C" {
pub fn gtk_buildable_custom_finished(
buildable: *mut GtkBuildable,
builder: *mut GtkBuilder,
child: *mut GObject,
tagname: *const gchar,
data: gpointer,
);
}
extern "C" {
pub fn gtk_buildable_parser_finished(buildable: *mut GtkBuildable, builder: *mut GtkBuilder);
}
extern "C" {
pub fn gtk_buildable_get_internal_child(
buildable: *mut GtkBuildable,
builder: *mut GtkBuilder,
childname: *const gchar,
) -> *mut GObject;
}
pub type GtkButton = _GtkButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkButtonPrivate {
_unused: [u8; 0],
}
pub type GtkButtonPrivate = _GtkButtonPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkButton {
pub bin: GtkBin,
pub priv_: *mut GtkButtonPrivate,
}
#[test]
fn bindgen_test_layout__GtkButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkButton>(),
56usize,
concat!("Size of: ", stringify!(_GtkButton))
);
assert_eq!(
::std::mem::align_of::<_GtkButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bin) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkButton),
"::",
stringify!(bin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkButton),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_button_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_button_new_with_label(label: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_button_new_from_icon_name(
icon_name: *const gchar,
size: GtkIconSize,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_button_new_from_stock(stock_id: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_button_new_with_mnemonic(label: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_button_clicked(button: *mut GtkButton);
}
extern "C" {
pub fn gtk_button_pressed(button: *mut GtkButton);
}
extern "C" {
pub fn gtk_button_released(button: *mut GtkButton);
}
extern "C" {
pub fn gtk_button_enter(button: *mut GtkButton);
}
extern "C" {
pub fn gtk_button_leave(button: *mut GtkButton);
}
extern "C" {
pub fn gtk_button_set_relief(button: *mut GtkButton, relief: GtkReliefStyle);
}
extern "C" {
pub fn gtk_button_get_relief(button: *mut GtkButton) -> GtkReliefStyle;
}
extern "C" {
pub fn gtk_button_set_label(button: *mut GtkButton, label: *const gchar);
}
extern "C" {
pub fn gtk_button_get_label(button: *mut GtkButton) -> *const gchar;
}
extern "C" {
pub fn gtk_button_set_use_underline(button: *mut GtkButton, use_underline: gboolean);
}
extern "C" {
pub fn gtk_button_get_use_underline(button: *mut GtkButton) -> gboolean;
}
extern "C" {
pub fn gtk_button_set_use_stock(button: *mut GtkButton, use_stock: gboolean);
}
extern "C" {
pub fn gtk_button_get_use_stock(button: *mut GtkButton) -> gboolean;
}
extern "C" {
pub fn gtk_button_set_focus_on_click(button: *mut GtkButton, focus_on_click: gboolean);
}
extern "C" {
pub fn gtk_button_get_focus_on_click(button: *mut GtkButton) -> gboolean;
}
extern "C" {
pub fn gtk_button_set_alignment(button: *mut GtkButton, xalign: gfloat, yalign: gfloat);
}
extern "C" {
pub fn gtk_button_get_alignment(
button: *mut GtkButton,
xalign: *mut gfloat,
yalign: *mut gfloat,
);
}
extern "C" {
pub fn gtk_button_set_image(button: *mut GtkButton, image: *mut GtkWidget);
}
extern "C" {
pub fn gtk_button_get_image(button: *mut GtkButton) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_button_set_image_position(button: *mut GtkButton, position: GtkPositionType);
}
extern "C" {
pub fn gtk_button_get_image_position(button: *mut GtkButton) -> GtkPositionType;
}
extern "C" {
pub fn gtk_button_set_always_show_image(button: *mut GtkButton, always_show: gboolean);
}
extern "C" {
pub fn gtk_button_get_always_show_image(button: *mut GtkButton) -> gboolean;
}
extern "C" {
pub fn gtk_button_get_event_window(button: *mut GtkButton) -> *mut GdkWindow;
}
pub type GtkCalendar = _GtkCalendar;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCalendarPrivate {
_unused: [u8; 0],
}
pub type GtkCalendarPrivate = _GtkCalendarPrivate;
pub const GtkCalendarDisplayOptions_GTK_CALENDAR_SHOW_HEADING: GtkCalendarDisplayOptions = 1;
pub const GtkCalendarDisplayOptions_GTK_CALENDAR_SHOW_DAY_NAMES: GtkCalendarDisplayOptions = 2;
pub const GtkCalendarDisplayOptions_GTK_CALENDAR_NO_MONTH_CHANGE: GtkCalendarDisplayOptions = 4;
pub const GtkCalendarDisplayOptions_GTK_CALENDAR_SHOW_WEEK_NUMBERS: GtkCalendarDisplayOptions = 8;
pub const GtkCalendarDisplayOptions_GTK_CALENDAR_SHOW_DETAILS: GtkCalendarDisplayOptions = 32;
#[doc = " GtkCalendarDisplayOptions:\n @GTK_CALENDAR_SHOW_HEADING: Specifies that the month and year should be displayed.\n @GTK_CALENDAR_SHOW_DAY_NAMES: Specifies that three letter day descriptions should be present.\n @GTK_CALENDAR_NO_MONTH_CHANGE: Prevents the user from switching months with the calendar.\n @GTK_CALENDAR_SHOW_WEEK_NUMBERS: Displays each week numbers of the current year, down the\n left side of the calendar.\n @GTK_CALENDAR_SHOW_DETAILS: Just show an indicator, not the full details\n text when details are provided. See gtk_calendar_set_detail_func().\n\n These options can be used to influence the display and behaviour of a #GtkCalendar."]
pub type GtkCalendarDisplayOptions = ::std::os::raw::c_uint;
#[doc = " GtkCalendarDetailFunc:\n @calendar: a #GtkCalendar.\n @year: the year for which details are needed.\n @month: the month for which details are needed.\n @day: the day of @month for which details are needed.\n @user_data: the data passed with gtk_calendar_set_detail_func().\n\n This kind of functions provide Pango markup with detail information for the\n specified day. Examples for such details are holidays or appointments. The\n function returns %NULL when no information is available.\n\n Since: 2.14\n\n Returns: Newly allocated string with Pango markup with details\n for the specified day, or %NULL."]
pub type GtkCalendarDetailFunc = ::std::option::Option<
unsafe extern "C" fn(
calendar: *mut GtkCalendar,
year: guint,
month: guint,
day: guint,
user_data: gpointer,
) -> *mut gchar,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCalendar {
pub widget: GtkWidget,
pub priv_: *mut GtkCalendarPrivate,
}
#[test]
fn bindgen_test_layout__GtkCalendar() {
const UNINIT: ::std::mem::MaybeUninit<_GtkCalendar> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkCalendar>(),
40usize,
concat!("Size of: ", stringify!(_GtkCalendar))
);
assert_eq!(
::std::mem::align_of::<_GtkCalendar>(),
8usize,
concat!("Alignment of ", stringify!(_GtkCalendar))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).widget) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkCalendar),
"::",
stringify!(widget)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkCalendar),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkCalendar {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_calendar_get_type() -> GType;
}
extern "C" {
pub fn gtk_calendar_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_calendar_select_month(calendar: *mut GtkCalendar, month: guint, year: guint);
}
extern "C" {
pub fn gtk_calendar_select_day(calendar: *mut GtkCalendar, day: guint);
}
extern "C" {
pub fn gtk_calendar_mark_day(calendar: *mut GtkCalendar, day: guint);
}
extern "C" {
pub fn gtk_calendar_unmark_day(calendar: *mut GtkCalendar, day: guint);
}
extern "C" {
pub fn gtk_calendar_clear_marks(calendar: *mut GtkCalendar);
}
extern "C" {
pub fn gtk_calendar_set_display_options(
calendar: *mut GtkCalendar,
flags: GtkCalendarDisplayOptions,
);
}
extern "C" {
pub fn gtk_calendar_get_display_options(
calendar: *mut GtkCalendar,
) -> GtkCalendarDisplayOptions;
}
extern "C" {
pub fn gtk_calendar_get_date(
calendar: *mut GtkCalendar,
year: *mut guint,
month: *mut guint,
day: *mut guint,
);
}
extern "C" {
pub fn gtk_calendar_set_detail_func(
calendar: *mut GtkCalendar,
func: GtkCalendarDetailFunc,
data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_calendar_set_detail_width_chars(calendar: *mut GtkCalendar, chars: gint);
}
extern "C" {
pub fn gtk_calendar_set_detail_height_rows(calendar: *mut GtkCalendar, rows: gint);
}
extern "C" {
pub fn gtk_calendar_get_detail_width_chars(calendar: *mut GtkCalendar) -> gint;
}
extern "C" {
pub fn gtk_calendar_get_detail_height_rows(calendar: *mut GtkCalendar) -> gint;
}
extern "C" {
pub fn gtk_calendar_get_day_is_marked(calendar: *mut GtkCalendar, day: guint) -> gboolean;
}
pub type GtkCellAreaBox = _GtkCellAreaBox;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellAreaBoxPrivate {
_unused: [u8; 0],
}
pub type GtkCellAreaBoxPrivate = _GtkCellAreaBoxPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellAreaBox {
pub parent_instance: GtkCellArea,
pub priv_: *mut GtkCellAreaBoxPrivate,
}
#[test]
fn bindgen_test_layout__GtkCellAreaBox() {
const UNINIT: ::std::mem::MaybeUninit<_GtkCellAreaBox> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkCellAreaBox>(),
40usize,
concat!("Size of: ", stringify!(_GtkCellAreaBox))
);
assert_eq!(
::std::mem::align_of::<_GtkCellAreaBox>(),
8usize,
concat!("Alignment of ", stringify!(_GtkCellAreaBox))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaBox),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaBox),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkCellAreaBox {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_cell_area_box_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_area_box_new() -> *mut GtkCellArea;
}
extern "C" {
pub fn gtk_cell_area_box_pack_start(
box_: *mut GtkCellAreaBox,
renderer: *mut GtkCellRenderer,
expand: gboolean,
align: gboolean,
fixed: gboolean,
);
}
extern "C" {
pub fn gtk_cell_area_box_pack_end(
box_: *mut GtkCellAreaBox,
renderer: *mut GtkCellRenderer,
expand: gboolean,
align: gboolean,
fixed: gboolean,
);
}
extern "C" {
pub fn gtk_cell_area_box_get_spacing(box_: *mut GtkCellAreaBox) -> gint;
}
extern "C" {
pub fn gtk_cell_area_box_set_spacing(box_: *mut GtkCellAreaBox, spacing: gint);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellAreaContextPrivate {
_unused: [u8; 0],
}
pub type GtkCellAreaContextPrivate = _GtkCellAreaContextPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellAreaContext {
pub parent_instance: GObject,
pub priv_: *mut GtkCellAreaContextPrivate,
}
#[test]
fn bindgen_test_layout__GtkCellAreaContext() {
const UNINIT: ::std::mem::MaybeUninit<_GtkCellAreaContext> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkCellAreaContext>(),
32usize,
concat!("Size of: ", stringify!(_GtkCellAreaContext))
);
assert_eq!(
::std::mem::align_of::<_GtkCellAreaContext>(),
8usize,
concat!("Alignment of ", stringify!(_GtkCellAreaContext))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaContext),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellAreaContext),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkCellAreaContext {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_cell_area_context_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_area_context_get_area(context: *mut GtkCellAreaContext) -> *mut GtkCellArea;
}
extern "C" {
pub fn gtk_cell_area_context_allocate(
context: *mut GtkCellAreaContext,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_cell_area_context_reset(context: *mut GtkCellAreaContext);
}
extern "C" {
pub fn gtk_cell_area_context_get_preferred_width(
context: *mut GtkCellAreaContext,
minimum_width: *mut gint,
natural_width: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_area_context_get_preferred_height(
context: *mut GtkCellAreaContext,
minimum_height: *mut gint,
natural_height: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_area_context_get_preferred_height_for_width(
context: *mut GtkCellAreaContext,
width: gint,
minimum_height: *mut gint,
natural_height: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_area_context_get_preferred_width_for_height(
context: *mut GtkCellAreaContext,
height: gint,
minimum_width: *mut gint,
natural_width: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_area_context_get_allocation(
context: *mut GtkCellAreaContext,
width: *mut gint,
height: *mut gint,
);
}
extern "C" {
pub fn gtk_cell_area_context_push_preferred_width(
context: *mut GtkCellAreaContext,
minimum_width: gint,
natural_width: gint,
);
}
extern "C" {
pub fn gtk_cell_area_context_push_preferred_height(
context: *mut GtkCellAreaContext,
minimum_height: gint,
natural_height: gint,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellLayout {
_unused: [u8; 0],
}
pub type GtkCellLayout = _GtkCellLayout;
#[doc = " GtkCellLayoutDataFunc:\n @cell_layout: a #GtkCellLayout\n @cell: the cell renderer whose value is to be set\n @tree_model: the model\n @iter: a #GtkTreeIter indicating the row to set the value for\n @data: (closure): user data passed to gtk_cell_layout_set_cell_data_func()\n\n A function which should set the value of @cell_layout’s cell renderer(s)\n as appropriate."]
pub type GtkCellLayoutDataFunc = ::std::option::Option<
unsafe extern "C" fn(
cell_layout: *mut GtkCellLayout,
cell: *mut GtkCellRenderer,
tree_model: *mut GtkTreeModel,
iter: *mut GtkTreeIter,
data: gpointer,
),
>;
extern "C" {
pub fn gtk_cell_layout_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_layout_pack_start(
cell_layout: *mut GtkCellLayout,
cell: *mut GtkCellRenderer,
expand: gboolean,
);
}
extern "C" {
pub fn gtk_cell_layout_pack_end(
cell_layout: *mut GtkCellLayout,
cell: *mut GtkCellRenderer,
expand: gboolean,
);
}
extern "C" {
pub fn gtk_cell_layout_get_cells(cell_layout: *mut GtkCellLayout) -> *mut GList;
}
extern "C" {
pub fn gtk_cell_layout_clear(cell_layout: *mut GtkCellLayout);
}
extern "C" {
pub fn gtk_cell_layout_set_attributes(
cell_layout: *mut GtkCellLayout,
cell: *mut GtkCellRenderer,
...
);
}
extern "C" {
pub fn gtk_cell_layout_add_attribute(
cell_layout: *mut GtkCellLayout,
cell: *mut GtkCellRenderer,
attribute: *const gchar,
column: gint,
);
}
extern "C" {
pub fn gtk_cell_layout_set_cell_data_func(
cell_layout: *mut GtkCellLayout,
cell: *mut GtkCellRenderer,
func: GtkCellLayoutDataFunc,
func_data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_cell_layout_clear_attributes(
cell_layout: *mut GtkCellLayout,
cell: *mut GtkCellRenderer,
);
}
extern "C" {
pub fn gtk_cell_layout_reorder(
cell_layout: *mut GtkCellLayout,
cell: *mut GtkCellRenderer,
position: gint,
);
}
extern "C" {
pub fn gtk_cell_layout_get_area(cell_layout: *mut GtkCellLayout) -> *mut GtkCellArea;
}
pub type GtkCellRendererText = _GtkCellRendererText;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellRendererTextPrivate {
_unused: [u8; 0],
}
pub type GtkCellRendererTextPrivate = _GtkCellRendererTextPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellRendererText {
pub parent: GtkCellRenderer,
pub priv_: *mut GtkCellRendererTextPrivate,
}
#[test]
fn bindgen_test_layout__GtkCellRendererText() {
const UNINIT: ::std::mem::MaybeUninit<_GtkCellRendererText> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkCellRendererText>(),
40usize,
concat!("Size of: ", stringify!(_GtkCellRendererText))
);
assert_eq!(
::std::mem::align_of::<_GtkCellRendererText>(),
8usize,
concat!("Alignment of ", stringify!(_GtkCellRendererText))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererText),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererText),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkCellRendererText {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_cell_renderer_text_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_renderer_text_new() -> *mut GtkCellRenderer;
}
extern "C" {
pub fn gtk_cell_renderer_text_set_fixed_height_from_font(
renderer: *mut GtkCellRendererText,
number_of_rows: gint,
);
}
extern "C" {
pub fn gtk_cell_renderer_accel_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_renderer_accel_new() -> *mut GtkCellRenderer;
}
extern "C" {
pub fn gtk_cell_renderer_combo_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_renderer_combo_new() -> *mut GtkCellRenderer;
}
extern "C" {
pub fn gtk_cell_renderer_pixbuf_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_renderer_pixbuf_new() -> *mut GtkCellRenderer;
}
extern "C" {
pub fn gtk_cell_renderer_progress_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_renderer_progress_new() -> *mut GtkCellRenderer;
}
extern "C" {
pub fn gtk_cell_renderer_spin_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_renderer_spin_new() -> *mut GtkCellRenderer;
}
extern "C" {
pub fn gtk_cell_renderer_spinner_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_renderer_spinner_new() -> *mut GtkCellRenderer;
}
pub type GtkCellRendererToggle = _GtkCellRendererToggle;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellRendererTogglePrivate {
_unused: [u8; 0],
}
pub type GtkCellRendererTogglePrivate = _GtkCellRendererTogglePrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellRendererToggle {
pub parent: GtkCellRenderer,
pub priv_: *mut GtkCellRendererTogglePrivate,
}
#[test]
fn bindgen_test_layout__GtkCellRendererToggle() {
const UNINIT: ::std::mem::MaybeUninit<_GtkCellRendererToggle> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkCellRendererToggle>(),
40usize,
concat!("Size of: ", stringify!(_GtkCellRendererToggle))
);
assert_eq!(
::std::mem::align_of::<_GtkCellRendererToggle>(),
8usize,
concat!("Alignment of ", stringify!(_GtkCellRendererToggle))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererToggle),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellRendererToggle),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkCellRendererToggle {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_cell_renderer_toggle_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_renderer_toggle_new() -> *mut GtkCellRenderer;
}
extern "C" {
pub fn gtk_cell_renderer_toggle_get_radio(toggle: *mut GtkCellRendererToggle) -> gboolean;
}
extern "C" {
pub fn gtk_cell_renderer_toggle_set_radio(toggle: *mut GtkCellRendererToggle, radio: gboolean);
}
extern "C" {
pub fn gtk_cell_renderer_toggle_get_active(toggle: *mut GtkCellRendererToggle) -> gboolean;
}
extern "C" {
pub fn gtk_cell_renderer_toggle_set_active(
toggle: *mut GtkCellRendererToggle,
setting: gboolean,
);
}
extern "C" {
pub fn gtk_cell_renderer_toggle_get_activatable(toggle: *mut GtkCellRendererToggle)
-> gboolean;
}
extern "C" {
pub fn gtk_cell_renderer_toggle_set_activatable(
toggle: *mut GtkCellRendererToggle,
setting: gboolean,
);
}
pub type GtkCellView = _GtkCellView;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellViewPrivate {
_unused: [u8; 0],
}
pub type GtkCellViewPrivate = _GtkCellViewPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCellView {
pub parent_instance: GtkWidget,
pub priv_: *mut GtkCellViewPrivate,
}
#[test]
fn bindgen_test_layout__GtkCellView() {
const UNINIT: ::std::mem::MaybeUninit<_GtkCellView> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkCellView>(),
40usize,
concat!("Size of: ", stringify!(_GtkCellView))
);
assert_eq!(
::std::mem::align_of::<_GtkCellView>(),
8usize,
concat!("Alignment of ", stringify!(_GtkCellView))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellView),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkCellView),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkCellView {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_cell_view_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_view_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_cell_view_new_with_context(
area: *mut GtkCellArea,
context: *mut GtkCellAreaContext,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_cell_view_new_with_text(text: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_cell_view_new_with_markup(markup: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_cell_view_new_with_pixbuf(pixbuf: *mut GdkPixbuf) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_cell_view_set_model(cell_view: *mut GtkCellView, model: *mut GtkTreeModel);
}
extern "C" {
pub fn gtk_cell_view_get_model(cell_view: *mut GtkCellView) -> *mut GtkTreeModel;
}
extern "C" {
pub fn gtk_cell_view_set_displayed_row(cell_view: *mut GtkCellView, path: *mut GtkTreePath);
}
extern "C" {
pub fn gtk_cell_view_get_displayed_row(cell_view: *mut GtkCellView) -> *mut GtkTreePath;
}
extern "C" {
pub fn gtk_cell_view_set_background_rgba(cell_view: *mut GtkCellView, rgba: *const GdkRGBA);
}
extern "C" {
pub fn gtk_cell_view_get_draw_sensitive(cell_view: *mut GtkCellView) -> gboolean;
}
extern "C" {
pub fn gtk_cell_view_set_draw_sensitive(cell_view: *mut GtkCellView, draw_sensitive: gboolean);
}
extern "C" {
pub fn gtk_cell_view_get_fit_model(cell_view: *mut GtkCellView) -> gboolean;
}
extern "C" {
pub fn gtk_cell_view_set_fit_model(cell_view: *mut GtkCellView, fit_model: gboolean);
}
extern "C" {
pub fn gtk_cell_view_get_size_of_row(
cell_view: *mut GtkCellView,
path: *mut GtkTreePath,
requisition: *mut GtkRequisition,
) -> gboolean;
}
extern "C" {
pub fn gtk_cell_view_set_background_color(cell_view: *mut GtkCellView, color: *const GdkColor);
}
pub type GtkToggleButton = _GtkToggleButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToggleButtonPrivate {
_unused: [u8; 0],
}
pub type GtkToggleButtonPrivate = _GtkToggleButtonPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToggleButton {
pub button: GtkButton,
pub priv_: *mut GtkToggleButtonPrivate,
}
#[test]
fn bindgen_test_layout__GtkToggleButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkToggleButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkToggleButton>(),
64usize,
concat!("Size of: ", stringify!(_GtkToggleButton))
);
assert_eq!(
::std::mem::align_of::<_GtkToggleButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkToggleButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkToggleButton),
"::",
stringify!(button)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkToggleButton),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkToggleButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_toggle_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_toggle_button_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_toggle_button_new_with_label(label: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_toggle_button_new_with_mnemonic(label: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_toggle_button_set_mode(
toggle_button: *mut GtkToggleButton,
draw_indicator: gboolean,
);
}
extern "C" {
pub fn gtk_toggle_button_get_mode(toggle_button: *mut GtkToggleButton) -> gboolean;
}
extern "C" {
pub fn gtk_toggle_button_set_active(toggle_button: *mut GtkToggleButton, is_active: gboolean);
}
extern "C" {
pub fn gtk_toggle_button_get_active(toggle_button: *mut GtkToggleButton) -> gboolean;
}
extern "C" {
pub fn gtk_toggle_button_toggled(toggle_button: *mut GtkToggleButton);
}
extern "C" {
pub fn gtk_toggle_button_set_inconsistent(
toggle_button: *mut GtkToggleButton,
setting: gboolean,
);
}
extern "C" {
pub fn gtk_toggle_button_get_inconsistent(toggle_button: *mut GtkToggleButton) -> gboolean;
}
pub type GtkCheckButton = _GtkCheckButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCheckButton {
pub toggle_button: GtkToggleButton,
}
#[test]
fn bindgen_test_layout__GtkCheckButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkCheckButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkCheckButton>(),
64usize,
concat!("Size of: ", stringify!(_GtkCheckButton))
);
assert_eq!(
::std::mem::align_of::<_GtkCheckButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkCheckButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).toggle_button) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkCheckButton),
"::",
stringify!(toggle_button)
)
);
}
impl Default for _GtkCheckButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_check_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_check_button_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_check_button_new_with_label(label: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_check_button_new_with_mnemonic(label: *const gchar) -> *mut GtkWidget;
}
pub type GtkMenuItem = _GtkMenuItem;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMenuItemPrivate {
_unused: [u8; 0],
}
pub type GtkMenuItemPrivate = _GtkMenuItemPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMenuItem {
pub bin: GtkBin,
pub priv_: *mut GtkMenuItemPrivate,
}
#[test]
fn bindgen_test_layout__GtkMenuItem() {
const UNINIT: ::std::mem::MaybeUninit<_GtkMenuItem> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkMenuItem>(),
56usize,
concat!("Size of: ", stringify!(_GtkMenuItem))
);
assert_eq!(
::std::mem::align_of::<_GtkMenuItem>(),
8usize,
concat!("Alignment of ", stringify!(_GtkMenuItem))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bin) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkMenuItem),
"::",
stringify!(bin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkMenuItem),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkMenuItem {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_menu_item_get_type() -> GType;
}
extern "C" {
pub fn gtk_menu_item_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_menu_item_new_with_label(label: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_menu_item_new_with_mnemonic(label: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_menu_item_set_submenu(menu_item: *mut GtkMenuItem, submenu: *mut GtkWidget);
}
extern "C" {
pub fn gtk_menu_item_get_submenu(menu_item: *mut GtkMenuItem) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_menu_item_select(menu_item: *mut GtkMenuItem);
}
extern "C" {
pub fn gtk_menu_item_deselect(menu_item: *mut GtkMenuItem);
}
extern "C" {
pub fn gtk_menu_item_activate(menu_item: *mut GtkMenuItem);
}
extern "C" {
pub fn gtk_menu_item_toggle_size_request(menu_item: *mut GtkMenuItem, requisition: *mut gint);
}
extern "C" {
pub fn gtk_menu_item_toggle_size_allocate(menu_item: *mut GtkMenuItem, allocation: gint);
}
extern "C" {
pub fn gtk_menu_item_set_right_justified(
menu_item: *mut GtkMenuItem,
right_justified: gboolean,
);
}
extern "C" {
pub fn gtk_menu_item_get_right_justified(menu_item: *mut GtkMenuItem) -> gboolean;
}
extern "C" {
pub fn gtk_menu_item_set_accel_path(menu_item: *mut GtkMenuItem, accel_path: *const gchar);
}
extern "C" {
pub fn gtk_menu_item_get_accel_path(menu_item: *mut GtkMenuItem) -> *const gchar;
}
extern "C" {
pub fn gtk_menu_item_set_label(menu_item: *mut GtkMenuItem, label: *const gchar);
}
extern "C" {
pub fn gtk_menu_item_get_label(menu_item: *mut GtkMenuItem) -> *const gchar;
}
extern "C" {
pub fn gtk_menu_item_set_use_underline(menu_item: *mut GtkMenuItem, setting: gboolean);
}
extern "C" {
pub fn gtk_menu_item_get_use_underline(menu_item: *mut GtkMenuItem) -> gboolean;
}
extern "C" {
pub fn gtk_menu_item_set_reserve_indicator(menu_item: *mut GtkMenuItem, reserve: gboolean);
}
extern "C" {
pub fn gtk_menu_item_get_reserve_indicator(menu_item: *mut GtkMenuItem) -> gboolean;
}
pub type GtkCheckMenuItem = _GtkCheckMenuItem;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCheckMenuItemPrivate {
_unused: [u8; 0],
}
pub type GtkCheckMenuItemPrivate = _GtkCheckMenuItemPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCheckMenuItem {
pub menu_item: GtkMenuItem,
pub priv_: *mut GtkCheckMenuItemPrivate,
}
#[test]
fn bindgen_test_layout__GtkCheckMenuItem() {
const UNINIT: ::std::mem::MaybeUninit<_GtkCheckMenuItem> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkCheckMenuItem>(),
64usize,
concat!("Size of: ", stringify!(_GtkCheckMenuItem))
);
assert_eq!(
::std::mem::align_of::<_GtkCheckMenuItem>(),
8usize,
concat!("Alignment of ", stringify!(_GtkCheckMenuItem))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).menu_item) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkCheckMenuItem),
"::",
stringify!(menu_item)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkCheckMenuItem),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkCheckMenuItem {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_check_menu_item_get_type() -> GType;
}
extern "C" {
pub fn gtk_check_menu_item_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_check_menu_item_new_with_label(label: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_check_menu_item_new_with_mnemonic(label: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_check_menu_item_set_active(
check_menu_item: *mut GtkCheckMenuItem,
is_active: gboolean,
);
}
extern "C" {
pub fn gtk_check_menu_item_get_active(check_menu_item: *mut GtkCheckMenuItem) -> gboolean;
}
extern "C" {
pub fn gtk_check_menu_item_toggled(check_menu_item: *mut GtkCheckMenuItem);
}
extern "C" {
pub fn gtk_check_menu_item_set_inconsistent(
check_menu_item: *mut GtkCheckMenuItem,
setting: gboolean,
);
}
extern "C" {
pub fn gtk_check_menu_item_get_inconsistent(check_menu_item: *mut GtkCheckMenuItem)
-> gboolean;
}
extern "C" {
pub fn gtk_check_menu_item_set_draw_as_radio(
check_menu_item: *mut GtkCheckMenuItem,
draw_as_radio: gboolean,
);
}
extern "C" {
pub fn gtk_check_menu_item_get_draw_as_radio(
check_menu_item: *mut GtkCheckMenuItem,
) -> gboolean;
}
#[doc = " GtkClipboardReceivedFunc:\n @clipboard: the #GtkClipboard\n @selection_data: a #GtkSelectionData containing the data was received.\n If retrieving the data failed, then then length field\n of @selection_data will be negative.\n @data: (closure): the @user_data supplied to\n gtk_clipboard_request_contents().\n\n A function to be called when the results of gtk_clipboard_request_contents()\n are received, or when the request fails."]
pub type GtkClipboardReceivedFunc = ::std::option::Option<
unsafe extern "C" fn(
clipboard: *mut GtkClipboard,
selection_data: *mut GtkSelectionData,
data: gpointer,
),
>;
#[doc = " GtkClipboardTextReceivedFunc:\n @clipboard: the #GtkClipboard\n @text: (nullable): the text received, as a UTF-8 encoded string, or\n %NULL if retrieving the data failed.\n @data: (closure): the @user_data supplied to\n gtk_clipboard_request_text().\n\n A function to be called when the results of gtk_clipboard_request_text()\n are received, or when the request fails."]
pub type GtkClipboardTextReceivedFunc = ::std::option::Option<
unsafe extern "C" fn(clipboard: *mut GtkClipboard, text: *const gchar, data: gpointer),
>;
#[doc = " GtkClipboardRichTextReceivedFunc:\n @clipboard: the #GtkClipboard\n @format: The format of the rich text\n @text: (nullable) (type utf8): the rich text received, as\n a UTF-8 encoded string, or %NULL if retrieving the data failed.\n @length: Length of the text.\n @data: (closure): the @user_data supplied to\n gtk_clipboard_request_rich_text().\n\n A function to be called when the results of\n gtk_clipboard_request_rich_text() are received, or when the request\n fails.\n\n Since: 2.10"]
pub type GtkClipboardRichTextReceivedFunc = ::std::option::Option<
unsafe extern "C" fn(
clipboard: *mut GtkClipboard,
format: GdkAtom,
text: *const guint8,
length: gsize,
data: gpointer,
),
>;
#[doc = " GtkClipboardImageReceivedFunc:\n @clipboard: the #GtkClipboard\n @pixbuf: the received image\n @data: (closure): the @user_data supplied to\n gtk_clipboard_request_image().\n\n A function to be called when the results of gtk_clipboard_request_image()\n are received, or when the request fails.\n\n Since: 2.6"]
pub type GtkClipboardImageReceivedFunc = ::std::option::Option<
unsafe extern "C" fn(clipboard: *mut GtkClipboard, pixbuf: *mut GdkPixbuf, data: gpointer),
>;
#[doc = " GtkClipboardURIReceivedFunc:\n @clipboard: the #GtkClipboard\n @uris: (array zero-terminated=1): the received URIs\n @data: (closure): the @user_data supplied to\n gtk_clipboard_request_uris().\n\n A function to be called when the results of\n gtk_clipboard_request_uris() are received, or when the request\n fails.\n\n Since: 2.14"]
pub type GtkClipboardURIReceivedFunc = ::std::option::Option<
unsafe extern "C" fn(clipboard: *mut GtkClipboard, uris: *mut *mut gchar, data: gpointer),
>;
#[doc = " GtkClipboardTargetsReceivedFunc:\n @clipboard: the #GtkClipboard\n @atoms: (nullable) (array length=n_atoms): the supported targets,\n as array of #GdkAtom, or %NULL if retrieving the data failed.\n @n_atoms: the length of the @atoms array.\n @data: (closure): the @user_data supplied to\n gtk_clipboard_request_targets().\n\n A function to be called when the results of gtk_clipboard_request_targets()\n are received, or when the request fails.\n\n Since: 2.4"]
pub type GtkClipboardTargetsReceivedFunc = ::std::option::Option<
unsafe extern "C" fn(
clipboard: *mut GtkClipboard,
atoms: *mut GdkAtom,
n_atoms: gint,
data: gpointer,
),
>;
#[doc = " GtkClipboardGetFunc:\n @clipboard: the #GtkClipboard\n @selection_data: a #GtkSelectionData argument in which the requested\n data should be stored.\n @info: the info field corresponding to the requested target from the\n #GtkTargetEntry array passed to gtk_clipboard_set_with_data() or\n gtk_clipboard_set_with_owner().\n @user_data_or_owner: the @user_data argument passed to\n gtk_clipboard_set_with_data(), or the @owner argument passed to\n gtk_clipboard_set_with_owner()\n\n A function that will be called to provide the contents of the selection.\n If multiple types of data were advertised, the requested type can\n be determined from the @info parameter or by checking the target field\n of @selection_data. If the data could successfully be converted into\n then it should be stored into the @selection_data object by\n calling gtk_selection_data_set() (or related functions such\n as gtk_selection_data_set_text()). If no data is set, the requestor\n will be informed that the attempt to get the data failed."]
pub type GtkClipboardGetFunc = ::std::option::Option<
unsafe extern "C" fn(
clipboard: *mut GtkClipboard,
selection_data: *mut GtkSelectionData,
info: guint,
user_data_or_owner: gpointer,
),
>;
#[doc = " GtkClipboardClearFunc:\n @clipboard: the #GtkClipboard\n @user_data_or_owner: the @user_data argument passed to gtk_clipboard_set_with_data(),\n or the @owner argument passed to gtk_clipboard_set_with_owner()\n\n A function that will be called when the contents of the clipboard are changed\n or cleared. Once this has called, the @user_data_or_owner argument\n will not be used again."]
pub type GtkClipboardClearFunc = ::std::option::Option<
unsafe extern "C" fn(clipboard: *mut GtkClipboard, user_data_or_owner: gpointer),
>;
extern "C" {
pub fn gtk_clipboard_get_type() -> GType;
}
extern "C" {
pub fn gtk_clipboard_get_for_display(
display: *mut GdkDisplay,
selection: GdkAtom,
) -> *mut GtkClipboard;
}
extern "C" {
pub fn gtk_clipboard_get(selection: GdkAtom) -> *mut GtkClipboard;
}
extern "C" {
pub fn gtk_clipboard_get_display(clipboard: *mut GtkClipboard) -> *mut GdkDisplay;
}
extern "C" {
pub fn gtk_clipboard_set_with_data(
clipboard: *mut GtkClipboard,
targets: *const GtkTargetEntry,
n_targets: guint,
get_func: GtkClipboardGetFunc,
clear_func: GtkClipboardClearFunc,
user_data: gpointer,
) -> gboolean;
}
extern "C" {
pub fn gtk_clipboard_set_with_owner(
clipboard: *mut GtkClipboard,
targets: *const GtkTargetEntry,
n_targets: guint,
get_func: GtkClipboardGetFunc,
clear_func: GtkClipboardClearFunc,
owner: *mut GObject,
) -> gboolean;
}
extern "C" {
pub fn gtk_clipboard_get_owner(clipboard: *mut GtkClipboard) -> *mut GObject;
}
extern "C" {
pub fn gtk_clipboard_clear(clipboard: *mut GtkClipboard);
}
extern "C" {
pub fn gtk_clipboard_set_text(clipboard: *mut GtkClipboard, text: *const gchar, len: gint);
}
extern "C" {
pub fn gtk_clipboard_set_image(clipboard: *mut GtkClipboard, pixbuf: *mut GdkPixbuf);
}
extern "C" {
pub fn gtk_clipboard_request_contents(
clipboard: *mut GtkClipboard,
target: GdkAtom,
callback: GtkClipboardReceivedFunc,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_clipboard_request_text(
clipboard: *mut GtkClipboard,
callback: GtkClipboardTextReceivedFunc,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_clipboard_request_rich_text(
clipboard: *mut GtkClipboard,
buffer: *mut GtkTextBuffer,
callback: GtkClipboardRichTextReceivedFunc,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_clipboard_request_image(
clipboard: *mut GtkClipboard,
callback: GtkClipboardImageReceivedFunc,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_clipboard_request_uris(
clipboard: *mut GtkClipboard,
callback: GtkClipboardURIReceivedFunc,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_clipboard_request_targets(
clipboard: *mut GtkClipboard,
callback: GtkClipboardTargetsReceivedFunc,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_clipboard_wait_for_contents(
clipboard: *mut GtkClipboard,
target: GdkAtom,
) -> *mut GtkSelectionData;
}
extern "C" {
pub fn gtk_clipboard_wait_for_text(clipboard: *mut GtkClipboard) -> *mut gchar;
}
extern "C" {
pub fn gtk_clipboard_wait_for_rich_text(
clipboard: *mut GtkClipboard,
buffer: *mut GtkTextBuffer,
format: *mut GdkAtom,
length: *mut gsize,
) -> *mut guint8;
}
extern "C" {
pub fn gtk_clipboard_wait_for_image(clipboard: *mut GtkClipboard) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_clipboard_wait_for_uris(clipboard: *mut GtkClipboard) -> *mut *mut gchar;
}
extern "C" {
pub fn gtk_clipboard_wait_for_targets(
clipboard: *mut GtkClipboard,
targets: *mut *mut GdkAtom,
n_targets: *mut gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_clipboard_wait_is_text_available(clipboard: *mut GtkClipboard) -> gboolean;
}
extern "C" {
pub fn gtk_clipboard_wait_is_rich_text_available(
clipboard: *mut GtkClipboard,
buffer: *mut GtkTextBuffer,
) -> gboolean;
}
extern "C" {
pub fn gtk_clipboard_wait_is_image_available(clipboard: *mut GtkClipboard) -> gboolean;
}
extern "C" {
pub fn gtk_clipboard_wait_is_uris_available(clipboard: *mut GtkClipboard) -> gboolean;
}
extern "C" {
pub fn gtk_clipboard_wait_is_target_available(
clipboard: *mut GtkClipboard,
target: GdkAtom,
) -> gboolean;
}
extern "C" {
pub fn gtk_clipboard_set_can_store(
clipboard: *mut GtkClipboard,
targets: *const GtkTargetEntry,
n_targets: gint,
);
}
extern "C" {
pub fn gtk_clipboard_store(clipboard: *mut GtkClipboard);
}
pub type GtkColorButton = _GtkColorButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkColorButtonPrivate {
_unused: [u8; 0],
}
pub type GtkColorButtonPrivate = _GtkColorButtonPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkColorButton {
pub button: GtkButton,
pub priv_: *mut GtkColorButtonPrivate,
}
#[test]
fn bindgen_test_layout__GtkColorButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkColorButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkColorButton>(),
64usize,
concat!("Size of: ", stringify!(_GtkColorButton))
);
assert_eq!(
::std::mem::align_of::<_GtkColorButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkColorButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkColorButton),
"::",
stringify!(button)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkColorButton),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkColorButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_color_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_color_button_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_color_button_new_with_rgba(rgba: *const GdkRGBA) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_color_button_set_title(button: *mut GtkColorButton, title: *const gchar);
}
extern "C" {
pub fn gtk_color_button_get_title(button: *mut GtkColorButton) -> *const gchar;
}
extern "C" {
pub fn gtk_color_button_new_with_color(color: *const GdkColor) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_color_button_set_color(button: *mut GtkColorButton, color: *const GdkColor);
}
extern "C" {
pub fn gtk_color_button_get_color(button: *mut GtkColorButton, color: *mut GdkColor);
}
extern "C" {
pub fn gtk_color_button_set_alpha(button: *mut GtkColorButton, alpha: guint16);
}
extern "C" {
pub fn gtk_color_button_get_alpha(button: *mut GtkColorButton) -> guint16;
}
extern "C" {
pub fn gtk_color_button_set_use_alpha(button: *mut GtkColorButton, use_alpha: gboolean);
}
extern "C" {
pub fn gtk_color_button_get_use_alpha(button: *mut GtkColorButton) -> gboolean;
}
extern "C" {
pub fn gtk_color_button_set_rgba(button: *mut GtkColorButton, rgba: *const GdkRGBA);
}
extern "C" {
pub fn gtk_color_button_get_rgba(button: *mut GtkColorButton, rgba: *mut GdkRGBA);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkColorChooser {
_unused: [u8; 0],
}
pub type GtkColorChooser = _GtkColorChooser;
extern "C" {
pub fn gtk_color_chooser_get_type() -> GType;
}
extern "C" {
pub fn gtk_color_chooser_get_rgba(chooser: *mut GtkColorChooser, color: *mut GdkRGBA);
}
extern "C" {
pub fn gtk_color_chooser_set_rgba(chooser: *mut GtkColorChooser, color: *const GdkRGBA);
}
extern "C" {
pub fn gtk_color_chooser_get_use_alpha(chooser: *mut GtkColorChooser) -> gboolean;
}
extern "C" {
pub fn gtk_color_chooser_set_use_alpha(chooser: *mut GtkColorChooser, use_alpha: gboolean);
}
extern "C" {
pub fn gtk_color_chooser_add_palette(
chooser: *mut GtkColorChooser,
orientation: GtkOrientation,
colors_per_line: gint,
n_colors: gint,
colors: *mut GdkRGBA,
);
}
extern "C" {
pub fn gtk_color_chooser_dialog_get_type() -> GType;
}
extern "C" {
pub fn gtk_color_chooser_dialog_new(
title: *const gchar,
parent: *mut GtkWindow,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_color_chooser_widget_get_type() -> GType;
}
extern "C" {
pub fn gtk_color_chooser_widget_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_hsv_to_rgb(
h: gdouble,
s: gdouble,
v: gdouble,
r: *mut gdouble,
g: *mut gdouble,
b: *mut gdouble,
);
}
extern "C" {
pub fn gtk_rgb_to_hsv(
r: gdouble,
g: gdouble,
b: gdouble,
h: *mut gdouble,
s: *mut gdouble,
v: *mut gdouble,
);
}
pub type GtkComboBoxText = _GtkComboBoxText;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkComboBoxTextPrivate {
_unused: [u8; 0],
}
pub type GtkComboBoxTextPrivate = _GtkComboBoxTextPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkComboBoxText {
pub parent_instance: GtkComboBox,
pub priv_: *mut GtkComboBoxTextPrivate,
}
#[test]
fn bindgen_test_layout__GtkComboBoxText() {
const UNINIT: ::std::mem::MaybeUninit<_GtkComboBoxText> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkComboBoxText>(),
64usize,
concat!("Size of: ", stringify!(_GtkComboBoxText))
);
assert_eq!(
::std::mem::align_of::<_GtkComboBoxText>(),
8usize,
concat!("Alignment of ", stringify!(_GtkComboBoxText))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkComboBoxText),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkComboBoxText),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkComboBoxText {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_combo_box_text_get_type() -> GType;
}
extern "C" {
pub fn gtk_combo_box_text_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_combo_box_text_new_with_entry() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_combo_box_text_append_text(combo_box: *mut GtkComboBoxText, text: *const gchar);
}
extern "C" {
pub fn gtk_combo_box_text_insert_text(
combo_box: *mut GtkComboBoxText,
position: gint,
text: *const gchar,
);
}
extern "C" {
pub fn gtk_combo_box_text_prepend_text(combo_box: *mut GtkComboBoxText, text: *const gchar);
}
extern "C" {
pub fn gtk_combo_box_text_remove(combo_box: *mut GtkComboBoxText, position: gint);
}
extern "C" {
pub fn gtk_combo_box_text_remove_all(combo_box: *mut GtkComboBoxText);
}
extern "C" {
pub fn gtk_combo_box_text_get_active_text(combo_box: *mut GtkComboBoxText) -> *mut gchar;
}
extern "C" {
pub fn gtk_combo_box_text_insert(
combo_box: *mut GtkComboBoxText,
position: gint,
id: *const gchar,
text: *const gchar,
);
}
extern "C" {
pub fn gtk_combo_box_text_append(
combo_box: *mut GtkComboBoxText,
id: *const gchar,
text: *const gchar,
);
}
extern "C" {
pub fn gtk_combo_box_text_prepend(
combo_box: *mut GtkComboBoxText,
id: *const gchar,
text: *const gchar,
);
}
pub const GtkCssSectionType_GTK_CSS_SECTION_DOCUMENT: GtkCssSectionType = 0;
pub const GtkCssSectionType_GTK_CSS_SECTION_IMPORT: GtkCssSectionType = 1;
pub const GtkCssSectionType_GTK_CSS_SECTION_COLOR_DEFINITION: GtkCssSectionType = 2;
pub const GtkCssSectionType_GTK_CSS_SECTION_BINDING_SET: GtkCssSectionType = 3;
pub const GtkCssSectionType_GTK_CSS_SECTION_RULESET: GtkCssSectionType = 4;
pub const GtkCssSectionType_GTK_CSS_SECTION_SELECTOR: GtkCssSectionType = 5;
pub const GtkCssSectionType_GTK_CSS_SECTION_DECLARATION: GtkCssSectionType = 6;
pub const GtkCssSectionType_GTK_CSS_SECTION_VALUE: GtkCssSectionType = 7;
pub const GtkCssSectionType_GTK_CSS_SECTION_KEYFRAMES: GtkCssSectionType = 8;
#[doc = " GtkCssSectionType:\n @GTK_CSS_SECTION_DOCUMENT: The section describes a complete document.\n This section time is the only one where gtk_css_section_get_parent()\n might return %NULL.\n @GTK_CSS_SECTION_IMPORT: The section defines an import rule.\n @GTK_CSS_SECTION_COLOR_DEFINITION: The section defines a color. This\n is a GTK extension to CSS.\n @GTK_CSS_SECTION_BINDING_SET: The section defines a binding set. This\n is a GTK extension to CSS.\n @GTK_CSS_SECTION_RULESET: The section defines a CSS ruleset.\n @GTK_CSS_SECTION_SELECTOR: The section defines a CSS selector.\n @GTK_CSS_SECTION_DECLARATION: The section defines the declaration of\n a CSS variable.\n @GTK_CSS_SECTION_VALUE: The section defines the value of a CSS declaration.\n @GTK_CSS_SECTION_KEYFRAMES: The section defines keyframes. See [CSS\n Animations](http://dev.w3.org/csswg/css3-animations/#keyframes) for details. Since 3.6\n\n The different types of sections indicate parts of a CSS document as\n parsed by GTK’s CSS parser. They are oriented towards the\n [CSS Grammar](http://www.w3.org/TR/CSS21/grammar.html),\n but may contain extensions.\n\n More types might be added in the future as the parser incorporates\n more features.\n\n Since: 3.2"]
pub type GtkCssSectionType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCssSection {
_unused: [u8; 0],
}
pub type GtkCssSection = _GtkCssSection;
extern "C" {
pub fn gtk_css_section_get_type() -> GType;
}
extern "C" {
pub fn gtk_css_section_ref(section: *mut GtkCssSection) -> *mut GtkCssSection;
}
extern "C" {
pub fn gtk_css_section_unref(section: *mut GtkCssSection);
}
extern "C" {
pub fn gtk_css_section_get_section_type(section: *const GtkCssSection) -> GtkCssSectionType;
}
extern "C" {
pub fn gtk_css_section_get_parent(section: *const GtkCssSection) -> *mut GtkCssSection;
}
extern "C" {
pub fn gtk_css_section_get_file(section: *const GtkCssSection) -> *mut GFile;
}
extern "C" {
pub fn gtk_css_section_get_start_line(section: *const GtkCssSection) -> guint;
}
extern "C" {
pub fn gtk_css_section_get_start_position(section: *const GtkCssSection) -> guint;
}
extern "C" {
pub fn gtk_css_section_get_end_line(section: *const GtkCssSection) -> guint;
}
extern "C" {
pub fn gtk_css_section_get_end_position(section: *const GtkCssSection) -> guint;
}
extern "C" {
pub fn gtk_css_provider_error_quark() -> GQuark;
}
pub type GtkCssProvider = _GtkCssProvider;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCssProviderPrivate {
_unused: [u8; 0],
}
pub type GtkCssProviderPrivate = _GtkCssProviderPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkCssProvider {
pub parent_instance: GObject,
pub priv_: *mut GtkCssProviderPrivate,
}
#[test]
fn bindgen_test_layout__GtkCssProvider() {
const UNINIT: ::std::mem::MaybeUninit<_GtkCssProvider> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkCssProvider>(),
32usize,
concat!("Size of: ", stringify!(_GtkCssProvider))
);
assert_eq!(
::std::mem::align_of::<_GtkCssProvider>(),
8usize,
concat!("Alignment of ", stringify!(_GtkCssProvider))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkCssProvider),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkCssProvider),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkCssProvider {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_css_provider_get_type() -> GType;
}
extern "C" {
pub fn gtk_css_provider_new() -> *mut GtkCssProvider;
}
extern "C" {
pub fn gtk_css_provider_to_string(provider: *mut GtkCssProvider)
-> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn gtk_css_provider_load_from_data(
css_provider: *mut GtkCssProvider,
data: *const gchar,
length: gssize,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_css_provider_load_from_file(
css_provider: *mut GtkCssProvider,
file: *mut GFile,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_css_provider_load_from_path(
css_provider: *mut GtkCssProvider,
path: *const gchar,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_css_provider_get_default() -> *mut GtkCssProvider;
}
extern "C" {
pub fn gtk_css_provider_get_named(
name: *const gchar,
variant: *const gchar,
) -> *mut GtkCssProvider;
}
extern "C" {
pub fn gtk_get_debug_flags() -> guint;
}
extern "C" {
pub fn gtk_set_debug_flags(flags: guint);
}
extern "C" {
pub fn gtk_drawing_area_get_type() -> GType;
}
extern "C" {
pub fn gtk_drawing_area_new() -> *mut GtkWidget;
}
pub type GtkEventBox = _GtkEventBox;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkEventBoxPrivate {
_unused: [u8; 0],
}
pub type GtkEventBoxPrivate = _GtkEventBoxPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkEventBox {
pub bin: GtkBin,
pub priv_: *mut GtkEventBoxPrivate,
}
#[test]
fn bindgen_test_layout__GtkEventBox() {
const UNINIT: ::std::mem::MaybeUninit<_GtkEventBox> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkEventBox>(),
56usize,
concat!("Size of: ", stringify!(_GtkEventBox))
);
assert_eq!(
::std::mem::align_of::<_GtkEventBox>(),
8usize,
concat!("Alignment of ", stringify!(_GtkEventBox))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bin) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkEventBox),
"::",
stringify!(bin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkEventBox),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkEventBox {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_event_box_get_type() -> GType;
}
extern "C" {
pub fn gtk_event_box_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_event_box_get_visible_window(event_box: *mut GtkEventBox) -> gboolean;
}
extern "C" {
pub fn gtk_event_box_set_visible_window(event_box: *mut GtkEventBox, visible_window: gboolean);
}
extern "C" {
pub fn gtk_event_box_get_above_child(event_box: *mut GtkEventBox) -> gboolean;
}
extern "C" {
pub fn gtk_event_box_set_above_child(event_box: *mut GtkEventBox, above_child: gboolean);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkEventController {
_unused: [u8; 0],
}
pub type GtkEventController = _GtkEventController;
extern "C" {
pub fn gtk_event_controller_get_type() -> GType;
}
extern "C" {
pub fn gtk_event_controller_get_widget(controller: *mut GtkEventController) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_event_controller_handle_event(
controller: *mut GtkEventController,
event: *const GdkEvent,
) -> gboolean;
}
extern "C" {
pub fn gtk_event_controller_reset(controller: *mut GtkEventController);
}
extern "C" {
pub fn gtk_event_controller_get_propagation_phase(
controller: *mut GtkEventController,
) -> GtkPropagationPhase;
}
extern "C" {
pub fn gtk_event_controller_set_propagation_phase(
controller: *mut GtkEventController,
phase: GtkPropagationPhase,
);
}
pub type GtkExpander = _GtkExpander;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkExpanderPrivate {
_unused: [u8; 0],
}
pub type GtkExpanderPrivate = _GtkExpanderPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkExpander {
pub bin: GtkBin,
pub priv_: *mut GtkExpanderPrivate,
}
#[test]
fn bindgen_test_layout__GtkExpander() {
const UNINIT: ::std::mem::MaybeUninit<_GtkExpander> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkExpander>(),
56usize,
concat!("Size of: ", stringify!(_GtkExpander))
);
assert_eq!(
::std::mem::align_of::<_GtkExpander>(),
8usize,
concat!("Alignment of ", stringify!(_GtkExpander))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bin) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkExpander),
"::",
stringify!(bin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkExpander),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkExpander {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_expander_get_type() -> GType;
}
extern "C" {
pub fn gtk_expander_new(label: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_expander_new_with_mnemonic(label: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_expander_set_expanded(expander: *mut GtkExpander, expanded: gboolean);
}
extern "C" {
pub fn gtk_expander_get_expanded(expander: *mut GtkExpander) -> gboolean;
}
extern "C" {
pub fn gtk_expander_set_spacing(expander: *mut GtkExpander, spacing: gint);
}
extern "C" {
pub fn gtk_expander_get_spacing(expander: *mut GtkExpander) -> gint;
}
extern "C" {
pub fn gtk_expander_set_label(expander: *mut GtkExpander, label: *const gchar);
}
extern "C" {
pub fn gtk_expander_get_label(expander: *mut GtkExpander) -> *const gchar;
}
extern "C" {
pub fn gtk_expander_set_use_underline(expander: *mut GtkExpander, use_underline: gboolean);
}
extern "C" {
pub fn gtk_expander_get_use_underline(expander: *mut GtkExpander) -> gboolean;
}
extern "C" {
pub fn gtk_expander_set_use_markup(expander: *mut GtkExpander, use_markup: gboolean);
}
extern "C" {
pub fn gtk_expander_get_use_markup(expander: *mut GtkExpander) -> gboolean;
}
extern "C" {
pub fn gtk_expander_set_label_widget(expander: *mut GtkExpander, label_widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_expander_get_label_widget(expander: *mut GtkExpander) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_expander_set_label_fill(expander: *mut GtkExpander, label_fill: gboolean);
}
extern "C" {
pub fn gtk_expander_get_label_fill(expander: *mut GtkExpander) -> gboolean;
}
extern "C" {
pub fn gtk_expander_set_resize_toplevel(expander: *mut GtkExpander, resize_toplevel: gboolean);
}
extern "C" {
pub fn gtk_expander_get_resize_toplevel(expander: *mut GtkExpander) -> gboolean;
}
pub type GtkFixed = _GtkFixed;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFixedPrivate {
_unused: [u8; 0],
}
pub type GtkFixedPrivate = _GtkFixedPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFixed {
pub container: GtkContainer,
pub priv_: *mut GtkFixedPrivate,
}
#[test]
fn bindgen_test_layout__GtkFixed() {
const UNINIT: ::std::mem::MaybeUninit<_GtkFixed> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkFixed>(),
48usize,
concat!("Size of: ", stringify!(_GtkFixed))
);
assert_eq!(
::std::mem::align_of::<_GtkFixed>(),
8usize,
concat!("Alignment of ", stringify!(_GtkFixed))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).container) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkFixed),
"::",
stringify!(container)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkFixed),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkFixed {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_fixed_get_type() -> GType;
}
extern "C" {
pub fn gtk_fixed_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_fixed_put(fixed: *mut GtkFixed, widget: *mut GtkWidget, x: gint, y: gint);
}
extern "C" {
pub fn gtk_fixed_move(fixed: *mut GtkFixed, widget: *mut GtkWidget, x: gint, y: gint);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFileFilter {
_unused: [u8; 0],
}
pub type GtkFileFilter = _GtkFileFilter;
#[doc = " GtkFileFilterInfo:\n @contains: Flags indicating which of the following fields need\n are filled\n @filename: the filename of the file being tested\n @uri: the URI for the file being tested\n @display_name: the string that will be used to display the file\n in the file chooser\n @mime_type: the mime type of the file\n\n A #GtkFileFilterInfo-struct is used to pass information about the\n tested file to gtk_file_filter_filter()."]
pub type GtkFileFilterInfo = _GtkFileFilterInfo;
pub const GtkFileFilterFlags_GTK_FILE_FILTER_FILENAME: GtkFileFilterFlags = 1;
pub const GtkFileFilterFlags_GTK_FILE_FILTER_URI: GtkFileFilterFlags = 2;
pub const GtkFileFilterFlags_GTK_FILE_FILTER_DISPLAY_NAME: GtkFileFilterFlags = 4;
pub const GtkFileFilterFlags_GTK_FILE_FILTER_MIME_TYPE: GtkFileFilterFlags = 8;
#[doc = " GtkFileFilterFlags:\n @GTK_FILE_FILTER_FILENAME: the filename of the file being tested\n @GTK_FILE_FILTER_URI: the URI for the file being tested\n @GTK_FILE_FILTER_DISPLAY_NAME: the string that will be used to\n display the file in the file chooser\n @GTK_FILE_FILTER_MIME_TYPE: the mime type of the file\n\n These flags indicate what parts of a #GtkFileFilterInfo struct\n are filled or need to be filled."]
pub type GtkFileFilterFlags = ::std::os::raw::c_uint;
#[doc = " GtkFileFilterFunc:\n @filter_info: a #GtkFileFilterInfo that is filled according\n to the @needed flags passed to gtk_file_filter_add_custom()\n @data: (closure): user data passed to gtk_file_filter_add_custom()\n\n The type of function that is used with custom filters, see\n gtk_file_filter_add_custom().\n\n Returns: %TRUE if the file should be displayed"]
pub type GtkFileFilterFunc = ::std::option::Option<
unsafe extern "C" fn(filter_info: *const GtkFileFilterInfo, data: gpointer) -> gboolean,
>;
#[doc = " GtkFileFilterInfo:\n @contains: Flags indicating which of the following fields need\n are filled\n @filename: the filename of the file being tested\n @uri: the URI for the file being tested\n @display_name: the string that will be used to display the file\n in the file chooser\n @mime_type: the mime type of the file\n\n A #GtkFileFilterInfo-struct is used to pass information about the\n tested file to gtk_file_filter_filter()."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFileFilterInfo {
pub contains: GtkFileFilterFlags,
pub filename: *const gchar,
pub uri: *const gchar,
pub display_name: *const gchar,
pub mime_type: *const gchar,
}
#[test]
fn bindgen_test_layout__GtkFileFilterInfo() {
const UNINIT: ::std::mem::MaybeUninit<_GtkFileFilterInfo> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkFileFilterInfo>(),
40usize,
concat!("Size of: ", stringify!(_GtkFileFilterInfo))
);
assert_eq!(
::std::mem::align_of::<_GtkFileFilterInfo>(),
8usize,
concat!("Alignment of ", stringify!(_GtkFileFilterInfo))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).contains) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkFileFilterInfo),
"::",
stringify!(contains)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).filename) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkFileFilterInfo),
"::",
stringify!(filename)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).uri) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GtkFileFilterInfo),
"::",
stringify!(uri)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).display_name) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkFileFilterInfo),
"::",
stringify!(display_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mime_type) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkFileFilterInfo),
"::",
stringify!(mime_type)
)
);
}
impl Default for _GtkFileFilterInfo {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_file_filter_get_type() -> GType;
}
extern "C" {
pub fn gtk_file_filter_new() -> *mut GtkFileFilter;
}
extern "C" {
pub fn gtk_file_filter_set_name(filter: *mut GtkFileFilter, name: *const gchar);
}
extern "C" {
pub fn gtk_file_filter_get_name(filter: *mut GtkFileFilter) -> *const gchar;
}
extern "C" {
pub fn gtk_file_filter_add_mime_type(filter: *mut GtkFileFilter, mime_type: *const gchar);
}
extern "C" {
pub fn gtk_file_filter_add_pattern(filter: *mut GtkFileFilter, pattern: *const gchar);
}
extern "C" {
pub fn gtk_file_filter_add_pixbuf_formats(filter: *mut GtkFileFilter);
}
extern "C" {
pub fn gtk_file_filter_add_custom(
filter: *mut GtkFileFilter,
needed: GtkFileFilterFlags,
func: GtkFileFilterFunc,
data: gpointer,
notify: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_file_filter_get_needed(filter: *mut GtkFileFilter) -> GtkFileFilterFlags;
}
extern "C" {
pub fn gtk_file_filter_filter(
filter: *mut GtkFileFilter,
filter_info: *const GtkFileFilterInfo,
) -> gboolean;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFileChooser {
_unused: [u8; 0],
}
pub type GtkFileChooser = _GtkFileChooser;
pub const GtkFileChooserAction_GTK_FILE_CHOOSER_ACTION_OPEN: GtkFileChooserAction = 0;
pub const GtkFileChooserAction_GTK_FILE_CHOOSER_ACTION_SAVE: GtkFileChooserAction = 1;
pub const GtkFileChooserAction_GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER: GtkFileChooserAction = 2;
pub const GtkFileChooserAction_GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER: GtkFileChooserAction = 3;
#[doc = " GtkFileChooserAction:\n @GTK_FILE_CHOOSER_ACTION_OPEN: Indicates open mode. The file chooser\n will only let the user pick an existing file.\n @GTK_FILE_CHOOSER_ACTION_SAVE: Indicates save mode. The file chooser\n will let the user pick an existing file, or type in a new\n filename.\n @GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER: Indicates an Open mode for\n selecting folders. The file chooser will let the user pick an\n existing folder.\n @GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER: Indicates a mode for creating a\n new folder. The file chooser will let the user name an existing or\n new folder.\n\n Describes whether a #GtkFileChooser is being used to open existing files\n or to save to a possibly new file."]
pub type GtkFileChooserAction = ::std::os::raw::c_uint;
extern "C" {
pub fn gtk_file_chooser_get_type() -> GType;
}
extern "C" {
pub fn gtk_file_chooser_error_quark() -> GQuark;
}
extern "C" {
pub fn gtk_file_chooser_set_action(chooser: *mut GtkFileChooser, action: GtkFileChooserAction);
}
extern "C" {
pub fn gtk_file_chooser_get_action(chooser: *mut GtkFileChooser) -> GtkFileChooserAction;
}
extern "C" {
pub fn gtk_file_chooser_set_local_only(chooser: *mut GtkFileChooser, local_only: gboolean);
}
extern "C" {
pub fn gtk_file_chooser_get_local_only(chooser: *mut GtkFileChooser) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_set_select_multiple(
chooser: *mut GtkFileChooser,
select_multiple: gboolean,
);
}
extern "C" {
pub fn gtk_file_chooser_get_select_multiple(chooser: *mut GtkFileChooser) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_set_show_hidden(chooser: *mut GtkFileChooser, show_hidden: gboolean);
}
extern "C" {
pub fn gtk_file_chooser_get_show_hidden(chooser: *mut GtkFileChooser) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_set_do_overwrite_confirmation(
chooser: *mut GtkFileChooser,
do_overwrite_confirmation: gboolean,
);
}
extern "C" {
pub fn gtk_file_chooser_get_do_overwrite_confirmation(chooser: *mut GtkFileChooser)
-> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_set_create_folders(
chooser: *mut GtkFileChooser,
create_folders: gboolean,
);
}
extern "C" {
pub fn gtk_file_chooser_get_create_folders(chooser: *mut GtkFileChooser) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_set_current_name(chooser: *mut GtkFileChooser, name: *const gchar);
}
extern "C" {
pub fn gtk_file_chooser_get_current_name(chooser: *mut GtkFileChooser) -> *mut gchar;
}
extern "C" {
pub fn gtk_file_chooser_get_filename(chooser: *mut GtkFileChooser) -> *mut gchar;
}
extern "C" {
pub fn gtk_file_chooser_set_filename(
chooser: *mut GtkFileChooser,
filename: *const ::std::os::raw::c_char,
) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_select_filename(
chooser: *mut GtkFileChooser,
filename: *const ::std::os::raw::c_char,
) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_unselect_filename(
chooser: *mut GtkFileChooser,
filename: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn gtk_file_chooser_select_all(chooser: *mut GtkFileChooser);
}
extern "C" {
pub fn gtk_file_chooser_unselect_all(chooser: *mut GtkFileChooser);
}
extern "C" {
pub fn gtk_file_chooser_get_filenames(chooser: *mut GtkFileChooser) -> *mut GSList;
}
extern "C" {
pub fn gtk_file_chooser_set_current_folder(
chooser: *mut GtkFileChooser,
filename: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_get_current_folder(chooser: *mut GtkFileChooser) -> *mut gchar;
}
extern "C" {
pub fn gtk_file_chooser_get_uri(chooser: *mut GtkFileChooser) -> *mut gchar;
}
extern "C" {
pub fn gtk_file_chooser_set_uri(
chooser: *mut GtkFileChooser,
uri: *const ::std::os::raw::c_char,
) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_select_uri(
chooser: *mut GtkFileChooser,
uri: *const ::std::os::raw::c_char,
) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_unselect_uri(
chooser: *mut GtkFileChooser,
uri: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn gtk_file_chooser_get_uris(chooser: *mut GtkFileChooser) -> *mut GSList;
}
extern "C" {
pub fn gtk_file_chooser_set_current_folder_uri(
chooser: *mut GtkFileChooser,
uri: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_get_current_folder_uri(chooser: *mut GtkFileChooser) -> *mut gchar;
}
extern "C" {
pub fn gtk_file_chooser_get_file(chooser: *mut GtkFileChooser) -> *mut GFile;
}
extern "C" {
pub fn gtk_file_chooser_set_file(
chooser: *mut GtkFileChooser,
file: *mut GFile,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_select_file(
chooser: *mut GtkFileChooser,
file: *mut GFile,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_unselect_file(chooser: *mut GtkFileChooser, file: *mut GFile);
}
extern "C" {
pub fn gtk_file_chooser_get_files(chooser: *mut GtkFileChooser) -> *mut GSList;
}
extern "C" {
pub fn gtk_file_chooser_set_current_folder_file(
chooser: *mut GtkFileChooser,
file: *mut GFile,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_get_current_folder_file(chooser: *mut GtkFileChooser) -> *mut GFile;
}
extern "C" {
pub fn gtk_file_chooser_set_preview_widget(
chooser: *mut GtkFileChooser,
preview_widget: *mut GtkWidget,
);
}
extern "C" {
pub fn gtk_file_chooser_get_preview_widget(chooser: *mut GtkFileChooser) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_file_chooser_set_preview_widget_active(
chooser: *mut GtkFileChooser,
active: gboolean,
);
}
extern "C" {
pub fn gtk_file_chooser_get_preview_widget_active(chooser: *mut GtkFileChooser) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_set_use_preview_label(
chooser: *mut GtkFileChooser,
use_label: gboolean,
);
}
extern "C" {
pub fn gtk_file_chooser_get_use_preview_label(chooser: *mut GtkFileChooser) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_get_preview_filename(
chooser: *mut GtkFileChooser,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn gtk_file_chooser_get_preview_uri(
chooser: *mut GtkFileChooser,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn gtk_file_chooser_get_preview_file(chooser: *mut GtkFileChooser) -> *mut GFile;
}
extern "C" {
pub fn gtk_file_chooser_set_extra_widget(
chooser: *mut GtkFileChooser,
extra_widget: *mut GtkWidget,
);
}
extern "C" {
pub fn gtk_file_chooser_get_extra_widget(chooser: *mut GtkFileChooser) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_file_chooser_add_filter(chooser: *mut GtkFileChooser, filter: *mut GtkFileFilter);
}
extern "C" {
pub fn gtk_file_chooser_remove_filter(chooser: *mut GtkFileChooser, filter: *mut GtkFileFilter);
}
extern "C" {
pub fn gtk_file_chooser_list_filters(chooser: *mut GtkFileChooser) -> *mut GSList;
}
extern "C" {
pub fn gtk_file_chooser_set_filter(chooser: *mut GtkFileChooser, filter: *mut GtkFileFilter);
}
extern "C" {
pub fn gtk_file_chooser_get_filter(chooser: *mut GtkFileChooser) -> *mut GtkFileFilter;
}
extern "C" {
pub fn gtk_file_chooser_add_shortcut_folder(
chooser: *mut GtkFileChooser,
folder: *const ::std::os::raw::c_char,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_remove_shortcut_folder(
chooser: *mut GtkFileChooser,
folder: *const ::std::os::raw::c_char,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_list_shortcut_folders(chooser: *mut GtkFileChooser) -> *mut GSList;
}
extern "C" {
pub fn gtk_file_chooser_add_shortcut_folder_uri(
chooser: *mut GtkFileChooser,
uri: *const ::std::os::raw::c_char,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_remove_shortcut_folder_uri(
chooser: *mut GtkFileChooser,
uri: *const ::std::os::raw::c_char,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_list_shortcut_folder_uris(chooser: *mut GtkFileChooser) -> *mut GSList;
}
pub type GtkFileChooserButton = _GtkFileChooserButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFileChooserButtonPrivate {
_unused: [u8; 0],
}
pub type GtkFileChooserButtonPrivate = _GtkFileChooserButtonPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFileChooserButton {
pub parent: GtkBox,
pub priv_: *mut GtkFileChooserButtonPrivate,
}
#[test]
fn bindgen_test_layout__GtkFileChooserButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkFileChooserButton> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkFileChooserButton>(),
56usize,
concat!("Size of: ", stringify!(_GtkFileChooserButton))
);
assert_eq!(
::std::mem::align_of::<_GtkFileChooserButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkFileChooserButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkFileChooserButton),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkFileChooserButton),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkFileChooserButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_file_chooser_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_file_chooser_button_new(
title: *const gchar,
action: GtkFileChooserAction,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_file_chooser_button_new_with_dialog(dialog: *mut GtkWidget) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_file_chooser_button_get_title(button: *mut GtkFileChooserButton) -> *const gchar;
}
extern "C" {
pub fn gtk_file_chooser_button_set_title(
button: *mut GtkFileChooserButton,
title: *const gchar,
);
}
extern "C" {
pub fn gtk_file_chooser_button_get_width_chars(button: *mut GtkFileChooserButton) -> gint;
}
extern "C" {
pub fn gtk_file_chooser_button_set_width_chars(
button: *mut GtkFileChooserButton,
n_chars: gint,
);
}
extern "C" {
pub fn gtk_file_chooser_button_get_focus_on_click(
button: *mut GtkFileChooserButton,
) -> gboolean;
}
extern "C" {
pub fn gtk_file_chooser_button_set_focus_on_click(
button: *mut GtkFileChooserButton,
focus_on_click: gboolean,
);
}
extern "C" {
pub fn gtk_file_chooser_dialog_get_type() -> GType;
}
extern "C" {
pub fn gtk_file_chooser_dialog_new(
title: *const gchar,
parent: *mut GtkWindow,
action: GtkFileChooserAction,
first_button_text: *const gchar,
...
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_file_chooser_widget_get_type() -> GType;
}
extern "C" {
pub fn gtk_file_chooser_widget_new(action: GtkFileChooserAction) -> *mut GtkWidget;
}
pub type GtkFlowBox = _GtkFlowBox;
pub type GtkFlowBoxChild = _GtkFlowBoxChild;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFlowBox {
pub container: GtkContainer,
}
#[test]
fn bindgen_test_layout__GtkFlowBox() {
const UNINIT: ::std::mem::MaybeUninit<_GtkFlowBox> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkFlowBox>(),
40usize,
concat!("Size of: ", stringify!(_GtkFlowBox))
);
assert_eq!(
::std::mem::align_of::<_GtkFlowBox>(),
8usize,
concat!("Alignment of ", stringify!(_GtkFlowBox))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).container) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkFlowBox),
"::",
stringify!(container)
)
);
}
impl Default for _GtkFlowBox {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFlowBoxChild {
pub parent_instance: GtkBin,
}
#[test]
fn bindgen_test_layout__GtkFlowBoxChild() {
const UNINIT: ::std::mem::MaybeUninit<_GtkFlowBoxChild> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkFlowBoxChild>(),
48usize,
concat!("Size of: ", stringify!(_GtkFlowBoxChild))
);
assert_eq!(
::std::mem::align_of::<_GtkFlowBoxChild>(),
8usize,
concat!("Alignment of ", stringify!(_GtkFlowBoxChild))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkFlowBoxChild),
"::",
stringify!(parent_instance)
)
);
}
impl Default for _GtkFlowBoxChild {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_flow_box_child_get_type() -> GType;
}
extern "C" {
pub fn gtk_flow_box_child_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_flow_box_child_get_index(child: *mut GtkFlowBoxChild) -> gint;
}
extern "C" {
pub fn gtk_flow_box_child_is_selected(child: *mut GtkFlowBoxChild) -> gboolean;
}
extern "C" {
pub fn gtk_flow_box_child_changed(child: *mut GtkFlowBoxChild);
}
extern "C" {
pub fn gtk_flow_box_get_type() -> GType;
}
extern "C" {
pub fn gtk_flow_box_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_flow_box_set_homogeneous(box_: *mut GtkFlowBox, homogeneous: gboolean);
}
extern "C" {
pub fn gtk_flow_box_get_homogeneous(box_: *mut GtkFlowBox) -> gboolean;
}
extern "C" {
pub fn gtk_flow_box_set_row_spacing(box_: *mut GtkFlowBox, spacing: guint);
}
extern "C" {
pub fn gtk_flow_box_get_row_spacing(box_: *mut GtkFlowBox) -> guint;
}
extern "C" {
pub fn gtk_flow_box_set_column_spacing(box_: *mut GtkFlowBox, spacing: guint);
}
extern "C" {
pub fn gtk_flow_box_get_column_spacing(box_: *mut GtkFlowBox) -> guint;
}
extern "C" {
pub fn gtk_flow_box_set_min_children_per_line(box_: *mut GtkFlowBox, n_children: guint);
}
extern "C" {
pub fn gtk_flow_box_get_min_children_per_line(box_: *mut GtkFlowBox) -> guint;
}
extern "C" {
pub fn gtk_flow_box_set_max_children_per_line(box_: *mut GtkFlowBox, n_children: guint);
}
extern "C" {
pub fn gtk_flow_box_get_max_children_per_line(box_: *mut GtkFlowBox) -> guint;
}
extern "C" {
pub fn gtk_flow_box_set_activate_on_single_click(box_: *mut GtkFlowBox, single: gboolean);
}
extern "C" {
pub fn gtk_flow_box_get_activate_on_single_click(box_: *mut GtkFlowBox) -> gboolean;
}
extern "C" {
pub fn gtk_flow_box_insert(box_: *mut GtkFlowBox, widget: *mut GtkWidget, position: gint);
}
extern "C" {
pub fn gtk_flow_box_get_child_at_index(
box_: *mut GtkFlowBox,
idx: gint,
) -> *mut GtkFlowBoxChild;
}
pub type GtkFlowBoxForeachFunc = ::std::option::Option<
unsafe extern "C" fn(box_: *mut GtkFlowBox, child: *mut GtkFlowBoxChild, user_data: gpointer),
>;
extern "C" {
pub fn gtk_flow_box_selected_foreach(
box_: *mut GtkFlowBox,
func: GtkFlowBoxForeachFunc,
data: gpointer,
);
}
extern "C" {
pub fn gtk_flow_box_get_selected_children(box_: *mut GtkFlowBox) -> *mut GList;
}
extern "C" {
pub fn gtk_flow_box_select_child(box_: *mut GtkFlowBox, child: *mut GtkFlowBoxChild);
}
extern "C" {
pub fn gtk_flow_box_unselect_child(box_: *mut GtkFlowBox, child: *mut GtkFlowBoxChild);
}
extern "C" {
pub fn gtk_flow_box_select_all(box_: *mut GtkFlowBox);
}
extern "C" {
pub fn gtk_flow_box_unselect_all(box_: *mut GtkFlowBox);
}
extern "C" {
pub fn gtk_flow_box_set_selection_mode(box_: *mut GtkFlowBox, mode: GtkSelectionMode);
}
extern "C" {
pub fn gtk_flow_box_get_selection_mode(box_: *mut GtkFlowBox) -> GtkSelectionMode;
}
extern "C" {
pub fn gtk_flow_box_set_hadjustment(box_: *mut GtkFlowBox, adjustment: *mut GtkAdjustment);
}
extern "C" {
pub fn gtk_flow_box_set_vadjustment(box_: *mut GtkFlowBox, adjustment: *mut GtkAdjustment);
}
pub type GtkFlowBoxFilterFunc = ::std::option::Option<
unsafe extern "C" fn(child: *mut GtkFlowBoxChild, user_data: gpointer) -> gboolean,
>;
extern "C" {
pub fn gtk_flow_box_set_filter_func(
box_: *mut GtkFlowBox,
filter_func: GtkFlowBoxFilterFunc,
user_data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_flow_box_invalidate_filter(box_: *mut GtkFlowBox);
}
pub type GtkFlowBoxSortFunc = ::std::option::Option<
unsafe extern "C" fn(
child1: *mut GtkFlowBoxChild,
child2: *mut GtkFlowBoxChild,
user_data: gpointer,
) -> gint,
>;
extern "C" {
pub fn gtk_flow_box_set_sort_func(
box_: *mut GtkFlowBox,
sort_func: GtkFlowBoxSortFunc,
user_data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_flow_box_invalidate_sort(box_: *mut GtkFlowBox);
}
pub type GtkFontButton = _GtkFontButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFontButtonPrivate {
_unused: [u8; 0],
}
pub type GtkFontButtonPrivate = _GtkFontButtonPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFontButton {
pub button: GtkButton,
pub priv_: *mut GtkFontButtonPrivate,
}
#[test]
fn bindgen_test_layout__GtkFontButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkFontButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkFontButton>(),
64usize,
concat!("Size of: ", stringify!(_GtkFontButton))
);
assert_eq!(
::std::mem::align_of::<_GtkFontButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkFontButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkFontButton),
"::",
stringify!(button)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkFontButton),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkFontButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_font_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_font_button_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_font_button_new_with_font(fontname: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_font_button_get_title(font_button: *mut GtkFontButton) -> *const gchar;
}
extern "C" {
pub fn gtk_font_button_set_title(font_button: *mut GtkFontButton, title: *const gchar);
}
extern "C" {
pub fn gtk_font_button_get_use_font(font_button: *mut GtkFontButton) -> gboolean;
}
extern "C" {
pub fn gtk_font_button_set_use_font(font_button: *mut GtkFontButton, use_font: gboolean);
}
extern "C" {
pub fn gtk_font_button_get_use_size(font_button: *mut GtkFontButton) -> gboolean;
}
extern "C" {
pub fn gtk_font_button_set_use_size(font_button: *mut GtkFontButton, use_size: gboolean);
}
extern "C" {
pub fn gtk_font_button_get_font_name(font_button: *mut GtkFontButton) -> *const gchar;
}
extern "C" {
pub fn gtk_font_button_set_font_name(
font_button: *mut GtkFontButton,
fontname: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_font_button_get_show_style(font_button: *mut GtkFontButton) -> gboolean;
}
extern "C" {
pub fn gtk_font_button_set_show_style(font_button: *mut GtkFontButton, show_style: gboolean);
}
extern "C" {
pub fn gtk_font_button_get_show_size(font_button: *mut GtkFontButton) -> gboolean;
}
extern "C" {
pub fn gtk_font_button_set_show_size(font_button: *mut GtkFontButton, show_size: gboolean);
}
#[doc = " GtkFontFilterFunc:\n @family: a #PangoFontFamily\n @face: a #PangoFontFace belonging to @family\n @data: (closure): user data passed to gtk_font_chooser_set_filter_func()\n\n The type of function that is used for deciding what fonts get\n shown in a #GtkFontChooser. See gtk_font_chooser_set_filter_func().\n\n Returns: %TRUE if the font should be displayed"]
pub type GtkFontFilterFunc = ::std::option::Option<
unsafe extern "C" fn(
family: *const PangoFontFamily,
face: *const PangoFontFace,
data: gpointer,
) -> gboolean,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFontChooser {
_unused: [u8; 0],
}
pub type GtkFontChooser = _GtkFontChooser;
extern "C" {
pub fn gtk_font_chooser_get_type() -> GType;
}
extern "C" {
pub fn gtk_font_chooser_get_font_family(
fontchooser: *mut GtkFontChooser,
) -> *mut PangoFontFamily;
}
extern "C" {
pub fn gtk_font_chooser_get_font_face(fontchooser: *mut GtkFontChooser) -> *mut PangoFontFace;
}
extern "C" {
pub fn gtk_font_chooser_get_font_size(fontchooser: *mut GtkFontChooser) -> gint;
}
extern "C" {
pub fn gtk_font_chooser_get_font_desc(
fontchooser: *mut GtkFontChooser,
) -> *mut PangoFontDescription;
}
extern "C" {
pub fn gtk_font_chooser_set_font_desc(
fontchooser: *mut GtkFontChooser,
font_desc: *const PangoFontDescription,
);
}
extern "C" {
pub fn gtk_font_chooser_get_font(fontchooser: *mut GtkFontChooser) -> *mut gchar;
}
extern "C" {
pub fn gtk_font_chooser_set_font(fontchooser: *mut GtkFontChooser, fontname: *const gchar);
}
extern "C" {
pub fn gtk_font_chooser_get_preview_text(fontchooser: *mut GtkFontChooser) -> *mut gchar;
}
extern "C" {
pub fn gtk_font_chooser_set_preview_text(fontchooser: *mut GtkFontChooser, text: *const gchar);
}
extern "C" {
pub fn gtk_font_chooser_get_show_preview_entry(fontchooser: *mut GtkFontChooser) -> gboolean;
}
extern "C" {
pub fn gtk_font_chooser_set_show_preview_entry(
fontchooser: *mut GtkFontChooser,
show_preview_entry: gboolean,
);
}
extern "C" {
pub fn gtk_font_chooser_set_filter_func(
fontchooser: *mut GtkFontChooser,
filter: GtkFontFilterFunc,
user_data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_font_chooser_dialog_get_type() -> GType;
}
extern "C" {
pub fn gtk_font_chooser_dialog_new(
title: *const gchar,
parent: *mut GtkWindow,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_font_chooser_widget_get_type() -> GType;
}
extern "C" {
pub fn gtk_font_chooser_widget_new() -> *mut GtkWidget;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkGesture {
_unused: [u8; 0],
}
pub type GtkGesture = _GtkGesture;
extern "C" {
pub fn gtk_gesture_get_type() -> GType;
}
extern "C" {
pub fn gtk_gesture_get_device(gesture: *mut GtkGesture) -> *mut GdkDevice;
}
extern "C" {
pub fn gtk_gesture_set_state(
gesture: *mut GtkGesture,
state: GtkEventSequenceState,
) -> gboolean;
}
extern "C" {
pub fn gtk_gesture_get_sequence_state(
gesture: *mut GtkGesture,
sequence: *mut GdkEventSequence,
) -> GtkEventSequenceState;
}
extern "C" {
pub fn gtk_gesture_set_sequence_state(
gesture: *mut GtkGesture,
sequence: *mut GdkEventSequence,
state: GtkEventSequenceState,
) -> gboolean;
}
extern "C" {
pub fn gtk_gesture_get_sequences(gesture: *mut GtkGesture) -> *mut GList;
}
extern "C" {
pub fn gtk_gesture_get_last_updated_sequence(gesture: *mut GtkGesture)
-> *mut GdkEventSequence;
}
extern "C" {
pub fn gtk_gesture_handles_sequence(
gesture: *mut GtkGesture,
sequence: *mut GdkEventSequence,
) -> gboolean;
}
extern "C" {
pub fn gtk_gesture_get_last_event(
gesture: *mut GtkGesture,
sequence: *mut GdkEventSequence,
) -> *const GdkEvent;
}
extern "C" {
pub fn gtk_gesture_get_point(
gesture: *mut GtkGesture,
sequence: *mut GdkEventSequence,
x: *mut gdouble,
y: *mut gdouble,
) -> gboolean;
}
extern "C" {
pub fn gtk_gesture_get_bounding_box(
gesture: *mut GtkGesture,
rect: *mut GdkRectangle,
) -> gboolean;
}
extern "C" {
pub fn gtk_gesture_get_bounding_box_center(
gesture: *mut GtkGesture,
x: *mut gdouble,
y: *mut gdouble,
) -> gboolean;
}
extern "C" {
pub fn gtk_gesture_is_active(gesture: *mut GtkGesture) -> gboolean;
}
extern "C" {
pub fn gtk_gesture_is_recognized(gesture: *mut GtkGesture) -> gboolean;
}
extern "C" {
pub fn gtk_gesture_get_window(gesture: *mut GtkGesture) -> *mut GdkWindow;
}
extern "C" {
pub fn gtk_gesture_set_window(gesture: *mut GtkGesture, window: *mut GdkWindow);
}
extern "C" {
pub fn gtk_gesture_group(group_gesture: *mut GtkGesture, gesture: *mut GtkGesture);
}
extern "C" {
pub fn gtk_gesture_ungroup(gesture: *mut GtkGesture);
}
extern "C" {
pub fn gtk_gesture_get_group(gesture: *mut GtkGesture) -> *mut GList;
}
extern "C" {
pub fn gtk_gesture_is_grouped_with(
gesture: *mut GtkGesture,
other: *mut GtkGesture,
) -> gboolean;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkGestureSingle {
_unused: [u8; 0],
}
pub type GtkGestureSingle = _GtkGestureSingle;
extern "C" {
pub fn gtk_gesture_single_get_type() -> GType;
}
extern "C" {
pub fn gtk_gesture_single_get_touch_only(gesture: *mut GtkGestureSingle) -> gboolean;
}
extern "C" {
pub fn gtk_gesture_single_set_touch_only(gesture: *mut GtkGestureSingle, touch_only: gboolean);
}
extern "C" {
pub fn gtk_gesture_single_get_exclusive(gesture: *mut GtkGestureSingle) -> gboolean;
}
extern "C" {
pub fn gtk_gesture_single_set_exclusive(gesture: *mut GtkGestureSingle, exclusive: gboolean);
}
extern "C" {
pub fn gtk_gesture_single_get_button(gesture: *mut GtkGestureSingle) -> guint;
}
extern "C" {
pub fn gtk_gesture_single_set_button(gesture: *mut GtkGestureSingle, button: guint);
}
extern "C" {
pub fn gtk_gesture_single_get_current_button(gesture: *mut GtkGestureSingle) -> guint;
}
extern "C" {
pub fn gtk_gesture_single_get_current_sequence(
gesture: *mut GtkGestureSingle,
) -> *mut GdkEventSequence;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkGestureDrag {
_unused: [u8; 0],
}
pub type GtkGestureDrag = _GtkGestureDrag;
extern "C" {
pub fn gtk_gesture_drag_get_type() -> GType;
}
extern "C" {
pub fn gtk_gesture_drag_new(widget: *mut GtkWidget) -> *mut GtkGesture;
}
extern "C" {
pub fn gtk_gesture_drag_get_start_point(
gesture: *mut GtkGestureDrag,
x: *mut gdouble,
y: *mut gdouble,
) -> gboolean;
}
extern "C" {
pub fn gtk_gesture_drag_get_offset(
gesture: *mut GtkGestureDrag,
x: *mut gdouble,
y: *mut gdouble,
) -> gboolean;
}
extern "C" {
pub fn gtk_gesture_long_press_get_type() -> GType;
}
extern "C" {
pub fn gtk_gesture_long_press_new(widget: *mut GtkWidget) -> *mut GtkGesture;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkGestureMultiPress {
_unused: [u8; 0],
}
pub type GtkGestureMultiPress = _GtkGestureMultiPress;
extern "C" {
pub fn gtk_gesture_multi_press_get_type() -> GType;
}
extern "C" {
pub fn gtk_gesture_multi_press_new(widget: *mut GtkWidget) -> *mut GtkGesture;
}
extern "C" {
pub fn gtk_gesture_multi_press_set_area(
gesture: *mut GtkGestureMultiPress,
rect: *const GdkRectangle,
);
}
extern "C" {
pub fn gtk_gesture_multi_press_get_area(
gesture: *mut GtkGestureMultiPress,
rect: *mut GdkRectangle,
) -> gboolean;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkGesturePan {
_unused: [u8; 0],
}
pub type GtkGesturePan = _GtkGesturePan;
extern "C" {
pub fn gtk_gesture_pan_get_type() -> GType;
}
extern "C" {
pub fn gtk_gesture_pan_new(
widget: *mut GtkWidget,
orientation: GtkOrientation,
) -> *mut GtkGesture;
}
extern "C" {
pub fn gtk_gesture_pan_get_orientation(gesture: *mut GtkGesturePan) -> GtkOrientation;
}
extern "C" {
pub fn gtk_gesture_pan_set_orientation(
gesture: *mut GtkGesturePan,
orientation: GtkOrientation,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkGestureRotate {
_unused: [u8; 0],
}
pub type GtkGestureRotate = _GtkGestureRotate;
extern "C" {
pub fn gtk_gesture_rotate_get_type() -> GType;
}
extern "C" {
pub fn gtk_gesture_rotate_new(widget: *mut GtkWidget) -> *mut GtkGesture;
}
extern "C" {
pub fn gtk_gesture_rotate_get_angle_delta(gesture: *mut GtkGestureRotate) -> gdouble;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkGestureSwipe {
_unused: [u8; 0],
}
pub type GtkGestureSwipe = _GtkGestureSwipe;
extern "C" {
pub fn gtk_gesture_swipe_get_type() -> GType;
}
extern "C" {
pub fn gtk_gesture_swipe_new(widget: *mut GtkWidget) -> *mut GtkGesture;
}
extern "C" {
pub fn gtk_gesture_swipe_get_velocity(
gesture: *mut GtkGestureSwipe,
velocity_x: *mut gdouble,
velocity_y: *mut gdouble,
) -> gboolean;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkGestureZoom {
_unused: [u8; 0],
}
pub type GtkGestureZoom = _GtkGestureZoom;
extern "C" {
pub fn gtk_gesture_zoom_get_type() -> GType;
}
extern "C" {
pub fn gtk_gesture_zoom_new(widget: *mut GtkWidget) -> *mut GtkGesture;
}
extern "C" {
pub fn gtk_gesture_zoom_get_scale_delta(gesture: *mut GtkGestureZoom) -> gdouble;
}
pub type GtkGrid = _GtkGrid;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkGridPrivate {
_unused: [u8; 0],
}
pub type GtkGridPrivate = _GtkGridPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkGrid {
pub container: GtkContainer,
pub priv_: *mut GtkGridPrivate,
}
#[test]
fn bindgen_test_layout__GtkGrid() {
const UNINIT: ::std::mem::MaybeUninit<_GtkGrid> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkGrid>(),
48usize,
concat!("Size of: ", stringify!(_GtkGrid))
);
assert_eq!(
::std::mem::align_of::<_GtkGrid>(),
8usize,
concat!("Alignment of ", stringify!(_GtkGrid))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).container) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkGrid),
"::",
stringify!(container)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkGrid),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkGrid {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_grid_get_type() -> GType;
}
extern "C" {
pub fn gtk_grid_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_grid_attach(
grid: *mut GtkGrid,
child: *mut GtkWidget,
left: gint,
top: gint,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_grid_attach_next_to(
grid: *mut GtkGrid,
child: *mut GtkWidget,
sibling: *mut GtkWidget,
side: GtkPositionType,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_grid_get_child_at(grid: *mut GtkGrid, left: gint, top: gint) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_grid_insert_row(grid: *mut GtkGrid, position: gint);
}
extern "C" {
pub fn gtk_grid_insert_column(grid: *mut GtkGrid, position: gint);
}
extern "C" {
pub fn gtk_grid_remove_row(grid: *mut GtkGrid, position: gint);
}
extern "C" {
pub fn gtk_grid_remove_column(grid: *mut GtkGrid, position: gint);
}
extern "C" {
pub fn gtk_grid_insert_next_to(
grid: *mut GtkGrid,
sibling: *mut GtkWidget,
side: GtkPositionType,
);
}
extern "C" {
pub fn gtk_grid_set_row_homogeneous(grid: *mut GtkGrid, homogeneous: gboolean);
}
extern "C" {
pub fn gtk_grid_get_row_homogeneous(grid: *mut GtkGrid) -> gboolean;
}
extern "C" {
pub fn gtk_grid_set_row_spacing(grid: *mut GtkGrid, spacing: guint);
}
extern "C" {
pub fn gtk_grid_get_row_spacing(grid: *mut GtkGrid) -> guint;
}
extern "C" {
pub fn gtk_grid_set_column_homogeneous(grid: *mut GtkGrid, homogeneous: gboolean);
}
extern "C" {
pub fn gtk_grid_get_column_homogeneous(grid: *mut GtkGrid) -> gboolean;
}
extern "C" {
pub fn gtk_grid_set_column_spacing(grid: *mut GtkGrid, spacing: guint);
}
extern "C" {
pub fn gtk_grid_get_column_spacing(grid: *mut GtkGrid) -> guint;
}
extern "C" {
pub fn gtk_grid_set_row_baseline_position(
grid: *mut GtkGrid,
row: gint,
pos: GtkBaselinePosition,
);
}
extern "C" {
pub fn gtk_grid_get_row_baseline_position(grid: *mut GtkGrid, row: gint)
-> GtkBaselinePosition;
}
extern "C" {
pub fn gtk_grid_set_baseline_row(grid: *mut GtkGrid, row: gint);
}
extern "C" {
pub fn gtk_grid_get_baseline_row(grid: *mut GtkGrid) -> gint;
}
pub type GtkHeaderBar = _GtkHeaderBar;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkHeaderBar {
pub container: GtkContainer,
}
#[test]
fn bindgen_test_layout__GtkHeaderBar() {
const UNINIT: ::std::mem::MaybeUninit<_GtkHeaderBar> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkHeaderBar>(),
40usize,
concat!("Size of: ", stringify!(_GtkHeaderBar))
);
assert_eq!(
::std::mem::align_of::<_GtkHeaderBar>(),
8usize,
concat!("Alignment of ", stringify!(_GtkHeaderBar))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).container) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkHeaderBar),
"::",
stringify!(container)
)
);
}
impl Default for _GtkHeaderBar {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_header_bar_get_type() -> GType;
}
extern "C" {
pub fn gtk_header_bar_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_header_bar_set_title(bar: *mut GtkHeaderBar, title: *const gchar);
}
extern "C" {
pub fn gtk_header_bar_get_title(bar: *mut GtkHeaderBar) -> *const gchar;
}
extern "C" {
pub fn gtk_header_bar_set_subtitle(bar: *mut GtkHeaderBar, subtitle: *const gchar);
}
extern "C" {
pub fn gtk_header_bar_get_subtitle(bar: *mut GtkHeaderBar) -> *const gchar;
}
extern "C" {
pub fn gtk_header_bar_set_custom_title(bar: *mut GtkHeaderBar, title_widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_header_bar_get_custom_title(bar: *mut GtkHeaderBar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_header_bar_pack_start(bar: *mut GtkHeaderBar, child: *mut GtkWidget);
}
extern "C" {
pub fn gtk_header_bar_pack_end(bar: *mut GtkHeaderBar, child: *mut GtkWidget);
}
extern "C" {
pub fn gtk_header_bar_get_show_close_button(bar: *mut GtkHeaderBar) -> gboolean;
}
extern "C" {
pub fn gtk_header_bar_set_show_close_button(bar: *mut GtkHeaderBar, setting: gboolean);
}
extern "C" {
pub fn gtk_header_bar_set_has_subtitle(bar: *mut GtkHeaderBar, setting: gboolean);
}
extern "C" {
pub fn gtk_header_bar_get_has_subtitle(bar: *mut GtkHeaderBar) -> gboolean;
}
extern "C" {
pub fn gtk_header_bar_set_decoration_layout(bar: *mut GtkHeaderBar, layout: *const gchar);
}
extern "C" {
pub fn gtk_header_bar_get_decoration_layout(bar: *mut GtkHeaderBar) -> *const gchar;
}
pub type GtkIconFactory = _GtkIconFactory;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkIconFactoryPrivate {
_unused: [u8; 0],
}
pub type GtkIconFactoryPrivate = _GtkIconFactoryPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkIconFactory {
pub parent_instance: GObject,
pub priv_: *mut GtkIconFactoryPrivate,
}
#[test]
fn bindgen_test_layout__GtkIconFactory() {
const UNINIT: ::std::mem::MaybeUninit<_GtkIconFactory> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkIconFactory>(),
32usize,
concat!("Size of: ", stringify!(_GtkIconFactory))
);
assert_eq!(
::std::mem::align_of::<_GtkIconFactory>(),
8usize,
concat!("Alignment of ", stringify!(_GtkIconFactory))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkIconFactory),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkIconFactory),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkIconFactory {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_icon_factory_get_type() -> GType;
}
extern "C" {
pub fn gtk_icon_factory_new() -> *mut GtkIconFactory;
}
extern "C" {
pub fn gtk_icon_factory_add(
factory: *mut GtkIconFactory,
stock_id: *const gchar,
icon_set: *mut GtkIconSet,
);
}
extern "C" {
pub fn gtk_icon_factory_lookup(
factory: *mut GtkIconFactory,
stock_id: *const gchar,
) -> *mut GtkIconSet;
}
extern "C" {
pub fn gtk_icon_factory_add_default(factory: *mut GtkIconFactory);
}
extern "C" {
pub fn gtk_icon_factory_remove_default(factory: *mut GtkIconFactory);
}
extern "C" {
pub fn gtk_icon_factory_lookup_default(stock_id: *const gchar) -> *mut GtkIconSet;
}
extern "C" {
pub fn gtk_icon_size_lookup(size: GtkIconSize, width: *mut gint, height: *mut gint)
-> gboolean;
}
extern "C" {
pub fn gtk_icon_size_lookup_for_settings(
settings: *mut GtkSettings,
size: GtkIconSize,
width: *mut gint,
height: *mut gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_icon_size_register(name: *const gchar, width: gint, height: gint) -> GtkIconSize;
}
extern "C" {
pub fn gtk_icon_size_register_alias(alias: *const gchar, target: GtkIconSize);
}
extern "C" {
pub fn gtk_icon_size_from_name(name: *const gchar) -> GtkIconSize;
}
extern "C" {
pub fn gtk_icon_size_get_name(size: GtkIconSize) -> *const gchar;
}
extern "C" {
pub fn gtk_icon_set_get_type() -> GType;
}
extern "C" {
pub fn gtk_icon_set_new() -> *mut GtkIconSet;
}
extern "C" {
pub fn gtk_icon_set_new_from_pixbuf(pixbuf: *mut GdkPixbuf) -> *mut GtkIconSet;
}
extern "C" {
pub fn gtk_icon_set_ref(icon_set: *mut GtkIconSet) -> *mut GtkIconSet;
}
extern "C" {
pub fn gtk_icon_set_unref(icon_set: *mut GtkIconSet);
}
extern "C" {
pub fn gtk_icon_set_copy(icon_set: *mut GtkIconSet) -> *mut GtkIconSet;
}
extern "C" {
pub fn gtk_icon_set_render_icon(
icon_set: *mut GtkIconSet,
style: *mut GtkStyle,
direction: GtkTextDirection,
state: GtkStateType,
size: GtkIconSize,
widget: *mut GtkWidget,
detail: *const gchar,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_icon_set_add_source(icon_set: *mut GtkIconSet, source: *const GtkIconSource);
}
extern "C" {
pub fn gtk_icon_set_get_sizes(
icon_set: *mut GtkIconSet,
sizes: *mut *mut GtkIconSize,
n_sizes: *mut gint,
);
}
extern "C" {
pub fn gtk_icon_source_get_type() -> GType;
}
extern "C" {
pub fn gtk_icon_source_new() -> *mut GtkIconSource;
}
extern "C" {
pub fn gtk_icon_source_copy(source: *const GtkIconSource) -> *mut GtkIconSource;
}
extern "C" {
pub fn gtk_icon_source_free(source: *mut GtkIconSource);
}
extern "C" {
pub fn gtk_icon_source_set_filename(source: *mut GtkIconSource, filename: *const gchar);
}
extern "C" {
pub fn gtk_icon_source_set_icon_name(source: *mut GtkIconSource, icon_name: *const gchar);
}
extern "C" {
pub fn gtk_icon_source_set_pixbuf(source: *mut GtkIconSource, pixbuf: *mut GdkPixbuf);
}
extern "C" {
pub fn gtk_icon_source_get_filename(source: *const GtkIconSource) -> *const gchar;
}
extern "C" {
pub fn gtk_icon_source_get_icon_name(source: *const GtkIconSource) -> *const gchar;
}
extern "C" {
pub fn gtk_icon_source_get_pixbuf(source: *const GtkIconSource) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_icon_source_set_direction_wildcarded(source: *mut GtkIconSource, setting: gboolean);
}
extern "C" {
pub fn gtk_icon_source_set_state_wildcarded(source: *mut GtkIconSource, setting: gboolean);
}
extern "C" {
pub fn gtk_icon_source_set_size_wildcarded(source: *mut GtkIconSource, setting: gboolean);
}
extern "C" {
pub fn gtk_icon_source_get_size_wildcarded(source: *const GtkIconSource) -> gboolean;
}
extern "C" {
pub fn gtk_icon_source_get_state_wildcarded(source: *const GtkIconSource) -> gboolean;
}
extern "C" {
pub fn gtk_icon_source_get_direction_wildcarded(source: *const GtkIconSource) -> gboolean;
}
extern "C" {
pub fn gtk_icon_source_set_direction(source: *mut GtkIconSource, direction: GtkTextDirection);
}
extern "C" {
pub fn gtk_icon_source_set_state(source: *mut GtkIconSource, state: GtkStateType);
}
extern "C" {
pub fn gtk_icon_source_set_size(source: *mut GtkIconSource, size: GtkIconSize);
}
extern "C" {
pub fn gtk_icon_source_get_direction(source: *const GtkIconSource) -> GtkTextDirection;
}
extern "C" {
pub fn gtk_icon_source_get_state(source: *const GtkIconSource) -> GtkStateType;
}
extern "C" {
pub fn gtk_icon_source_get_size(source: *const GtkIconSource) -> GtkIconSize;
}
pub type GtkStyleProperties = _GtkStyleProperties;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkStylePropertiesPrivate {
_unused: [u8; 0],
}
pub type GtkStylePropertiesPrivate = _GtkStylePropertiesPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkSymbolicColor {
_unused: [u8; 0],
}
pub type GtkSymbolicColor = _GtkSymbolicColor;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkGradient {
_unused: [u8; 0],
}
pub type GtkGradient = _GtkGradient;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkStyleProperties {
pub parent_object: GObject,
pub priv_: *mut GtkStylePropertiesPrivate,
}
#[test]
fn bindgen_test_layout__GtkStyleProperties() {
const UNINIT: ::std::mem::MaybeUninit<_GtkStyleProperties> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkStyleProperties>(),
32usize,
concat!("Size of: ", stringify!(_GtkStyleProperties))
);
assert_eq!(
::std::mem::align_of::<_GtkStyleProperties>(),
8usize,
concat!("Alignment of ", stringify!(_GtkStyleProperties))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_object) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyleProperties),
"::",
stringify!(parent_object)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyleProperties),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkStyleProperties {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type GtkStylePropertyParser = ::std::option::Option<
unsafe extern "C" fn(
string: *const gchar,
value: *mut GValue,
error: *mut *mut GError,
) -> gboolean,
>;
extern "C" {
pub fn gtk_style_properties_get_type() -> GType;
}
extern "C" {
pub fn gtk_style_properties_register_property(
parse_func: GtkStylePropertyParser,
pspec: *mut GParamSpec,
);
}
extern "C" {
pub fn gtk_style_properties_lookup_property(
property_name: *const gchar,
parse_func: *mut GtkStylePropertyParser,
pspec: *mut *mut GParamSpec,
) -> gboolean;
}
extern "C" {
pub fn gtk_style_properties_new() -> *mut GtkStyleProperties;
}
extern "C" {
pub fn gtk_style_properties_map_color(
props: *mut GtkStyleProperties,
name: *const gchar,
color: *mut GtkSymbolicColor,
);
}
extern "C" {
pub fn gtk_style_properties_lookup_color(
props: *mut GtkStyleProperties,
name: *const gchar,
) -> *mut GtkSymbolicColor;
}
extern "C" {
pub fn gtk_style_properties_set_property(
props: *mut GtkStyleProperties,
property: *const gchar,
state: GtkStateFlags,
value: *const GValue,
);
}
extern "C" {
pub fn gtk_style_properties_set(props: *mut GtkStyleProperties, state: GtkStateFlags, ...);
}
extern "C" {
pub fn gtk_style_properties_get_property(
props: *mut GtkStyleProperties,
property: *const gchar,
state: GtkStateFlags,
value: *mut GValue,
) -> gboolean;
}
extern "C" {
pub fn gtk_style_properties_get(props: *mut GtkStyleProperties, state: GtkStateFlags, ...);
}
extern "C" {
pub fn gtk_style_properties_unset_property(
props: *mut GtkStyleProperties,
property: *const gchar,
state: GtkStateFlags,
);
}
extern "C" {
pub fn gtk_style_properties_clear(props: *mut GtkStyleProperties);
}
extern "C" {
pub fn gtk_style_properties_merge(
props: *mut GtkStyleProperties,
props_to_merge: *const GtkStyleProperties,
replace: gboolean,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkStyleProvider {
_unused: [u8; 0],
}
pub type GtkStyleProvider = _GtkStyleProvider;
extern "C" {
pub fn gtk_style_provider_get_type() -> GType;
}
extern "C" {
pub fn gtk_style_provider_get_style(
provider: *mut GtkStyleProvider,
path: *mut GtkWidgetPath,
) -> *mut GtkStyleProperties;
}
extern "C" {
pub fn gtk_style_provider_get_style_property(
provider: *mut GtkStyleProvider,
path: *mut GtkWidgetPath,
state: GtkStateFlags,
pspec: *mut GParamSpec,
value: *mut GValue,
) -> gboolean;
}
extern "C" {
pub fn gtk_style_provider_get_icon_factory(
provider: *mut GtkStyleProvider,
path: *mut GtkWidgetPath,
) -> *mut GtkIconFactory;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkStyleContextPrivate {
_unused: [u8; 0],
}
pub type GtkStyleContextPrivate = _GtkStyleContextPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkStyleContext {
pub parent_object: GObject,
pub priv_: *mut GtkStyleContextPrivate,
}
#[test]
fn bindgen_test_layout__GtkStyleContext() {
const UNINIT: ::std::mem::MaybeUninit<_GtkStyleContext> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkStyleContext>(),
32usize,
concat!("Size of: ", stringify!(_GtkStyleContext))
);
assert_eq!(
::std::mem::align_of::<_GtkStyleContext>(),
8usize,
concat!("Alignment of ", stringify!(_GtkStyleContext))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_object) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyleContext),
"::",
stringify!(parent_object)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyleContext),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkStyleContext {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_style_context_get_type() -> GType;
}
extern "C" {
pub fn gtk_style_context_new() -> *mut GtkStyleContext;
}
extern "C" {
pub fn gtk_style_context_add_provider_for_screen(
screen: *mut GdkScreen,
provider: *mut GtkStyleProvider,
priority: guint,
);
}
extern "C" {
pub fn gtk_style_context_remove_provider_for_screen(
screen: *mut GdkScreen,
provider: *mut GtkStyleProvider,
);
}
extern "C" {
pub fn gtk_style_context_add_provider(
context: *mut GtkStyleContext,
provider: *mut GtkStyleProvider,
priority: guint,
);
}
extern "C" {
pub fn gtk_style_context_remove_provider(
context: *mut GtkStyleContext,
provider: *mut GtkStyleProvider,
);
}
extern "C" {
pub fn gtk_style_context_save(context: *mut GtkStyleContext);
}
extern "C" {
pub fn gtk_style_context_restore(context: *mut GtkStyleContext);
}
extern "C" {
pub fn gtk_style_context_get_section(
context: *mut GtkStyleContext,
property: *const gchar,
) -> *mut GtkCssSection;
}
extern "C" {
pub fn gtk_style_context_get_property(
context: *mut GtkStyleContext,
property: *const gchar,
state: GtkStateFlags,
value: *mut GValue,
);
}
extern "C" {
pub fn gtk_style_context_get(context: *mut GtkStyleContext, state: GtkStateFlags, ...);
}
extern "C" {
pub fn gtk_style_context_set_state(context: *mut GtkStyleContext, flags: GtkStateFlags);
}
extern "C" {
pub fn gtk_style_context_get_state(context: *mut GtkStyleContext) -> GtkStateFlags;
}
extern "C" {
pub fn gtk_style_context_set_scale(context: *mut GtkStyleContext, scale: gint);
}
extern "C" {
pub fn gtk_style_context_get_scale(context: *mut GtkStyleContext) -> gint;
}
extern "C" {
pub fn gtk_style_context_state_is_running(
context: *mut GtkStyleContext,
state: GtkStateType,
progress: *mut gdouble,
) -> gboolean;
}
extern "C" {
pub fn gtk_style_context_set_path(context: *mut GtkStyleContext, path: *mut GtkWidgetPath);
}
extern "C" {
pub fn gtk_style_context_get_path(context: *mut GtkStyleContext) -> *const GtkWidgetPath;
}
extern "C" {
pub fn gtk_style_context_set_parent(
context: *mut GtkStyleContext,
parent: *mut GtkStyleContext,
);
}
extern "C" {
pub fn gtk_style_context_get_parent(context: *mut GtkStyleContext) -> *mut GtkStyleContext;
}
extern "C" {
pub fn gtk_style_context_list_classes(context: *mut GtkStyleContext) -> *mut GList;
}
extern "C" {
pub fn gtk_style_context_add_class(context: *mut GtkStyleContext, class_name: *const gchar);
}
extern "C" {
pub fn gtk_style_context_remove_class(context: *mut GtkStyleContext, class_name: *const gchar);
}
extern "C" {
pub fn gtk_style_context_has_class(
context: *mut GtkStyleContext,
class_name: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_style_context_list_regions(context: *mut GtkStyleContext) -> *mut GList;
}
extern "C" {
pub fn gtk_style_context_add_region(
context: *mut GtkStyleContext,
region_name: *const gchar,
flags: GtkRegionFlags,
);
}
extern "C" {
pub fn gtk_style_context_remove_region(
context: *mut GtkStyleContext,
region_name: *const gchar,
);
}
extern "C" {
pub fn gtk_style_context_has_region(
context: *mut GtkStyleContext,
region_name: *const gchar,
flags_return: *mut GtkRegionFlags,
) -> gboolean;
}
extern "C" {
pub fn gtk_style_context_get_style_property(
context: *mut GtkStyleContext,
property_name: *const gchar,
value: *mut GValue,
);
}
extern "C" {
pub fn gtk_style_context_get_style(context: *mut GtkStyleContext, ...);
}
extern "C" {
pub fn gtk_style_context_lookup_icon_set(
context: *mut GtkStyleContext,
stock_id: *const gchar,
) -> *mut GtkIconSet;
}
extern "C" {
pub fn gtk_icon_set_render_icon_pixbuf(
icon_set: *mut GtkIconSet,
context: *mut GtkStyleContext,
size: GtkIconSize,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_icon_set_render_icon_surface(
icon_set: *mut GtkIconSet,
context: *mut GtkStyleContext,
size: GtkIconSize,
scale: ::std::os::raw::c_int,
for_window: *mut GdkWindow,
) -> *mut cairo_surface_t;
}
extern "C" {
pub fn gtk_style_context_set_screen(context: *mut GtkStyleContext, screen: *mut GdkScreen);
}
extern "C" {
pub fn gtk_style_context_get_screen(context: *mut GtkStyleContext) -> *mut GdkScreen;
}
extern "C" {
pub fn gtk_style_context_set_frame_clock(
context: *mut GtkStyleContext,
frame_clock: *mut GdkFrameClock,
);
}
extern "C" {
pub fn gtk_style_context_get_frame_clock(context: *mut GtkStyleContext) -> *mut GdkFrameClock;
}
extern "C" {
pub fn gtk_style_context_set_direction(
context: *mut GtkStyleContext,
direction: GtkTextDirection,
);
}
extern "C" {
pub fn gtk_style_context_get_direction(context: *mut GtkStyleContext) -> GtkTextDirection;
}
extern "C" {
pub fn gtk_style_context_set_junction_sides(
context: *mut GtkStyleContext,
sides: GtkJunctionSides,
);
}
extern "C" {
pub fn gtk_style_context_get_junction_sides(context: *mut GtkStyleContext) -> GtkJunctionSides;
}
extern "C" {
pub fn gtk_style_context_lookup_color(
context: *mut GtkStyleContext,
color_name: *const gchar,
color: *mut GdkRGBA,
) -> gboolean;
}
extern "C" {
pub fn gtk_style_context_notify_state_change(
context: *mut GtkStyleContext,
window: *mut GdkWindow,
region_id: gpointer,
state: GtkStateType,
state_value: gboolean,
);
}
extern "C" {
pub fn gtk_style_context_cancel_animations(context: *mut GtkStyleContext, region_id: gpointer);
}
extern "C" {
pub fn gtk_style_context_scroll_animations(
context: *mut GtkStyleContext,
window: *mut GdkWindow,
dx: gint,
dy: gint,
);
}
extern "C" {
pub fn gtk_style_context_push_animatable_region(
context: *mut GtkStyleContext,
region_id: gpointer,
);
}
extern "C" {
pub fn gtk_style_context_pop_animatable_region(context: *mut GtkStyleContext);
}
extern "C" {
pub fn gtk_style_context_get_color(
context: *mut GtkStyleContext,
state: GtkStateFlags,
color: *mut GdkRGBA,
);
}
extern "C" {
pub fn gtk_style_context_get_background_color(
context: *mut GtkStyleContext,
state: GtkStateFlags,
color: *mut GdkRGBA,
);
}
extern "C" {
pub fn gtk_style_context_get_border_color(
context: *mut GtkStyleContext,
state: GtkStateFlags,
color: *mut GdkRGBA,
);
}
extern "C" {
pub fn gtk_style_context_get_font(
context: *mut GtkStyleContext,
state: GtkStateFlags,
) -> *const PangoFontDescription;
}
extern "C" {
pub fn gtk_style_context_get_border(
context: *mut GtkStyleContext,
state: GtkStateFlags,
border: *mut GtkBorder,
);
}
extern "C" {
pub fn gtk_style_context_get_padding(
context: *mut GtkStyleContext,
state: GtkStateFlags,
padding: *mut GtkBorder,
);
}
extern "C" {
pub fn gtk_style_context_get_margin(
context: *mut GtkStyleContext,
state: GtkStateFlags,
margin: *mut GtkBorder,
);
}
extern "C" {
pub fn gtk_style_context_invalidate(context: *mut GtkStyleContext);
}
extern "C" {
pub fn gtk_style_context_reset_widgets(screen: *mut GdkScreen);
}
extern "C" {
pub fn gtk_style_context_set_background(context: *mut GtkStyleContext, window: *mut GdkWindow);
}
extern "C" {
pub fn gtk_render_check(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
x: gdouble,
y: gdouble,
width: gdouble,
height: gdouble,
);
}
extern "C" {
pub fn gtk_render_option(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
x: gdouble,
y: gdouble,
width: gdouble,
height: gdouble,
);
}
extern "C" {
pub fn gtk_render_arrow(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
angle: gdouble,
x: gdouble,
y: gdouble,
size: gdouble,
);
}
extern "C" {
pub fn gtk_render_background(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
x: gdouble,
y: gdouble,
width: gdouble,
height: gdouble,
);
}
extern "C" {
pub fn gtk_render_frame(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
x: gdouble,
y: gdouble,
width: gdouble,
height: gdouble,
);
}
extern "C" {
pub fn gtk_render_expander(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
x: gdouble,
y: gdouble,
width: gdouble,
height: gdouble,
);
}
extern "C" {
pub fn gtk_render_focus(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
x: gdouble,
y: gdouble,
width: gdouble,
height: gdouble,
);
}
extern "C" {
pub fn gtk_render_layout(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
x: gdouble,
y: gdouble,
layout: *mut PangoLayout,
);
}
extern "C" {
pub fn gtk_render_line(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
x0: gdouble,
y0: gdouble,
x1: gdouble,
y1: gdouble,
);
}
extern "C" {
pub fn gtk_render_slider(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
x: gdouble,
y: gdouble,
width: gdouble,
height: gdouble,
orientation: GtkOrientation,
);
}
extern "C" {
pub fn gtk_render_frame_gap(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
x: gdouble,
y: gdouble,
width: gdouble,
height: gdouble,
gap_side: GtkPositionType,
xy0_gap: gdouble,
xy1_gap: gdouble,
);
}
extern "C" {
pub fn gtk_render_extension(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
x: gdouble,
y: gdouble,
width: gdouble,
height: gdouble,
gap_side: GtkPositionType,
);
}
extern "C" {
pub fn gtk_render_handle(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
x: gdouble,
y: gdouble,
width: gdouble,
height: gdouble,
);
}
extern "C" {
pub fn gtk_render_activity(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
x: gdouble,
y: gdouble,
width: gdouble,
height: gdouble,
);
}
extern "C" {
pub fn gtk_render_icon_pixbuf(
context: *mut GtkStyleContext,
source: *const GtkIconSource,
size: GtkIconSize,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_render_icon(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
pixbuf: *mut GdkPixbuf,
x: gdouble,
y: gdouble,
);
}
extern "C" {
pub fn gtk_render_icon_surface(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
surface: *mut cairo_surface_t,
x: gdouble,
y: gdouble,
);
}
extern "C" {
pub fn gtk_render_insertion_cursor(
context: *mut GtkStyleContext,
cr: *mut cairo_t,
x: gdouble,
y: gdouble,
layout: *mut PangoLayout,
index: ::std::os::raw::c_int,
direction: PangoDirection,
);
}
extern "C" {
pub fn gtk_draw_insertion_cursor(
widget: *mut GtkWidget,
cr: *mut cairo_t,
location: *const GdkRectangle,
is_primary: gboolean,
direction: GtkTextDirection,
draw_arrow: gboolean,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkIconInfo {
_unused: [u8; 0],
}
#[doc = " GtkIconInfo:\n\n Contains information found when looking up an icon in\n an icon theme."]
pub type GtkIconInfo = _GtkIconInfo;
#[doc = " GtkIconTheme:\n\n Acts as a database of information about an icon theme.\n Normally, you retrieve the icon theme for a particular\n screen using gtk_icon_theme_get_for_screen() and it\n will contain information about current icon theme for\n that screen, but you can also create a new #GtkIconTheme\n object and set the icon theme name explicitly using\n gtk_icon_theme_set_custom_theme()."]
pub type GtkIconTheme = _GtkIconTheme;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkIconThemePrivate {
_unused: [u8; 0],
}
pub type GtkIconThemePrivate = _GtkIconThemePrivate;
#[doc = " GtkIconTheme:\n\n Acts as a database of information about an icon theme.\n Normally, you retrieve the icon theme for a particular\n screen using gtk_icon_theme_get_for_screen() and it\n will contain information about current icon theme for\n that screen, but you can also create a new #GtkIconTheme\n object and set the icon theme name explicitly using\n gtk_icon_theme_set_custom_theme()."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkIconTheme {
pub parent_instance: GObject,
pub priv_: *mut GtkIconThemePrivate,
}
#[test]
fn bindgen_test_layout__GtkIconTheme() {
const UNINIT: ::std::mem::MaybeUninit<_GtkIconTheme> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkIconTheme>(),
32usize,
concat!("Size of: ", stringify!(_GtkIconTheme))
);
assert_eq!(
::std::mem::align_of::<_GtkIconTheme>(),
8usize,
concat!("Alignment of ", stringify!(_GtkIconTheme))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkIconTheme),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkIconTheme),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkIconTheme {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const GtkIconLookupFlags_GTK_ICON_LOOKUP_NO_SVG: GtkIconLookupFlags = 1;
pub const GtkIconLookupFlags_GTK_ICON_LOOKUP_FORCE_SVG: GtkIconLookupFlags = 2;
pub const GtkIconLookupFlags_GTK_ICON_LOOKUP_USE_BUILTIN: GtkIconLookupFlags = 4;
pub const GtkIconLookupFlags_GTK_ICON_LOOKUP_GENERIC_FALLBACK: GtkIconLookupFlags = 8;
pub const GtkIconLookupFlags_GTK_ICON_LOOKUP_FORCE_SIZE: GtkIconLookupFlags = 16;
pub const GtkIconLookupFlags_GTK_ICON_LOOKUP_FORCE_REGULAR: GtkIconLookupFlags = 32;
pub const GtkIconLookupFlags_GTK_ICON_LOOKUP_FORCE_SYMBOLIC: GtkIconLookupFlags = 64;
pub const GtkIconLookupFlags_GTK_ICON_LOOKUP_DIR_LTR: GtkIconLookupFlags = 128;
pub const GtkIconLookupFlags_GTK_ICON_LOOKUP_DIR_RTL: GtkIconLookupFlags = 256;
#[doc = " GtkIconLookupFlags:\n @GTK_ICON_LOOKUP_NO_SVG: Never get SVG icons, even if gdk-pixbuf\n supports them. Cannot be used together with %GTK_ICON_LOOKUP_FORCE_SVG.\n @GTK_ICON_LOOKUP_FORCE_SVG: Get SVG icons, even if gdk-pixbuf\n doesn’t support them.\n Cannot be used together with %GTK_ICON_LOOKUP_NO_SVG.\n @GTK_ICON_LOOKUP_USE_BUILTIN: When passed to\n gtk_icon_theme_lookup_icon() includes builtin icons\n as well as files. For a builtin icon, gtk_icon_info_get_filename()\n is %NULL and you need to call gtk_icon_info_get_builtin_pixbuf().\n @GTK_ICON_LOOKUP_GENERIC_FALLBACK: Try to shorten icon name at '-'\n characters before looking at inherited themes. For more general\n fallback, see gtk_icon_theme_choose_icon(). Since 2.12.\n @GTK_ICON_LOOKUP_FORCE_SIZE: Always get the icon scaled to the\n requested size. Since 2.14.\n @GTK_ICON_LOOKUP_FORCE_REGULAR: Try to always load regular icons, even\n when symbolic icon names are given. Since 3.14.\n @GTK_ICON_LOOKUP_FORCE_SYMBOLIC: Try to always load symbolic icons, even\n when regular icon names are given. Since 3.14.\n @GTK_ICON_LOOKUP_DIR_LTR: Try to load a variant of the icon for left-to-right\n text direction. Since 3.14.\n @GTK_ICON_LOOKUP_DIR_RTL: Try to load a variant of the icon for right-to-left\n text direction. Since 3.14.\n\n Used to specify options for gtk_icon_theme_lookup_icon()"]
pub type GtkIconLookupFlags = ::std::os::raw::c_uint;
extern "C" {
pub fn gtk_icon_theme_error_quark() -> GQuark;
}
extern "C" {
pub fn gtk_icon_theme_get_type() -> GType;
}
extern "C" {
pub fn gtk_icon_theme_new() -> *mut GtkIconTheme;
}
extern "C" {
pub fn gtk_icon_theme_get_default() -> *mut GtkIconTheme;
}
extern "C" {
pub fn gtk_icon_theme_get_for_screen(screen: *mut GdkScreen) -> *mut GtkIconTheme;
}
extern "C" {
pub fn gtk_icon_theme_set_screen(icon_theme: *mut GtkIconTheme, screen: *mut GdkScreen);
}
extern "C" {
pub fn gtk_icon_theme_set_search_path(
icon_theme: *mut GtkIconTheme,
path: *mut *const gchar,
n_elements: gint,
);
}
extern "C" {
pub fn gtk_icon_theme_get_search_path(
icon_theme: *mut GtkIconTheme,
path: *mut *mut *mut gchar,
n_elements: *mut gint,
);
}
extern "C" {
pub fn gtk_icon_theme_append_search_path(icon_theme: *mut GtkIconTheme, path: *const gchar);
}
extern "C" {
pub fn gtk_icon_theme_prepend_search_path(icon_theme: *mut GtkIconTheme, path: *const gchar);
}
extern "C" {
pub fn gtk_icon_theme_add_resource_path(icon_theme: *mut GtkIconTheme, path: *const gchar);
}
extern "C" {
pub fn gtk_icon_theme_set_custom_theme(icon_theme: *mut GtkIconTheme, theme_name: *const gchar);
}
extern "C" {
pub fn gtk_icon_theme_has_icon(
icon_theme: *mut GtkIconTheme,
icon_name: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_icon_theme_get_icon_sizes(
icon_theme: *mut GtkIconTheme,
icon_name: *const gchar,
) -> *mut gint;
}
extern "C" {
pub fn gtk_icon_theme_lookup_icon(
icon_theme: *mut GtkIconTheme,
icon_name: *const gchar,
size: gint,
flags: GtkIconLookupFlags,
) -> *mut GtkIconInfo;
}
extern "C" {
pub fn gtk_icon_theme_lookup_icon_for_scale(
icon_theme: *mut GtkIconTheme,
icon_name: *const gchar,
size: gint,
scale: gint,
flags: GtkIconLookupFlags,
) -> *mut GtkIconInfo;
}
extern "C" {
pub fn gtk_icon_theme_choose_icon(
icon_theme: *mut GtkIconTheme,
icon_names: *mut *const gchar,
size: gint,
flags: GtkIconLookupFlags,
) -> *mut GtkIconInfo;
}
extern "C" {
pub fn gtk_icon_theme_choose_icon_for_scale(
icon_theme: *mut GtkIconTheme,
icon_names: *mut *const gchar,
size: gint,
scale: gint,
flags: GtkIconLookupFlags,
) -> *mut GtkIconInfo;
}
extern "C" {
pub fn gtk_icon_theme_load_icon(
icon_theme: *mut GtkIconTheme,
icon_name: *const gchar,
size: gint,
flags: GtkIconLookupFlags,
error: *mut *mut GError,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_icon_theme_load_icon_for_scale(
icon_theme: *mut GtkIconTheme,
icon_name: *const gchar,
size: gint,
scale: gint,
flags: GtkIconLookupFlags,
error: *mut *mut GError,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_icon_theme_load_surface(
icon_theme: *mut GtkIconTheme,
icon_name: *const gchar,
size: gint,
scale: gint,
for_window: *mut GdkWindow,
flags: GtkIconLookupFlags,
error: *mut *mut GError,
) -> *mut cairo_surface_t;
}
extern "C" {
pub fn gtk_icon_theme_lookup_by_gicon(
icon_theme: *mut GtkIconTheme,
icon: *mut GIcon,
size: gint,
flags: GtkIconLookupFlags,
) -> *mut GtkIconInfo;
}
extern "C" {
pub fn gtk_icon_theme_lookup_by_gicon_for_scale(
icon_theme: *mut GtkIconTheme,
icon: *mut GIcon,
size: gint,
scale: gint,
flags: GtkIconLookupFlags,
) -> *mut GtkIconInfo;
}
extern "C" {
pub fn gtk_icon_theme_list_icons(
icon_theme: *mut GtkIconTheme,
context: *const gchar,
) -> *mut GList;
}
extern "C" {
pub fn gtk_icon_theme_list_contexts(icon_theme: *mut GtkIconTheme) -> *mut GList;
}
extern "C" {
pub fn gtk_icon_theme_get_example_icon_name(
icon_theme: *mut GtkIconTheme,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn gtk_icon_theme_rescan_if_needed(icon_theme: *mut GtkIconTheme) -> gboolean;
}
extern "C" {
pub fn gtk_icon_theme_add_builtin_icon(
icon_name: *const gchar,
size: gint,
pixbuf: *mut GdkPixbuf,
);
}
extern "C" {
pub fn gtk_icon_info_get_type() -> GType;
}
extern "C" {
pub fn gtk_icon_info_copy(icon_info: *mut GtkIconInfo) -> *mut GtkIconInfo;
}
extern "C" {
pub fn gtk_icon_info_free(icon_info: *mut GtkIconInfo);
}
extern "C" {
pub fn gtk_icon_info_new_for_pixbuf(
icon_theme: *mut GtkIconTheme,
pixbuf: *mut GdkPixbuf,
) -> *mut GtkIconInfo;
}
extern "C" {
pub fn gtk_icon_info_get_base_size(icon_info: *mut GtkIconInfo) -> gint;
}
extern "C" {
pub fn gtk_icon_info_get_base_scale(icon_info: *mut GtkIconInfo) -> gint;
}
extern "C" {
pub fn gtk_icon_info_get_filename(icon_info: *mut GtkIconInfo) -> *const gchar;
}
extern "C" {
pub fn gtk_icon_info_get_builtin_pixbuf(icon_info: *mut GtkIconInfo) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_icon_info_is_symbolic(icon_info: *mut GtkIconInfo) -> gboolean;
}
extern "C" {
pub fn gtk_icon_info_load_icon(
icon_info: *mut GtkIconInfo,
error: *mut *mut GError,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_icon_info_load_surface(
icon_info: *mut GtkIconInfo,
for_window: *mut GdkWindow,
error: *mut *mut GError,
) -> *mut cairo_surface_t;
}
extern "C" {
pub fn gtk_icon_info_load_icon_async(
icon_info: *mut GtkIconInfo,
cancellable: *mut GCancellable,
callback: GAsyncReadyCallback,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_icon_info_load_icon_finish(
icon_info: *mut GtkIconInfo,
res: *mut GAsyncResult,
error: *mut *mut GError,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_icon_info_load_symbolic(
icon_info: *mut GtkIconInfo,
fg: *const GdkRGBA,
success_color: *const GdkRGBA,
warning_color: *const GdkRGBA,
error_color: *const GdkRGBA,
was_symbolic: *mut gboolean,
error: *mut *mut GError,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_icon_info_load_symbolic_async(
icon_info: *mut GtkIconInfo,
fg: *const GdkRGBA,
success_color: *const GdkRGBA,
warning_color: *const GdkRGBA,
error_color: *const GdkRGBA,
cancellable: *mut GCancellable,
callback: GAsyncReadyCallback,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_icon_info_load_symbolic_finish(
icon_info: *mut GtkIconInfo,
res: *mut GAsyncResult,
was_symbolic: *mut gboolean,
error: *mut *mut GError,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_icon_info_load_symbolic_for_context(
icon_info: *mut GtkIconInfo,
context: *mut GtkStyleContext,
was_symbolic: *mut gboolean,
error: *mut *mut GError,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_icon_info_load_symbolic_for_context_async(
icon_info: *mut GtkIconInfo,
context: *mut GtkStyleContext,
cancellable: *mut GCancellable,
callback: GAsyncReadyCallback,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_icon_info_load_symbolic_for_context_finish(
icon_info: *mut GtkIconInfo,
res: *mut GAsyncResult,
was_symbolic: *mut gboolean,
error: *mut *mut GError,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_icon_info_load_symbolic_for_style(
icon_info: *mut GtkIconInfo,
style: *mut GtkStyle,
state: GtkStateType,
was_symbolic: *mut gboolean,
error: *mut *mut GError,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_icon_info_set_raw_coordinates(
icon_info: *mut GtkIconInfo,
raw_coordinates: gboolean,
);
}
extern "C" {
pub fn gtk_icon_info_get_embedded_rect(
icon_info: *mut GtkIconInfo,
rectangle: *mut GdkRectangle,
) -> gboolean;
}
extern "C" {
pub fn gtk_icon_info_get_attach_points(
icon_info: *mut GtkIconInfo,
points: *mut *mut GdkPoint,
n_points: *mut gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_icon_info_get_display_name(icon_info: *mut GtkIconInfo) -> *const gchar;
}
extern "C" {
pub fn gtk_tooltip_get_type() -> GType;
}
extern "C" {
pub fn gtk_tooltip_set_markup(tooltip: *mut GtkTooltip, markup: *const gchar);
}
extern "C" {
pub fn gtk_tooltip_set_text(tooltip: *mut GtkTooltip, text: *const gchar);
}
extern "C" {
pub fn gtk_tooltip_set_icon(tooltip: *mut GtkTooltip, pixbuf: *mut GdkPixbuf);
}
extern "C" {
pub fn gtk_tooltip_set_icon_from_stock(
tooltip: *mut GtkTooltip,
stock_id: *const gchar,
size: GtkIconSize,
);
}
extern "C" {
pub fn gtk_tooltip_set_icon_from_icon_name(
tooltip: *mut GtkTooltip,
icon_name: *const gchar,
size: GtkIconSize,
);
}
extern "C" {
pub fn gtk_tooltip_set_icon_from_gicon(
tooltip: *mut GtkTooltip,
gicon: *mut GIcon,
size: GtkIconSize,
);
}
extern "C" {
pub fn gtk_tooltip_set_custom(tooltip: *mut GtkTooltip, custom_widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_tooltip_set_tip_area(tooltip: *mut GtkTooltip, rect: *const GdkRectangle);
}
extern "C" {
pub fn gtk_tooltip_trigger_tooltip_query(display: *mut GdkDisplay);
}
pub type GtkIconView = _GtkIconView;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkIconViewPrivate {
_unused: [u8; 0],
}
pub type GtkIconViewPrivate = _GtkIconViewPrivate;
#[doc = " GtkIconViewForeachFunc:\n @icon_view: a #GtkIconView\n @path: The #GtkTreePath of a selected row\n @data: (closure): user data\n\n A function used by gtk_icon_view_selected_foreach() to map all\n selected rows. It will be called on every selected row in the view."]
pub type GtkIconViewForeachFunc = ::std::option::Option<
unsafe extern "C" fn(icon_view: *mut GtkIconView, path: *mut GtkTreePath, data: gpointer),
>;
pub const GtkIconViewDropPosition_GTK_ICON_VIEW_NO_DROP: GtkIconViewDropPosition = 0;
pub const GtkIconViewDropPosition_GTK_ICON_VIEW_DROP_INTO: GtkIconViewDropPosition = 1;
pub const GtkIconViewDropPosition_GTK_ICON_VIEW_DROP_LEFT: GtkIconViewDropPosition = 2;
pub const GtkIconViewDropPosition_GTK_ICON_VIEW_DROP_RIGHT: GtkIconViewDropPosition = 3;
pub const GtkIconViewDropPosition_GTK_ICON_VIEW_DROP_ABOVE: GtkIconViewDropPosition = 4;
pub const GtkIconViewDropPosition_GTK_ICON_VIEW_DROP_BELOW: GtkIconViewDropPosition = 5;
#[doc = " GtkIconViewDropPosition:\n @GTK_ICON_VIEW_NO_DROP: no drop possible\n @GTK_ICON_VIEW_DROP_INTO: dropped item replaces the item\n @GTK_ICON_VIEW_DROP_LEFT: droppped item is inserted to the left\n @GTK_ICON_VIEW_DROP_RIGHT: dropped item is inserted to the right\n @GTK_ICON_VIEW_DROP_ABOVE: dropped item is inserted above\n @GTK_ICON_VIEW_DROP_BELOW: dropped item is inserted below\n\n An enum for determining where a dropped item goes."]
pub type GtkIconViewDropPosition = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkIconView {
pub parent: GtkContainer,
pub priv_: *mut GtkIconViewPrivate,
}
#[test]
fn bindgen_test_layout__GtkIconView() {
const UNINIT: ::std::mem::MaybeUninit<_GtkIconView> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkIconView>(),
48usize,
concat!("Size of: ", stringify!(_GtkIconView))
);
assert_eq!(
::std::mem::align_of::<_GtkIconView>(),
8usize,
concat!("Alignment of ", stringify!(_GtkIconView))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkIconView),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkIconView),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkIconView {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_icon_view_get_type() -> GType;
}
extern "C" {
pub fn gtk_icon_view_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_icon_view_new_with_area(area: *mut GtkCellArea) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_icon_view_new_with_model(model: *mut GtkTreeModel) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_icon_view_set_model(icon_view: *mut GtkIconView, model: *mut GtkTreeModel);
}
extern "C" {
pub fn gtk_icon_view_get_model(icon_view: *mut GtkIconView) -> *mut GtkTreeModel;
}
extern "C" {
pub fn gtk_icon_view_set_text_column(icon_view: *mut GtkIconView, column: gint);
}
extern "C" {
pub fn gtk_icon_view_get_text_column(icon_view: *mut GtkIconView) -> gint;
}
extern "C" {
pub fn gtk_icon_view_set_markup_column(icon_view: *mut GtkIconView, column: gint);
}
extern "C" {
pub fn gtk_icon_view_get_markup_column(icon_view: *mut GtkIconView) -> gint;
}
extern "C" {
pub fn gtk_icon_view_set_pixbuf_column(icon_view: *mut GtkIconView, column: gint);
}
extern "C" {
pub fn gtk_icon_view_get_pixbuf_column(icon_view: *mut GtkIconView) -> gint;
}
extern "C" {
pub fn gtk_icon_view_set_item_orientation(
icon_view: *mut GtkIconView,
orientation: GtkOrientation,
);
}
extern "C" {
pub fn gtk_icon_view_get_item_orientation(icon_view: *mut GtkIconView) -> GtkOrientation;
}
extern "C" {
pub fn gtk_icon_view_set_columns(icon_view: *mut GtkIconView, columns: gint);
}
extern "C" {
pub fn gtk_icon_view_get_columns(icon_view: *mut GtkIconView) -> gint;
}
extern "C" {
pub fn gtk_icon_view_set_item_width(icon_view: *mut GtkIconView, item_width: gint);
}
extern "C" {
pub fn gtk_icon_view_get_item_width(icon_view: *mut GtkIconView) -> gint;
}
extern "C" {
pub fn gtk_icon_view_set_spacing(icon_view: *mut GtkIconView, spacing: gint);
}
extern "C" {
pub fn gtk_icon_view_get_spacing(icon_view: *mut GtkIconView) -> gint;
}
extern "C" {
pub fn gtk_icon_view_set_row_spacing(icon_view: *mut GtkIconView, row_spacing: gint);
}
extern "C" {
pub fn gtk_icon_view_get_row_spacing(icon_view: *mut GtkIconView) -> gint;
}
extern "C" {
pub fn gtk_icon_view_set_column_spacing(icon_view: *mut GtkIconView, column_spacing: gint);
}
extern "C" {
pub fn gtk_icon_view_get_column_spacing(icon_view: *mut GtkIconView) -> gint;
}
extern "C" {
pub fn gtk_icon_view_set_margin(icon_view: *mut GtkIconView, margin: gint);
}
extern "C" {
pub fn gtk_icon_view_get_margin(icon_view: *mut GtkIconView) -> gint;
}
extern "C" {
pub fn gtk_icon_view_set_item_padding(icon_view: *mut GtkIconView, item_padding: gint);
}
extern "C" {
pub fn gtk_icon_view_get_item_padding(icon_view: *mut GtkIconView) -> gint;
}
extern "C" {
pub fn gtk_icon_view_get_path_at_pos(
icon_view: *mut GtkIconView,
x: gint,
y: gint,
) -> *mut GtkTreePath;
}
extern "C" {
pub fn gtk_icon_view_get_item_at_pos(
icon_view: *mut GtkIconView,
x: gint,
y: gint,
path: *mut *mut GtkTreePath,
cell: *mut *mut GtkCellRenderer,
) -> gboolean;
}
extern "C" {
pub fn gtk_icon_view_get_visible_range(
icon_view: *mut GtkIconView,
start_path: *mut *mut GtkTreePath,
end_path: *mut *mut GtkTreePath,
) -> gboolean;
}
extern "C" {
pub fn gtk_icon_view_set_activate_on_single_click(
icon_view: *mut GtkIconView,
single: gboolean,
);
}
extern "C" {
pub fn gtk_icon_view_get_activate_on_single_click(icon_view: *mut GtkIconView) -> gboolean;
}
extern "C" {
pub fn gtk_icon_view_selected_foreach(
icon_view: *mut GtkIconView,
func: GtkIconViewForeachFunc,
data: gpointer,
);
}
extern "C" {
pub fn gtk_icon_view_set_selection_mode(icon_view: *mut GtkIconView, mode: GtkSelectionMode);
}
extern "C" {
pub fn gtk_icon_view_get_selection_mode(icon_view: *mut GtkIconView) -> GtkSelectionMode;
}
extern "C" {
pub fn gtk_icon_view_select_path(icon_view: *mut GtkIconView, path: *mut GtkTreePath);
}
extern "C" {
pub fn gtk_icon_view_unselect_path(icon_view: *mut GtkIconView, path: *mut GtkTreePath);
}
extern "C" {
pub fn gtk_icon_view_path_is_selected(
icon_view: *mut GtkIconView,
path: *mut GtkTreePath,
) -> gboolean;
}
extern "C" {
pub fn gtk_icon_view_get_item_row(icon_view: *mut GtkIconView, path: *mut GtkTreePath) -> gint;
}
extern "C" {
pub fn gtk_icon_view_get_item_column(
icon_view: *mut GtkIconView,
path: *mut GtkTreePath,
) -> gint;
}
extern "C" {
pub fn gtk_icon_view_get_selected_items(icon_view: *mut GtkIconView) -> *mut GList;
}
extern "C" {
pub fn gtk_icon_view_select_all(icon_view: *mut GtkIconView);
}
extern "C" {
pub fn gtk_icon_view_unselect_all(icon_view: *mut GtkIconView);
}
extern "C" {
pub fn gtk_icon_view_item_activated(icon_view: *mut GtkIconView, path: *mut GtkTreePath);
}
extern "C" {
pub fn gtk_icon_view_set_cursor(
icon_view: *mut GtkIconView,
path: *mut GtkTreePath,
cell: *mut GtkCellRenderer,
start_editing: gboolean,
);
}
extern "C" {
pub fn gtk_icon_view_get_cursor(
icon_view: *mut GtkIconView,
path: *mut *mut GtkTreePath,
cell: *mut *mut GtkCellRenderer,
) -> gboolean;
}
extern "C" {
pub fn gtk_icon_view_scroll_to_path(
icon_view: *mut GtkIconView,
path: *mut GtkTreePath,
use_align: gboolean,
row_align: gfloat,
col_align: gfloat,
);
}
extern "C" {
pub fn gtk_icon_view_enable_model_drag_source(
icon_view: *mut GtkIconView,
start_button_mask: GdkModifierType,
targets: *const GtkTargetEntry,
n_targets: gint,
actions: GdkDragAction,
);
}
extern "C" {
pub fn gtk_icon_view_enable_model_drag_dest(
icon_view: *mut GtkIconView,
targets: *const GtkTargetEntry,
n_targets: gint,
actions: GdkDragAction,
);
}
extern "C" {
pub fn gtk_icon_view_unset_model_drag_source(icon_view: *mut GtkIconView);
}
extern "C" {
pub fn gtk_icon_view_unset_model_drag_dest(icon_view: *mut GtkIconView);
}
extern "C" {
pub fn gtk_icon_view_set_reorderable(icon_view: *mut GtkIconView, reorderable: gboolean);
}
extern "C" {
pub fn gtk_icon_view_get_reorderable(icon_view: *mut GtkIconView) -> gboolean;
}
extern "C" {
pub fn gtk_icon_view_set_drag_dest_item(
icon_view: *mut GtkIconView,
path: *mut GtkTreePath,
pos: GtkIconViewDropPosition,
);
}
extern "C" {
pub fn gtk_icon_view_get_drag_dest_item(
icon_view: *mut GtkIconView,
path: *mut *mut GtkTreePath,
pos: *mut GtkIconViewDropPosition,
);
}
extern "C" {
pub fn gtk_icon_view_get_dest_item_at_pos(
icon_view: *mut GtkIconView,
drag_x: gint,
drag_y: gint,
path: *mut *mut GtkTreePath,
pos: *mut GtkIconViewDropPosition,
) -> gboolean;
}
extern "C" {
pub fn gtk_icon_view_create_drag_icon(
icon_view: *mut GtkIconView,
path: *mut GtkTreePath,
) -> *mut cairo_surface_t;
}
extern "C" {
pub fn gtk_icon_view_convert_widget_to_bin_window_coords(
icon_view: *mut GtkIconView,
wx: gint,
wy: gint,
bx: *mut gint,
by: *mut gint,
);
}
extern "C" {
pub fn gtk_icon_view_get_cell_rect(
icon_view: *mut GtkIconView,
path: *mut GtkTreePath,
cell: *mut GtkCellRenderer,
rect: *mut GdkRectangle,
) -> gboolean;
}
extern "C" {
pub fn gtk_icon_view_set_tooltip_item(
icon_view: *mut GtkIconView,
tooltip: *mut GtkTooltip,
path: *mut GtkTreePath,
);
}
extern "C" {
pub fn gtk_icon_view_set_tooltip_cell(
icon_view: *mut GtkIconView,
tooltip: *mut GtkTooltip,
path: *mut GtkTreePath,
cell: *mut GtkCellRenderer,
);
}
extern "C" {
pub fn gtk_icon_view_get_tooltip_context(
icon_view: *mut GtkIconView,
x: *mut gint,
y: *mut gint,
keyboard_tip: gboolean,
model: *mut *mut GtkTreeModel,
path: *mut *mut GtkTreePath,
iter: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_icon_view_set_tooltip_column(icon_view: *mut GtkIconView, column: gint);
}
extern "C" {
pub fn gtk_icon_view_get_tooltip_column(icon_view: *mut GtkIconView) -> gint;
}
pub type GtkIMContextSimple = _GtkIMContextSimple;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkIMContextSimplePrivate {
_unused: [u8; 0],
}
pub type GtkIMContextSimplePrivate = _GtkIMContextSimplePrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkIMContextSimple {
pub object: GtkIMContext,
pub priv_: *mut GtkIMContextSimplePrivate,
}
#[test]
fn bindgen_test_layout__GtkIMContextSimple() {
const UNINIT: ::std::mem::MaybeUninit<_GtkIMContextSimple> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkIMContextSimple>(),
32usize,
concat!("Size of: ", stringify!(_GtkIMContextSimple))
);
assert_eq!(
::std::mem::align_of::<_GtkIMContextSimple>(),
8usize,
concat!("Alignment of ", stringify!(_GtkIMContextSimple))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).object) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkIMContextSimple),
"::",
stringify!(object)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkIMContextSimple),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkIMContextSimple {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_im_context_simple_get_type() -> GType;
}
extern "C" {
pub fn gtk_im_context_simple_new() -> *mut GtkIMContext;
}
extern "C" {
pub fn gtk_im_context_simple_add_table(
context_simple: *mut GtkIMContextSimple,
data: *mut guint16,
max_seq_len: gint,
n_seqs: gint,
);
}
pub type GtkIMMulticontext = _GtkIMMulticontext;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkIMMulticontextPrivate {
_unused: [u8; 0],
}
pub type GtkIMMulticontextPrivate = _GtkIMMulticontextPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkIMMulticontext {
pub object: GtkIMContext,
pub priv_: *mut GtkIMMulticontextPrivate,
}
#[test]
fn bindgen_test_layout__GtkIMMulticontext() {
const UNINIT: ::std::mem::MaybeUninit<_GtkIMMulticontext> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkIMMulticontext>(),
32usize,
concat!("Size of: ", stringify!(_GtkIMMulticontext))
);
assert_eq!(
::std::mem::align_of::<_GtkIMMulticontext>(),
8usize,
concat!("Alignment of ", stringify!(_GtkIMMulticontext))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).object) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkIMMulticontext),
"::",
stringify!(object)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkIMMulticontext),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkIMMulticontext {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_im_multicontext_get_type() -> GType;
}
extern "C" {
pub fn gtk_im_multicontext_new() -> *mut GtkIMContext;
}
extern "C" {
pub fn gtk_im_multicontext_append_menuitems(
context: *mut GtkIMMulticontext,
menushell: *mut GtkMenuShell,
);
}
extern "C" {
pub fn gtk_im_multicontext_get_context_id(
context: *mut GtkIMMulticontext,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn gtk_im_multicontext_set_context_id(
context: *mut GtkIMMulticontext,
context_id: *const ::std::os::raw::c_char,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkInfoBarPrivate {
_unused: [u8; 0],
}
pub type GtkInfoBarPrivate = _GtkInfoBarPrivate;
pub type GtkInfoBar = _GtkInfoBar;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkInfoBar {
pub parent: GtkBox,
pub priv_: *mut GtkInfoBarPrivate,
}
#[test]
fn bindgen_test_layout__GtkInfoBar() {
const UNINIT: ::std::mem::MaybeUninit<_GtkInfoBar> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkInfoBar>(),
56usize,
concat!("Size of: ", stringify!(_GtkInfoBar))
);
assert_eq!(
::std::mem::align_of::<_GtkInfoBar>(),
8usize,
concat!("Alignment of ", stringify!(_GtkInfoBar))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkInfoBar),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkInfoBar),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkInfoBar {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_info_bar_get_type() -> GType;
}
extern "C" {
pub fn gtk_info_bar_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_info_bar_new_with_buttons(first_button_text: *const gchar, ...) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_info_bar_get_action_area(info_bar: *mut GtkInfoBar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_info_bar_get_content_area(info_bar: *mut GtkInfoBar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_info_bar_add_action_widget(
info_bar: *mut GtkInfoBar,
child: *mut GtkWidget,
response_id: gint,
);
}
extern "C" {
pub fn gtk_info_bar_add_button(
info_bar: *mut GtkInfoBar,
button_text: *const gchar,
response_id: gint,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_info_bar_add_buttons(
info_bar: *mut GtkInfoBar,
first_button_text: *const gchar,
...
);
}
extern "C" {
pub fn gtk_info_bar_set_response_sensitive(
info_bar: *mut GtkInfoBar,
response_id: gint,
setting: gboolean,
);
}
extern "C" {
pub fn gtk_info_bar_set_default_response(info_bar: *mut GtkInfoBar, response_id: gint);
}
extern "C" {
pub fn gtk_info_bar_response(info_bar: *mut GtkInfoBar, response_id: gint);
}
extern "C" {
pub fn gtk_info_bar_set_message_type(info_bar: *mut GtkInfoBar, message_type: GtkMessageType);
}
extern "C" {
pub fn gtk_info_bar_get_message_type(info_bar: *mut GtkInfoBar) -> GtkMessageType;
}
extern "C" {
pub fn gtk_info_bar_set_show_close_button(info_bar: *mut GtkInfoBar, setting: gboolean);
}
extern "C" {
pub fn gtk_info_bar_get_show_close_button(info_bar: *mut GtkInfoBar) -> gboolean;
}
pub type GtkInvisible = _GtkInvisible;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkInvisiblePrivate {
_unused: [u8; 0],
}
pub type GtkInvisiblePrivate = _GtkInvisiblePrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkInvisible {
pub widget: GtkWidget,
pub priv_: *mut GtkInvisiblePrivate,
}
#[test]
fn bindgen_test_layout__GtkInvisible() {
const UNINIT: ::std::mem::MaybeUninit<_GtkInvisible> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkInvisible>(),
40usize,
concat!("Size of: ", stringify!(_GtkInvisible))
);
assert_eq!(
::std::mem::align_of::<_GtkInvisible>(),
8usize,
concat!("Alignment of ", stringify!(_GtkInvisible))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).widget) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkInvisible),
"::",
stringify!(widget)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkInvisible),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkInvisible {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_invisible_get_type() -> GType;
}
extern "C" {
pub fn gtk_invisible_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_invisible_new_for_screen(screen: *mut GdkScreen) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_invisible_set_screen(invisible: *mut GtkInvisible, screen: *mut GdkScreen);
}
extern "C" {
pub fn gtk_invisible_get_screen(invisible: *mut GtkInvisible) -> *mut GdkScreen;
}
pub type GtkLayout = _GtkLayout;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkLayoutPrivate {
_unused: [u8; 0],
}
pub type GtkLayoutPrivate = _GtkLayoutPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkLayout {
pub container: GtkContainer,
pub priv_: *mut GtkLayoutPrivate,
}
#[test]
fn bindgen_test_layout__GtkLayout() {
const UNINIT: ::std::mem::MaybeUninit<_GtkLayout> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkLayout>(),
48usize,
concat!("Size of: ", stringify!(_GtkLayout))
);
assert_eq!(
::std::mem::align_of::<_GtkLayout>(),
8usize,
concat!("Alignment of ", stringify!(_GtkLayout))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).container) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkLayout),
"::",
stringify!(container)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkLayout),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkLayout {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_layout_get_type() -> GType;
}
extern "C" {
pub fn gtk_layout_new(
hadjustment: *mut GtkAdjustment,
vadjustment: *mut GtkAdjustment,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_layout_get_bin_window(layout: *mut GtkLayout) -> *mut GdkWindow;
}
extern "C" {
pub fn gtk_layout_put(layout: *mut GtkLayout, child_widget: *mut GtkWidget, x: gint, y: gint);
}
extern "C" {
pub fn gtk_layout_move(layout: *mut GtkLayout, child_widget: *mut GtkWidget, x: gint, y: gint);
}
extern "C" {
pub fn gtk_layout_set_size(layout: *mut GtkLayout, width: guint, height: guint);
}
extern "C" {
pub fn gtk_layout_get_size(layout: *mut GtkLayout, width: *mut guint, height: *mut guint);
}
extern "C" {
pub fn gtk_layout_get_hadjustment(layout: *mut GtkLayout) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_layout_get_vadjustment(layout: *mut GtkLayout) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_layout_set_hadjustment(layout: *mut GtkLayout, adjustment: *mut GtkAdjustment);
}
extern "C" {
pub fn gtk_layout_set_vadjustment(layout: *mut GtkLayout, adjustment: *mut GtkAdjustment);
}
pub type GtkLevelBar = _GtkLevelBar;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkLevelBarPrivate {
_unused: [u8; 0],
}
pub type GtkLevelBarPrivate = _GtkLevelBarPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkLevelBar {
pub parent: GtkWidget,
pub priv_: *mut GtkLevelBarPrivate,
}
#[test]
fn bindgen_test_layout__GtkLevelBar() {
const UNINIT: ::std::mem::MaybeUninit<_GtkLevelBar> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkLevelBar>(),
40usize,
concat!("Size of: ", stringify!(_GtkLevelBar))
);
assert_eq!(
::std::mem::align_of::<_GtkLevelBar>(),
8usize,
concat!("Alignment of ", stringify!(_GtkLevelBar))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkLevelBar),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkLevelBar),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkLevelBar {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_level_bar_get_type() -> GType;
}
extern "C" {
pub fn gtk_level_bar_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_level_bar_new_for_interval(min_value: gdouble, max_value: gdouble)
-> *mut GtkWidget;
}
extern "C" {
pub fn gtk_level_bar_set_mode(self_: *mut GtkLevelBar, mode: GtkLevelBarMode);
}
extern "C" {
pub fn gtk_level_bar_get_mode(self_: *mut GtkLevelBar) -> GtkLevelBarMode;
}
extern "C" {
pub fn gtk_level_bar_set_value(self_: *mut GtkLevelBar, value: gdouble);
}
extern "C" {
pub fn gtk_level_bar_get_value(self_: *mut GtkLevelBar) -> gdouble;
}
extern "C" {
pub fn gtk_level_bar_set_min_value(self_: *mut GtkLevelBar, value: gdouble);
}
extern "C" {
pub fn gtk_level_bar_get_min_value(self_: *mut GtkLevelBar) -> gdouble;
}
extern "C" {
pub fn gtk_level_bar_set_max_value(self_: *mut GtkLevelBar, value: gdouble);
}
extern "C" {
pub fn gtk_level_bar_get_max_value(self_: *mut GtkLevelBar) -> gdouble;
}
extern "C" {
pub fn gtk_level_bar_set_inverted(self_: *mut GtkLevelBar, inverted: gboolean);
}
extern "C" {
pub fn gtk_level_bar_get_inverted(self_: *mut GtkLevelBar) -> gboolean;
}
extern "C" {
pub fn gtk_level_bar_add_offset_value(
self_: *mut GtkLevelBar,
name: *const gchar,
value: gdouble,
);
}
extern "C" {
pub fn gtk_level_bar_remove_offset_value(self_: *mut GtkLevelBar, name: *const gchar);
}
extern "C" {
pub fn gtk_level_bar_get_offset_value(
self_: *mut GtkLevelBar,
name: *const gchar,
value: *mut gdouble,
) -> gboolean;
}
#[doc = " GtkLinkButton:\n\n The #GtkLinkButton-struct contains only\n private data and should be accessed using the provided API."]
pub type GtkLinkButton = _GtkLinkButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkLinkButtonPrivate {
_unused: [u8; 0],
}
pub type GtkLinkButtonPrivate = _GtkLinkButtonPrivate;
#[doc = " GtkLinkButton:\n\n The #GtkLinkButton-struct contains only\n private data and should be accessed using the provided API."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkLinkButton {
pub parent_instance: GtkButton,
pub priv_: *mut GtkLinkButtonPrivate,
}
#[test]
fn bindgen_test_layout__GtkLinkButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkLinkButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkLinkButton>(),
64usize,
concat!("Size of: ", stringify!(_GtkLinkButton))
);
assert_eq!(
::std::mem::align_of::<_GtkLinkButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkLinkButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkLinkButton),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkLinkButton),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkLinkButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_link_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_link_button_new(uri: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_link_button_new_with_label(uri: *const gchar, label: *const gchar)
-> *mut GtkWidget;
}
extern "C" {
pub fn gtk_link_button_get_uri(link_button: *mut GtkLinkButton) -> *const gchar;
}
extern "C" {
pub fn gtk_link_button_set_uri(link_button: *mut GtkLinkButton, uri: *const gchar);
}
extern "C" {
pub fn gtk_link_button_get_visited(link_button: *mut GtkLinkButton) -> gboolean;
}
extern "C" {
pub fn gtk_link_button_set_visited(link_button: *mut GtkLinkButton, visited: gboolean);
}
pub type GtkListBox = _GtkListBox;
pub type GtkListBoxRow = _GtkListBoxRow;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkListBox {
pub parent_instance: GtkContainer,
}
#[test]
fn bindgen_test_layout__GtkListBox() {
const UNINIT: ::std::mem::MaybeUninit<_GtkListBox> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkListBox>(),
40usize,
concat!("Size of: ", stringify!(_GtkListBox))
);
assert_eq!(
::std::mem::align_of::<_GtkListBox>(),
8usize,
concat!("Alignment of ", stringify!(_GtkListBox))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkListBox),
"::",
stringify!(parent_instance)
)
);
}
impl Default for _GtkListBox {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkListBoxRow {
pub parent_instance: GtkBin,
}
#[test]
fn bindgen_test_layout__GtkListBoxRow() {
const UNINIT: ::std::mem::MaybeUninit<_GtkListBoxRow> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkListBoxRow>(),
48usize,
concat!("Size of: ", stringify!(_GtkListBoxRow))
);
assert_eq!(
::std::mem::align_of::<_GtkListBoxRow>(),
8usize,
concat!("Alignment of ", stringify!(_GtkListBoxRow))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkListBoxRow),
"::",
stringify!(parent_instance)
)
);
}
impl Default for _GtkListBoxRow {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GtkListBoxFilterFunc:\n @row: the row that may be filtered\n @user_data: (closure): user data\n\n Will be called whenever the row changes or is added and lets you control\n if the row should be visible or not.\n\n Returns: %TRUE if the row should be visible, %FALSE otherwise\n\n Since: 3.10"]
pub type GtkListBoxFilterFunc = ::std::option::Option<
unsafe extern "C" fn(row: *mut GtkListBoxRow, user_data: gpointer) -> gboolean,
>;
#[doc = " GtkListBoxSortFunc:\n @row1: the first row\n @row2: the second row\n @user_data: (closure): user data\n\n Compare two rows to determine which should be first.\n\n Returns: < 0 if @row1 should be before @row2, 0 if they are\n equal and > 0 otherwise\n\n Since: 3.10"]
pub type GtkListBoxSortFunc = ::std::option::Option<
unsafe extern "C" fn(
row1: *mut GtkListBoxRow,
row2: *mut GtkListBoxRow,
user_data: gpointer,
) -> gint,
>;
#[doc = " GtkListBoxUpdateHeaderFunc:\n @row: the row to update\n @before: (allow-none): the row before @row, or %NULL if it is first\n @user_data: (closure): user data\n\n Whenever @row changes or which row is before @row changes this\n is called, which lets you update the header on @row. You may\n remove or set a new one via gtk_list_box_row_set_header() or\n just change the state of the current header widget.\n\n Since: 3.10"]
pub type GtkListBoxUpdateHeaderFunc = ::std::option::Option<
unsafe extern "C" fn(row: *mut GtkListBoxRow, before: *mut GtkListBoxRow, user_data: gpointer),
>;
extern "C" {
pub fn gtk_list_box_row_get_type() -> GType;
}
extern "C" {
pub fn gtk_list_box_row_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_list_box_row_get_header(row: *mut GtkListBoxRow) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_list_box_row_set_header(row: *mut GtkListBoxRow, header: *mut GtkWidget);
}
extern "C" {
pub fn gtk_list_box_row_get_index(row: *mut GtkListBoxRow) -> gint;
}
extern "C" {
pub fn gtk_list_box_row_changed(row: *mut GtkListBoxRow);
}
extern "C" {
pub fn gtk_list_box_row_is_selected(row: *mut GtkListBoxRow) -> gboolean;
}
extern "C" {
pub fn gtk_list_box_row_set_selectable(row: *mut GtkListBoxRow, selectable: gboolean);
}
extern "C" {
pub fn gtk_list_box_row_get_selectable(row: *mut GtkListBoxRow) -> gboolean;
}
extern "C" {
pub fn gtk_list_box_row_set_activatable(row: *mut GtkListBoxRow, activatable: gboolean);
}
extern "C" {
pub fn gtk_list_box_row_get_activatable(row: *mut GtkListBoxRow) -> gboolean;
}
extern "C" {
pub fn gtk_list_box_get_type() -> GType;
}
extern "C" {
pub fn gtk_list_box_prepend(box_: *mut GtkListBox, child: *mut GtkWidget);
}
extern "C" {
pub fn gtk_list_box_insert(box_: *mut GtkListBox, child: *mut GtkWidget, position: gint);
}
extern "C" {
pub fn gtk_list_box_get_selected_row(box_: *mut GtkListBox) -> *mut GtkListBoxRow;
}
extern "C" {
pub fn gtk_list_box_get_row_at_index(box_: *mut GtkListBox, index_: gint)
-> *mut GtkListBoxRow;
}
extern "C" {
pub fn gtk_list_box_get_row_at_y(box_: *mut GtkListBox, y: gint) -> *mut GtkListBoxRow;
}
extern "C" {
pub fn gtk_list_box_select_row(box_: *mut GtkListBox, row: *mut GtkListBoxRow);
}
extern "C" {
pub fn gtk_list_box_set_placeholder(box_: *mut GtkListBox, placeholder: *mut GtkWidget);
}
extern "C" {
pub fn gtk_list_box_set_adjustment(box_: *mut GtkListBox, adjustment: *mut GtkAdjustment);
}
extern "C" {
pub fn gtk_list_box_get_adjustment(box_: *mut GtkListBox) -> *mut GtkAdjustment;
}
pub type GtkListBoxForeachFunc = ::std::option::Option<
unsafe extern "C" fn(box_: *mut GtkListBox, row: *mut GtkListBoxRow, user_data: gpointer),
>;
extern "C" {
pub fn gtk_list_box_selected_foreach(
box_: *mut GtkListBox,
func: GtkListBoxForeachFunc,
data: gpointer,
);
}
extern "C" {
pub fn gtk_list_box_get_selected_rows(box_: *mut GtkListBox) -> *mut GList;
}
extern "C" {
pub fn gtk_list_box_unselect_row(box_: *mut GtkListBox, row: *mut GtkListBoxRow);
}
extern "C" {
pub fn gtk_list_box_select_all(box_: *mut GtkListBox);
}
extern "C" {
pub fn gtk_list_box_unselect_all(box_: *mut GtkListBox);
}
extern "C" {
pub fn gtk_list_box_set_selection_mode(box_: *mut GtkListBox, mode: GtkSelectionMode);
}
extern "C" {
pub fn gtk_list_box_get_selection_mode(box_: *mut GtkListBox) -> GtkSelectionMode;
}
extern "C" {
pub fn gtk_list_box_set_filter_func(
box_: *mut GtkListBox,
filter_func: GtkListBoxFilterFunc,
user_data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_list_box_set_header_func(
box_: *mut GtkListBox,
update_header: GtkListBoxUpdateHeaderFunc,
user_data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_list_box_invalidate_filter(box_: *mut GtkListBox);
}
extern "C" {
pub fn gtk_list_box_invalidate_sort(box_: *mut GtkListBox);
}
extern "C" {
pub fn gtk_list_box_invalidate_headers(box_: *mut GtkListBox);
}
extern "C" {
pub fn gtk_list_box_set_sort_func(
box_: *mut GtkListBox,
sort_func: GtkListBoxSortFunc,
user_data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_list_box_set_activate_on_single_click(box_: *mut GtkListBox, single: gboolean);
}
extern "C" {
pub fn gtk_list_box_get_activate_on_single_click(box_: *mut GtkListBox) -> gboolean;
}
extern "C" {
pub fn gtk_list_box_drag_unhighlight_row(box_: *mut GtkListBox);
}
extern "C" {
pub fn gtk_list_box_drag_highlight_row(box_: *mut GtkListBox, row: *mut GtkListBoxRow);
}
extern "C" {
pub fn gtk_list_box_new() -> *mut GtkWidget;
}
pub type GtkLockButton = _GtkLockButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkLockButtonPrivate {
_unused: [u8; 0],
}
pub type GtkLockButtonPrivate = _GtkLockButtonPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkLockButton {
pub parent: GtkButton,
pub priv_: *mut GtkLockButtonPrivate,
}
#[test]
fn bindgen_test_layout__GtkLockButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkLockButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkLockButton>(),
64usize,
concat!("Size of: ", stringify!(_GtkLockButton))
);
assert_eq!(
::std::mem::align_of::<_GtkLockButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkLockButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkLockButton),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkLockButton),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkLockButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_lock_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_lock_button_new(permission: *mut GPermission) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_lock_button_get_permission(button: *mut GtkLockButton) -> *mut GPermission;
}
extern "C" {
pub fn gtk_lock_button_set_permission(button: *mut GtkLockButton, permission: *mut GPermission);
}
#[doc = " GtkKeySnoopFunc:\n @grab_widget: the widget to which the event will be delivered\n @event: the key event\n @func_data: (closure): data supplied to gtk_key_snooper_install()\n\n Key snooper functions are called before normal event delivery.\n They can be used to implement custom key event handling.\n\n Returns: %TRUE to stop further processing of @event, %FALSE to continue."]
pub type GtkKeySnoopFunc = ::std::option::Option<
unsafe extern "C" fn(
grab_widget: *mut GtkWidget,
event: *mut GdkEventKey,
func_data: gpointer,
) -> gint,
>;
extern "C" {
pub fn gtk_get_major_version() -> guint;
}
extern "C" {
pub fn gtk_get_minor_version() -> guint;
}
extern "C" {
pub fn gtk_get_micro_version() -> guint;
}
extern "C" {
pub fn gtk_get_binary_age() -> guint;
}
extern "C" {
pub fn gtk_get_interface_age() -> guint;
}
extern "C" {
pub fn gtk_check_version(
required_major: guint,
required_minor: guint,
required_micro: guint,
) -> *const gchar;
}
extern "C" {
pub fn gtk_parse_args(
argc: *mut ::std::os::raw::c_int,
argv: *mut *mut *mut ::std::os::raw::c_char,
) -> gboolean;
}
extern "C" {
pub fn gtk_init(argc: *mut ::std::os::raw::c_int, argv: *mut *mut *mut ::std::os::raw::c_char);
}
extern "C" {
pub fn gtk_init_check(
argc: *mut ::std::os::raw::c_int,
argv: *mut *mut *mut ::std::os::raw::c_char,
) -> gboolean;
}
extern "C" {
pub fn gtk_init_with_args(
argc: *mut gint,
argv: *mut *mut *mut gchar,
parameter_string: *const gchar,
entries: *const GOptionEntry,
translation_domain: *const gchar,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_get_option_group(open_default_display: gboolean) -> *mut GOptionGroup;
}
extern "C" {
pub fn gtk_disable_setlocale();
}
extern "C" {
pub fn gtk_get_default_language() -> *mut PangoLanguage;
}
extern "C" {
pub fn gtk_get_locale_direction() -> GtkTextDirection;
}
extern "C" {
pub fn gtk_events_pending() -> gboolean;
}
extern "C" {
pub fn gtk_main_do_event(event: *mut GdkEvent);
}
extern "C" {
pub fn gtk_main();
}
extern "C" {
pub fn gtk_main_level() -> guint;
}
extern "C" {
pub fn gtk_main_quit();
}
extern "C" {
pub fn gtk_main_iteration() -> gboolean;
}
extern "C" {
pub fn gtk_main_iteration_do(blocking: gboolean) -> gboolean;
}
extern "C" {
pub fn gtk_true() -> gboolean;
}
extern "C" {
pub fn gtk_false() -> gboolean;
}
extern "C" {
pub fn gtk_grab_add(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_grab_get_current() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_grab_remove(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_device_grab_add(
widget: *mut GtkWidget,
device: *mut GdkDevice,
block_others: gboolean,
);
}
extern "C" {
pub fn gtk_device_grab_remove(widget: *mut GtkWidget, device: *mut GdkDevice);
}
extern "C" {
pub fn gtk_key_snooper_install(snooper: GtkKeySnoopFunc, func_data: gpointer) -> guint;
}
extern "C" {
pub fn gtk_key_snooper_remove(snooper_handler_id: guint);
}
extern "C" {
pub fn gtk_get_current_event() -> *mut GdkEvent;
}
extern "C" {
pub fn gtk_get_current_event_time() -> guint32;
}
extern "C" {
pub fn gtk_get_current_event_state(state: *mut GdkModifierType) -> gboolean;
}
extern "C" {
pub fn gtk_get_current_event_device() -> *mut GdkDevice;
}
extern "C" {
pub fn gtk_get_event_widget(event: *mut GdkEvent) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_propagate_event(widget: *mut GtkWidget, event: *mut GdkEvent);
}
pub type GtkMenuBar = _GtkMenuBar;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMenuBarPrivate {
_unused: [u8; 0],
}
pub type GtkMenuBarPrivate = _GtkMenuBarPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMenuBar {
pub menu_shell: GtkMenuShell,
pub priv_: *mut GtkMenuBarPrivate,
}
#[test]
fn bindgen_test_layout__GtkMenuBar() {
const UNINIT: ::std::mem::MaybeUninit<_GtkMenuBar> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkMenuBar>(),
56usize,
concat!("Size of: ", stringify!(_GtkMenuBar))
);
assert_eq!(
::std::mem::align_of::<_GtkMenuBar>(),
8usize,
concat!("Alignment of ", stringify!(_GtkMenuBar))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).menu_shell) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkMenuBar),
"::",
stringify!(menu_shell)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkMenuBar),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkMenuBar {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_menu_bar_get_type() -> GType;
}
extern "C" {
pub fn gtk_menu_bar_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_menu_bar_new_from_model(model: *mut GMenuModel) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_menu_bar_get_pack_direction(menubar: *mut GtkMenuBar) -> GtkPackDirection;
}
extern "C" {
pub fn gtk_menu_bar_set_pack_direction(menubar: *mut GtkMenuBar, pack_dir: GtkPackDirection);
}
extern "C" {
pub fn gtk_menu_bar_get_child_pack_direction(menubar: *mut GtkMenuBar) -> GtkPackDirection;
}
extern "C" {
pub fn gtk_menu_bar_set_child_pack_direction(
menubar: *mut GtkMenuBar,
child_pack_dir: GtkPackDirection,
);
}
pub type GtkPopover = _GtkPopover;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkPopoverPrivate {
_unused: [u8; 0],
}
pub type GtkPopoverPrivate = _GtkPopoverPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkPopover {
pub parent_instance: GtkBin,
pub priv_: *mut GtkPopoverPrivate,
}
#[test]
fn bindgen_test_layout__GtkPopover() {
const UNINIT: ::std::mem::MaybeUninit<_GtkPopover> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkPopover>(),
56usize,
concat!("Size of: ", stringify!(_GtkPopover))
);
assert_eq!(
::std::mem::align_of::<_GtkPopover>(),
8usize,
concat!("Alignment of ", stringify!(_GtkPopover))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkPopover),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkPopover),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkPopover {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_popover_get_type() -> GType;
}
extern "C" {
pub fn gtk_popover_new(relative_to: *mut GtkWidget) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_popover_new_from_model(
relative_to: *mut GtkWidget,
model: *mut GMenuModel,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_popover_set_relative_to(popover: *mut GtkPopover, relative_to: *mut GtkWidget);
}
extern "C" {
pub fn gtk_popover_get_relative_to(popover: *mut GtkPopover) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_popover_set_pointing_to(popover: *mut GtkPopover, rect: *const GdkRectangle);
}
extern "C" {
pub fn gtk_popover_get_pointing_to(
popover: *mut GtkPopover,
rect: *mut GdkRectangle,
) -> gboolean;
}
extern "C" {
pub fn gtk_popover_set_position(popover: *mut GtkPopover, position: GtkPositionType);
}
extern "C" {
pub fn gtk_popover_get_position(popover: *mut GtkPopover) -> GtkPositionType;
}
extern "C" {
pub fn gtk_popover_set_modal(popover: *mut GtkPopover, modal: gboolean);
}
extern "C" {
pub fn gtk_popover_get_modal(popover: *mut GtkPopover) -> gboolean;
}
extern "C" {
pub fn gtk_popover_bind_model(
popover: *mut GtkPopover,
model: *mut GMenuModel,
action_namespace: *const gchar,
);
}
pub type GtkMenuButton = _GtkMenuButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMenuButtonPrivate {
_unused: [u8; 0],
}
pub type GtkMenuButtonPrivate = _GtkMenuButtonPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMenuButton {
pub parent: GtkToggleButton,
pub priv_: *mut GtkMenuButtonPrivate,
}
#[test]
fn bindgen_test_layout__GtkMenuButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkMenuButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkMenuButton>(),
72usize,
concat!("Size of: ", stringify!(_GtkMenuButton))
);
assert_eq!(
::std::mem::align_of::<_GtkMenuButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkMenuButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkMenuButton),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GtkMenuButton),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkMenuButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_menu_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_menu_button_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_menu_button_set_popup(menu_button: *mut GtkMenuButton, menu: *mut GtkWidget);
}
extern "C" {
pub fn gtk_menu_button_get_popup(menu_button: *mut GtkMenuButton) -> *mut GtkMenu;
}
extern "C" {
pub fn gtk_menu_button_set_popover(menu_button: *mut GtkMenuButton, popover: *mut GtkWidget);
}
extern "C" {
pub fn gtk_menu_button_get_popover(menu_button: *mut GtkMenuButton) -> *mut GtkPopover;
}
extern "C" {
pub fn gtk_menu_button_set_direction(menu_button: *mut GtkMenuButton, direction: GtkArrowType);
}
extern "C" {
pub fn gtk_menu_button_get_direction(menu_button: *mut GtkMenuButton) -> GtkArrowType;
}
extern "C" {
pub fn gtk_menu_button_set_menu_model(
menu_button: *mut GtkMenuButton,
menu_model: *mut GMenuModel,
);
}
extern "C" {
pub fn gtk_menu_button_get_menu_model(menu_button: *mut GtkMenuButton) -> *mut GMenuModel;
}
extern "C" {
pub fn gtk_menu_button_set_align_widget(
menu_button: *mut GtkMenuButton,
align_widget: *mut GtkWidget,
);
}
extern "C" {
pub fn gtk_menu_button_get_align_widget(menu_button: *mut GtkMenuButton) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_menu_button_set_use_popover(menu_button: *mut GtkMenuButton, use_popover: gboolean);
}
extern "C" {
pub fn gtk_menu_button_get_use_popover(menu_button: *mut GtkMenuButton) -> gboolean;
}
pub type GtkSizeGroup = _GtkSizeGroup;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkSizeGroupPrivate {
_unused: [u8; 0],
}
pub type GtkSizeGroupPrivate = _GtkSizeGroupPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkSizeGroup {
pub parent_instance: GObject,
pub priv_: *mut GtkSizeGroupPrivate,
}
#[test]
fn bindgen_test_layout__GtkSizeGroup() {
const UNINIT: ::std::mem::MaybeUninit<_GtkSizeGroup> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkSizeGroup>(),
32usize,
concat!("Size of: ", stringify!(_GtkSizeGroup))
);
assert_eq!(
::std::mem::align_of::<_GtkSizeGroup>(),
8usize,
concat!("Alignment of ", stringify!(_GtkSizeGroup))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkSizeGroup),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkSizeGroup),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkSizeGroup {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_size_group_get_type() -> GType;
}
extern "C" {
pub fn gtk_size_group_new(mode: GtkSizeGroupMode) -> *mut GtkSizeGroup;
}
extern "C" {
pub fn gtk_size_group_set_mode(size_group: *mut GtkSizeGroup, mode: GtkSizeGroupMode);
}
extern "C" {
pub fn gtk_size_group_get_mode(size_group: *mut GtkSizeGroup) -> GtkSizeGroupMode;
}
extern "C" {
pub fn gtk_size_group_set_ignore_hidden(size_group: *mut GtkSizeGroup, ignore_hidden: gboolean);
}
extern "C" {
pub fn gtk_size_group_get_ignore_hidden(size_group: *mut GtkSizeGroup) -> gboolean;
}
extern "C" {
pub fn gtk_size_group_add_widget(size_group: *mut GtkSizeGroup, widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_size_group_remove_widget(size_group: *mut GtkSizeGroup, widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_size_group_get_widgets(size_group: *mut GtkSizeGroup) -> *mut GSList;
}
pub type GtkToolItem = _GtkToolItem;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToolItemPrivate {
_unused: [u8; 0],
}
pub type GtkToolItemPrivate = _GtkToolItemPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToolItem {
pub parent: GtkBin,
pub priv_: *mut GtkToolItemPrivate,
}
#[test]
fn bindgen_test_layout__GtkToolItem() {
const UNINIT: ::std::mem::MaybeUninit<_GtkToolItem> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkToolItem>(),
56usize,
concat!("Size of: ", stringify!(_GtkToolItem))
);
assert_eq!(
::std::mem::align_of::<_GtkToolItem>(),
8usize,
concat!("Alignment of ", stringify!(_GtkToolItem))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkToolItem),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkToolItem),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkToolItem {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_tool_item_get_type() -> GType;
}
extern "C" {
pub fn gtk_tool_item_new() -> *mut GtkToolItem;
}
extern "C" {
pub fn gtk_tool_item_set_homogeneous(tool_item: *mut GtkToolItem, homogeneous: gboolean);
}
extern "C" {
pub fn gtk_tool_item_get_homogeneous(tool_item: *mut GtkToolItem) -> gboolean;
}
extern "C" {
pub fn gtk_tool_item_set_expand(tool_item: *mut GtkToolItem, expand: gboolean);
}
extern "C" {
pub fn gtk_tool_item_get_expand(tool_item: *mut GtkToolItem) -> gboolean;
}
extern "C" {
pub fn gtk_tool_item_set_tooltip_text(tool_item: *mut GtkToolItem, text: *const gchar);
}
extern "C" {
pub fn gtk_tool_item_set_tooltip_markup(tool_item: *mut GtkToolItem, markup: *const gchar);
}
extern "C" {
pub fn gtk_tool_item_set_use_drag_window(
tool_item: *mut GtkToolItem,
use_drag_window: gboolean,
);
}
extern "C" {
pub fn gtk_tool_item_get_use_drag_window(tool_item: *mut GtkToolItem) -> gboolean;
}
extern "C" {
pub fn gtk_tool_item_set_visible_horizontal(
tool_item: *mut GtkToolItem,
visible_horizontal: gboolean,
);
}
extern "C" {
pub fn gtk_tool_item_get_visible_horizontal(tool_item: *mut GtkToolItem) -> gboolean;
}
extern "C" {
pub fn gtk_tool_item_set_visible_vertical(
tool_item: *mut GtkToolItem,
visible_vertical: gboolean,
);
}
extern "C" {
pub fn gtk_tool_item_get_visible_vertical(tool_item: *mut GtkToolItem) -> gboolean;
}
extern "C" {
pub fn gtk_tool_item_get_is_important(tool_item: *mut GtkToolItem) -> gboolean;
}
extern "C" {
pub fn gtk_tool_item_set_is_important(tool_item: *mut GtkToolItem, is_important: gboolean);
}
extern "C" {
pub fn gtk_tool_item_get_ellipsize_mode(tool_item: *mut GtkToolItem) -> PangoEllipsizeMode;
}
extern "C" {
pub fn gtk_tool_item_get_icon_size(tool_item: *mut GtkToolItem) -> GtkIconSize;
}
extern "C" {
pub fn gtk_tool_item_get_orientation(tool_item: *mut GtkToolItem) -> GtkOrientation;
}
extern "C" {
pub fn gtk_tool_item_get_toolbar_style(tool_item: *mut GtkToolItem) -> GtkToolbarStyle;
}
extern "C" {
pub fn gtk_tool_item_get_relief_style(tool_item: *mut GtkToolItem) -> GtkReliefStyle;
}
extern "C" {
pub fn gtk_tool_item_get_text_alignment(tool_item: *mut GtkToolItem) -> gfloat;
}
extern "C" {
pub fn gtk_tool_item_get_text_orientation(tool_item: *mut GtkToolItem) -> GtkOrientation;
}
extern "C" {
pub fn gtk_tool_item_get_text_size_group(tool_item: *mut GtkToolItem) -> *mut GtkSizeGroup;
}
extern "C" {
pub fn gtk_tool_item_retrieve_proxy_menu_item(tool_item: *mut GtkToolItem) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_tool_item_get_proxy_menu_item(
tool_item: *mut GtkToolItem,
menu_item_id: *const gchar,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_tool_item_set_proxy_menu_item(
tool_item: *mut GtkToolItem,
menu_item_id: *const gchar,
menu_item: *mut GtkWidget,
);
}
extern "C" {
pub fn gtk_tool_item_rebuild_menu(tool_item: *mut GtkToolItem);
}
extern "C" {
pub fn gtk_tool_item_toolbar_reconfigured(tool_item: *mut GtkToolItem);
}
pub type GtkToolButton = _GtkToolButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToolButtonPrivate {
_unused: [u8; 0],
}
pub type GtkToolButtonPrivate = _GtkToolButtonPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToolButton {
pub parent: GtkToolItem,
pub priv_: *mut GtkToolButtonPrivate,
}
#[test]
fn bindgen_test_layout__GtkToolButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkToolButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkToolButton>(),
64usize,
concat!("Size of: ", stringify!(_GtkToolButton))
);
assert_eq!(
::std::mem::align_of::<_GtkToolButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkToolButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkToolButton),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkToolButton),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkToolButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_tool_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_tool_button_new(
icon_widget: *mut GtkWidget,
label: *const gchar,
) -> *mut GtkToolItem;
}
extern "C" {
pub fn gtk_tool_button_new_from_stock(stock_id: *const gchar) -> *mut GtkToolItem;
}
extern "C" {
pub fn gtk_tool_button_set_label(button: *mut GtkToolButton, label: *const gchar);
}
extern "C" {
pub fn gtk_tool_button_get_label(button: *mut GtkToolButton) -> *const gchar;
}
extern "C" {
pub fn gtk_tool_button_set_use_underline(button: *mut GtkToolButton, use_underline: gboolean);
}
extern "C" {
pub fn gtk_tool_button_get_use_underline(button: *mut GtkToolButton) -> gboolean;
}
extern "C" {
pub fn gtk_tool_button_set_stock_id(button: *mut GtkToolButton, stock_id: *const gchar);
}
extern "C" {
pub fn gtk_tool_button_get_stock_id(button: *mut GtkToolButton) -> *const gchar;
}
extern "C" {
pub fn gtk_tool_button_set_icon_name(button: *mut GtkToolButton, icon_name: *const gchar);
}
extern "C" {
pub fn gtk_tool_button_get_icon_name(button: *mut GtkToolButton) -> *const gchar;
}
extern "C" {
pub fn gtk_tool_button_set_icon_widget(button: *mut GtkToolButton, icon_widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_tool_button_get_icon_widget(button: *mut GtkToolButton) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_tool_button_set_label_widget(
button: *mut GtkToolButton,
label_widget: *mut GtkWidget,
);
}
extern "C" {
pub fn gtk_tool_button_get_label_widget(button: *mut GtkToolButton) -> *mut GtkWidget;
}
pub type GtkMenuToolButton = _GtkMenuToolButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMenuToolButtonPrivate {
_unused: [u8; 0],
}
pub type GtkMenuToolButtonPrivate = _GtkMenuToolButtonPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMenuToolButton {
pub parent: GtkToolButton,
pub priv_: *mut GtkMenuToolButtonPrivate,
}
#[test]
fn bindgen_test_layout__GtkMenuToolButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkMenuToolButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkMenuToolButton>(),
72usize,
concat!("Size of: ", stringify!(_GtkMenuToolButton))
);
assert_eq!(
::std::mem::align_of::<_GtkMenuToolButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkMenuToolButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkMenuToolButton),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GtkMenuToolButton),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkMenuToolButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_menu_tool_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_menu_tool_button_new(
icon_widget: *mut GtkWidget,
label: *const gchar,
) -> *mut GtkToolItem;
}
extern "C" {
pub fn gtk_menu_tool_button_new_from_stock(stock_id: *const gchar) -> *mut GtkToolItem;
}
extern "C" {
pub fn gtk_menu_tool_button_set_menu(button: *mut GtkMenuToolButton, menu: *mut GtkWidget);
}
extern "C" {
pub fn gtk_menu_tool_button_get_menu(button: *mut GtkMenuToolButton) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_menu_tool_button_set_arrow_tooltip_text(
button: *mut GtkMenuToolButton,
text: *const gchar,
);
}
extern "C" {
pub fn gtk_menu_tool_button_set_arrow_tooltip_markup(
button: *mut GtkMenuToolButton,
markup: *const gchar,
);
}
pub type GtkMessageDialog = _GtkMessageDialog;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMessageDialogPrivate {
_unused: [u8; 0],
}
pub type GtkMessageDialogPrivate = _GtkMessageDialogPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMessageDialog {
pub parent_instance: GtkDialog,
pub priv_: *mut GtkMessageDialogPrivate,
}
#[test]
fn bindgen_test_layout__GtkMessageDialog() {
const UNINIT: ::std::mem::MaybeUninit<_GtkMessageDialog> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkMessageDialog>(),
72usize,
concat!("Size of: ", stringify!(_GtkMessageDialog))
);
assert_eq!(
::std::mem::align_of::<_GtkMessageDialog>(),
8usize,
concat!("Alignment of ", stringify!(_GtkMessageDialog))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkMessageDialog),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GtkMessageDialog),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkMessageDialog {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const GtkButtonsType_GTK_BUTTONS_NONE: GtkButtonsType = 0;
pub const GtkButtonsType_GTK_BUTTONS_OK: GtkButtonsType = 1;
pub const GtkButtonsType_GTK_BUTTONS_CLOSE: GtkButtonsType = 2;
pub const GtkButtonsType_GTK_BUTTONS_CANCEL: GtkButtonsType = 3;
pub const GtkButtonsType_GTK_BUTTONS_YES_NO: GtkButtonsType = 4;
pub const GtkButtonsType_GTK_BUTTONS_OK_CANCEL: GtkButtonsType = 5;
#[doc = " GtkButtonsType:\n @GTK_BUTTONS_NONE: no buttons at all\n @GTK_BUTTONS_OK: an OK button\n @GTK_BUTTONS_CLOSE: a Close button\n @GTK_BUTTONS_CANCEL: a Cancel button\n @GTK_BUTTONS_YES_NO: Yes and No buttons\n @GTK_BUTTONS_OK_CANCEL: OK and Cancel buttons\n\n Prebuilt sets of buttons for the dialog. If\n none of these choices are appropriate, simply use %GTK_BUTTONS_NONE\n then call gtk_dialog_add_buttons().\n\n > Please note that %GTK_BUTTONS_OK, %GTK_BUTTONS_YES_NO\n > and %GTK_BUTTONS_OK_CANCEL are discouraged by the\n > [GNOME Human Interface Guidelines](http://library.gnome.org/devel/hig-book/stable/)."]
pub type GtkButtonsType = ::std::os::raw::c_uint;
extern "C" {
pub fn gtk_message_dialog_get_type() -> GType;
}
extern "C" {
pub fn gtk_message_dialog_new(
parent: *mut GtkWindow,
flags: GtkDialogFlags,
type_: GtkMessageType,
buttons: GtkButtonsType,
message_format: *const gchar,
...
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_message_dialog_new_with_markup(
parent: *mut GtkWindow,
flags: GtkDialogFlags,
type_: GtkMessageType,
buttons: GtkButtonsType,
message_format: *const gchar,
...
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_message_dialog_set_image(dialog: *mut GtkMessageDialog, image: *mut GtkWidget);
}
extern "C" {
pub fn gtk_message_dialog_get_image(dialog: *mut GtkMessageDialog) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_message_dialog_set_markup(message_dialog: *mut GtkMessageDialog, str_: *const gchar);
}
extern "C" {
pub fn gtk_message_dialog_format_secondary_text(
message_dialog: *mut GtkMessageDialog,
message_format: *const gchar,
...
);
}
extern "C" {
pub fn gtk_message_dialog_format_secondary_markup(
message_dialog: *mut GtkMessageDialog,
message_format: *const gchar,
...
);
}
extern "C" {
pub fn gtk_message_dialog_get_message_area(
message_dialog: *mut GtkMessageDialog,
) -> *mut GtkWidget;
}
#[doc = " GtkMountOperation:\n\n This should not be accessed directly. Use the accessor functions below."]
pub type GtkMountOperation = _GtkMountOperation;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMountOperationPrivate {
_unused: [u8; 0],
}
pub type GtkMountOperationPrivate = _GtkMountOperationPrivate;
#[doc = " GtkMountOperation:\n\n This should not be accessed directly. Use the accessor functions below."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMountOperation {
pub parent_instance: GMountOperation,
pub priv_: *mut GtkMountOperationPrivate,
}
#[test]
fn bindgen_test_layout__GtkMountOperation() {
const UNINIT: ::std::mem::MaybeUninit<_GtkMountOperation> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkMountOperation>(),
40usize,
concat!("Size of: ", stringify!(_GtkMountOperation))
);
assert_eq!(
::std::mem::align_of::<_GtkMountOperation>(),
8usize,
concat!("Alignment of ", stringify!(_GtkMountOperation))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkMountOperation),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkMountOperation),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkMountOperation {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_mount_operation_get_type() -> GType;
}
extern "C" {
pub fn gtk_mount_operation_new(parent: *mut GtkWindow) -> *mut GMountOperation;
}
extern "C" {
pub fn gtk_mount_operation_is_showing(op: *mut GtkMountOperation) -> gboolean;
}
extern "C" {
pub fn gtk_mount_operation_set_parent(op: *mut GtkMountOperation, parent: *mut GtkWindow);
}
extern "C" {
pub fn gtk_mount_operation_get_parent(op: *mut GtkMountOperation) -> *mut GtkWindow;
}
extern "C" {
pub fn gtk_mount_operation_set_screen(op: *mut GtkMountOperation, screen: *mut GdkScreen);
}
extern "C" {
pub fn gtk_mount_operation_get_screen(op: *mut GtkMountOperation) -> *mut GdkScreen;
}
pub type GtkNotebook = _GtkNotebook;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkNotebookPrivate {
_unused: [u8; 0],
}
pub type GtkNotebookPrivate = _GtkNotebookPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkNotebook {
pub container: GtkContainer,
pub priv_: *mut GtkNotebookPrivate,
}
#[test]
fn bindgen_test_layout__GtkNotebook() {
const UNINIT: ::std::mem::MaybeUninit<_GtkNotebook> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkNotebook>(),
48usize,
concat!("Size of: ", stringify!(_GtkNotebook))
);
assert_eq!(
::std::mem::align_of::<_GtkNotebook>(),
8usize,
concat!("Alignment of ", stringify!(_GtkNotebook))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).container) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkNotebook),
"::",
stringify!(container)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkNotebook),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkNotebook {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
#[doc = " Creation, insertion, deletion *"]
pub fn gtk_notebook_get_type() -> GType;
}
extern "C" {
pub fn gtk_notebook_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_notebook_append_page(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
tab_label: *mut GtkWidget,
) -> gint;
}
extern "C" {
pub fn gtk_notebook_append_page_menu(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
tab_label: *mut GtkWidget,
menu_label: *mut GtkWidget,
) -> gint;
}
extern "C" {
pub fn gtk_notebook_prepend_page(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
tab_label: *mut GtkWidget,
) -> gint;
}
extern "C" {
pub fn gtk_notebook_prepend_page_menu(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
tab_label: *mut GtkWidget,
menu_label: *mut GtkWidget,
) -> gint;
}
extern "C" {
pub fn gtk_notebook_insert_page(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
tab_label: *mut GtkWidget,
position: gint,
) -> gint;
}
extern "C" {
pub fn gtk_notebook_insert_page_menu(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
tab_label: *mut GtkWidget,
menu_label: *mut GtkWidget,
position: gint,
) -> gint;
}
extern "C" {
pub fn gtk_notebook_remove_page(notebook: *mut GtkNotebook, page_num: gint);
}
extern "C" {
#[doc = " Tabs drag and drop *"]
pub fn gtk_notebook_set_group_name(notebook: *mut GtkNotebook, group_name: *const gchar);
}
extern "C" {
pub fn gtk_notebook_get_group_name(notebook: *mut GtkNotebook) -> *const gchar;
}
extern "C" {
#[doc = " query, set current NotebookPage *"]
pub fn gtk_notebook_get_current_page(notebook: *mut GtkNotebook) -> gint;
}
extern "C" {
pub fn gtk_notebook_get_nth_page(notebook: *mut GtkNotebook, page_num: gint) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_notebook_get_n_pages(notebook: *mut GtkNotebook) -> gint;
}
extern "C" {
pub fn gtk_notebook_page_num(notebook: *mut GtkNotebook, child: *mut GtkWidget) -> gint;
}
extern "C" {
pub fn gtk_notebook_set_current_page(notebook: *mut GtkNotebook, page_num: gint);
}
extern "C" {
pub fn gtk_notebook_next_page(notebook: *mut GtkNotebook);
}
extern "C" {
pub fn gtk_notebook_prev_page(notebook: *mut GtkNotebook);
}
extern "C" {
#[doc = " set Notebook, NotebookTab style *"]
pub fn gtk_notebook_set_show_border(notebook: *mut GtkNotebook, show_border: gboolean);
}
extern "C" {
pub fn gtk_notebook_get_show_border(notebook: *mut GtkNotebook) -> gboolean;
}
extern "C" {
pub fn gtk_notebook_set_show_tabs(notebook: *mut GtkNotebook, show_tabs: gboolean);
}
extern "C" {
pub fn gtk_notebook_get_show_tabs(notebook: *mut GtkNotebook) -> gboolean;
}
extern "C" {
pub fn gtk_notebook_set_tab_pos(notebook: *mut GtkNotebook, pos: GtkPositionType);
}
extern "C" {
pub fn gtk_notebook_get_tab_pos(notebook: *mut GtkNotebook) -> GtkPositionType;
}
extern "C" {
pub fn gtk_notebook_set_scrollable(notebook: *mut GtkNotebook, scrollable: gboolean);
}
extern "C" {
pub fn gtk_notebook_get_scrollable(notebook: *mut GtkNotebook) -> gboolean;
}
extern "C" {
pub fn gtk_notebook_get_tab_hborder(notebook: *mut GtkNotebook) -> guint16;
}
extern "C" {
pub fn gtk_notebook_get_tab_vborder(notebook: *mut GtkNotebook) -> guint16;
}
extern "C" {
#[doc = " enable/disable PopupMenu *"]
pub fn gtk_notebook_popup_enable(notebook: *mut GtkNotebook);
}
extern "C" {
pub fn gtk_notebook_popup_disable(notebook: *mut GtkNotebook);
}
extern "C" {
#[doc = " query/set NotebookPage Properties *"]
pub fn gtk_notebook_get_tab_label(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_notebook_set_tab_label(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
tab_label: *mut GtkWidget,
);
}
extern "C" {
pub fn gtk_notebook_set_tab_label_text(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
tab_text: *const gchar,
);
}
extern "C" {
pub fn gtk_notebook_get_tab_label_text(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
) -> *const gchar;
}
extern "C" {
pub fn gtk_notebook_get_menu_label(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_notebook_set_menu_label(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
menu_label: *mut GtkWidget,
);
}
extern "C" {
pub fn gtk_notebook_set_menu_label_text(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
menu_text: *const gchar,
);
}
extern "C" {
pub fn gtk_notebook_get_menu_label_text(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
) -> *const gchar;
}
extern "C" {
pub fn gtk_notebook_reorder_child(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
position: gint,
);
}
extern "C" {
pub fn gtk_notebook_get_tab_reorderable(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
) -> gboolean;
}
extern "C" {
pub fn gtk_notebook_set_tab_reorderable(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
reorderable: gboolean,
);
}
extern "C" {
pub fn gtk_notebook_get_tab_detachable(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
) -> gboolean;
}
extern "C" {
pub fn gtk_notebook_set_tab_detachable(
notebook: *mut GtkNotebook,
child: *mut GtkWidget,
detachable: gboolean,
);
}
extern "C" {
pub fn gtk_notebook_get_action_widget(
notebook: *mut GtkNotebook,
pack_type: GtkPackType,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_notebook_set_action_widget(
notebook: *mut GtkNotebook,
widget: *mut GtkWidget,
pack_type: GtkPackType,
);
}
pub type GtkOffscreenWindow = _GtkOffscreenWindow;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkOffscreenWindow {
pub parent_object: GtkWindow,
}
#[test]
fn bindgen_test_layout__GtkOffscreenWindow() {
const UNINIT: ::std::mem::MaybeUninit<_GtkOffscreenWindow> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkOffscreenWindow>(),
56usize,
concat!("Size of: ", stringify!(_GtkOffscreenWindow))
);
assert_eq!(
::std::mem::align_of::<_GtkOffscreenWindow>(),
8usize,
concat!("Alignment of ", stringify!(_GtkOffscreenWindow))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_object) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkOffscreenWindow),
"::",
stringify!(parent_object)
)
);
}
impl Default for _GtkOffscreenWindow {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_offscreen_window_get_type() -> GType;
}
extern "C" {
pub fn gtk_offscreen_window_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_offscreen_window_get_surface(
offscreen: *mut GtkOffscreenWindow,
) -> *mut cairo_surface_t;
}
extern "C" {
pub fn gtk_offscreen_window_get_pixbuf(offscreen: *mut GtkOffscreenWindow) -> *mut GdkPixbuf;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkOrientable {
_unused: [u8; 0],
}
pub type GtkOrientable = _GtkOrientable;
extern "C" {
pub fn gtk_orientable_get_type() -> GType;
}
extern "C" {
pub fn gtk_orientable_set_orientation(
orientable: *mut GtkOrientable,
orientation: GtkOrientation,
);
}
extern "C" {
pub fn gtk_orientable_get_orientation(orientable: *mut GtkOrientable) -> GtkOrientation;
}
pub type GtkOverlay = _GtkOverlay;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkOverlayPrivate {
_unused: [u8; 0],
}
pub type GtkOverlayPrivate = _GtkOverlayPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkOverlay {
pub parent: GtkBin,
pub priv_: *mut GtkOverlayPrivate,
}
#[test]
fn bindgen_test_layout__GtkOverlay() {
const UNINIT: ::std::mem::MaybeUninit<_GtkOverlay> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkOverlay>(),
56usize,
concat!("Size of: ", stringify!(_GtkOverlay))
);
assert_eq!(
::std::mem::align_of::<_GtkOverlay>(),
8usize,
concat!("Alignment of ", stringify!(_GtkOverlay))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkOverlay),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkOverlay),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkOverlay {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_overlay_get_type() -> GType;
}
extern "C" {
pub fn gtk_overlay_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_overlay_add_overlay(overlay: *mut GtkOverlay, widget: *mut GtkWidget);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkPaperSize {
_unused: [u8; 0],
}
pub type GtkPaperSize = _GtkPaperSize;
extern "C" {
pub fn gtk_paper_size_get_type() -> GType;
}
extern "C" {
pub fn gtk_paper_size_new(name: *const gchar) -> *mut GtkPaperSize;
}
extern "C" {
pub fn gtk_paper_size_new_from_ppd(
ppd_name: *const gchar,
ppd_display_name: *const gchar,
width: gdouble,
height: gdouble,
) -> *mut GtkPaperSize;
}
extern "C" {
pub fn gtk_paper_size_new_custom(
name: *const gchar,
display_name: *const gchar,
width: gdouble,
height: gdouble,
unit: GtkUnit,
) -> *mut GtkPaperSize;
}
extern "C" {
pub fn gtk_paper_size_copy(other: *mut GtkPaperSize) -> *mut GtkPaperSize;
}
extern "C" {
pub fn gtk_paper_size_free(size: *mut GtkPaperSize);
}
extern "C" {
pub fn gtk_paper_size_is_equal(size1: *mut GtkPaperSize, size2: *mut GtkPaperSize) -> gboolean;
}
extern "C" {
pub fn gtk_paper_size_get_paper_sizes(include_custom: gboolean) -> *mut GList;
}
extern "C" {
pub fn gtk_paper_size_get_name(size: *mut GtkPaperSize) -> *const gchar;
}
extern "C" {
pub fn gtk_paper_size_get_display_name(size: *mut GtkPaperSize) -> *const gchar;
}
extern "C" {
pub fn gtk_paper_size_get_ppd_name(size: *mut GtkPaperSize) -> *const gchar;
}
extern "C" {
pub fn gtk_paper_size_get_width(size: *mut GtkPaperSize, unit: GtkUnit) -> gdouble;
}
extern "C" {
pub fn gtk_paper_size_get_height(size: *mut GtkPaperSize, unit: GtkUnit) -> gdouble;
}
extern "C" {
pub fn gtk_paper_size_is_custom(size: *mut GtkPaperSize) -> gboolean;
}
extern "C" {
pub fn gtk_paper_size_set_size(
size: *mut GtkPaperSize,
width: gdouble,
height: gdouble,
unit: GtkUnit,
);
}
extern "C" {
pub fn gtk_paper_size_get_default_top_margin(size: *mut GtkPaperSize, unit: GtkUnit)
-> gdouble;
}
extern "C" {
pub fn gtk_paper_size_get_default_bottom_margin(
size: *mut GtkPaperSize,
unit: GtkUnit,
) -> gdouble;
}
extern "C" {
pub fn gtk_paper_size_get_default_left_margin(
size: *mut GtkPaperSize,
unit: GtkUnit,
) -> gdouble;
}
extern "C" {
pub fn gtk_paper_size_get_default_right_margin(
size: *mut GtkPaperSize,
unit: GtkUnit,
) -> gdouble;
}
extern "C" {
pub fn gtk_paper_size_get_default() -> *const gchar;
}
extern "C" {
pub fn gtk_paper_size_new_from_key_file(
key_file: *mut GKeyFile,
group_name: *const gchar,
error: *mut *mut GError,
) -> *mut GtkPaperSize;
}
extern "C" {
pub fn gtk_paper_size_to_key_file(
size: *mut GtkPaperSize,
key_file: *mut GKeyFile,
group_name: *const gchar,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkPageSetup {
_unused: [u8; 0],
}
pub type GtkPageSetup = _GtkPageSetup;
extern "C" {
pub fn gtk_page_setup_get_type() -> GType;
}
extern "C" {
pub fn gtk_page_setup_new() -> *mut GtkPageSetup;
}
extern "C" {
pub fn gtk_page_setup_copy(other: *mut GtkPageSetup) -> *mut GtkPageSetup;
}
extern "C" {
pub fn gtk_page_setup_get_orientation(setup: *mut GtkPageSetup) -> GtkPageOrientation;
}
extern "C" {
pub fn gtk_page_setup_set_orientation(
setup: *mut GtkPageSetup,
orientation: GtkPageOrientation,
);
}
extern "C" {
pub fn gtk_page_setup_get_paper_size(setup: *mut GtkPageSetup) -> *mut GtkPaperSize;
}
extern "C" {
pub fn gtk_page_setup_set_paper_size(setup: *mut GtkPageSetup, size: *mut GtkPaperSize);
}
extern "C" {
pub fn gtk_page_setup_get_top_margin(setup: *mut GtkPageSetup, unit: GtkUnit) -> gdouble;
}
extern "C" {
pub fn gtk_page_setup_set_top_margin(setup: *mut GtkPageSetup, margin: gdouble, unit: GtkUnit);
}
extern "C" {
pub fn gtk_page_setup_get_bottom_margin(setup: *mut GtkPageSetup, unit: GtkUnit) -> gdouble;
}
extern "C" {
pub fn gtk_page_setup_set_bottom_margin(
setup: *mut GtkPageSetup,
margin: gdouble,
unit: GtkUnit,
);
}
extern "C" {
pub fn gtk_page_setup_get_left_margin(setup: *mut GtkPageSetup, unit: GtkUnit) -> gdouble;
}
extern "C" {
pub fn gtk_page_setup_set_left_margin(setup: *mut GtkPageSetup, margin: gdouble, unit: GtkUnit);
}
extern "C" {
pub fn gtk_page_setup_get_right_margin(setup: *mut GtkPageSetup, unit: GtkUnit) -> gdouble;
}
extern "C" {
pub fn gtk_page_setup_set_right_margin(
setup: *mut GtkPageSetup,
margin: gdouble,
unit: GtkUnit,
);
}
extern "C" {
pub fn gtk_page_setup_set_paper_size_and_default_margins(
setup: *mut GtkPageSetup,
size: *mut GtkPaperSize,
);
}
extern "C" {
pub fn gtk_page_setup_get_paper_width(setup: *mut GtkPageSetup, unit: GtkUnit) -> gdouble;
}
extern "C" {
pub fn gtk_page_setup_get_paper_height(setup: *mut GtkPageSetup, unit: GtkUnit) -> gdouble;
}
extern "C" {
pub fn gtk_page_setup_get_page_width(setup: *mut GtkPageSetup, unit: GtkUnit) -> gdouble;
}
extern "C" {
pub fn gtk_page_setup_get_page_height(setup: *mut GtkPageSetup, unit: GtkUnit) -> gdouble;
}
extern "C" {
pub fn gtk_page_setup_new_from_file(
file_name: *const gchar,
error: *mut *mut GError,
) -> *mut GtkPageSetup;
}
extern "C" {
pub fn gtk_page_setup_load_file(
setup: *mut GtkPageSetup,
file_name: *const ::std::os::raw::c_char,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_page_setup_to_file(
setup: *mut GtkPageSetup,
file_name: *const ::std::os::raw::c_char,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_page_setup_new_from_key_file(
key_file: *mut GKeyFile,
group_name: *const gchar,
error: *mut *mut GError,
) -> *mut GtkPageSetup;
}
extern "C" {
pub fn gtk_page_setup_load_key_file(
setup: *mut GtkPageSetup,
key_file: *mut GKeyFile,
group_name: *const gchar,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_page_setup_to_key_file(
setup: *mut GtkPageSetup,
key_file: *mut GKeyFile,
group_name: *const gchar,
);
}
pub type GtkPaned = _GtkPaned;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkPanedPrivate {
_unused: [u8; 0],
}
pub type GtkPanedPrivate = _GtkPanedPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkPaned {
pub container: GtkContainer,
pub priv_: *mut GtkPanedPrivate,
}
#[test]
fn bindgen_test_layout__GtkPaned() {
const UNINIT: ::std::mem::MaybeUninit<_GtkPaned> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkPaned>(),
48usize,
concat!("Size of: ", stringify!(_GtkPaned))
);
assert_eq!(
::std::mem::align_of::<_GtkPaned>(),
8usize,
concat!("Alignment of ", stringify!(_GtkPaned))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).container) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkPaned),
"::",
stringify!(container)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkPaned),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkPaned {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_paned_get_type() -> GType;
}
extern "C" {
pub fn gtk_paned_new(orientation: GtkOrientation) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_paned_add1(paned: *mut GtkPaned, child: *mut GtkWidget);
}
extern "C" {
pub fn gtk_paned_add2(paned: *mut GtkPaned, child: *mut GtkWidget);
}
extern "C" {
pub fn gtk_paned_pack1(
paned: *mut GtkPaned,
child: *mut GtkWidget,
resize: gboolean,
shrink: gboolean,
);
}
extern "C" {
pub fn gtk_paned_pack2(
paned: *mut GtkPaned,
child: *mut GtkWidget,
resize: gboolean,
shrink: gboolean,
);
}
extern "C" {
pub fn gtk_paned_get_position(paned: *mut GtkPaned) -> gint;
}
extern "C" {
pub fn gtk_paned_set_position(paned: *mut GtkPaned, position: gint);
}
extern "C" {
pub fn gtk_paned_get_child1(paned: *mut GtkPaned) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_paned_get_child2(paned: *mut GtkPaned) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_paned_get_handle_window(paned: *mut GtkPaned) -> *mut GdkWindow;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkPlacesSidebar {
_unused: [u8; 0],
}
pub type GtkPlacesSidebar = _GtkPlacesSidebar;
pub const GtkPlacesOpenFlags_GTK_PLACES_OPEN_NORMAL: GtkPlacesOpenFlags = 1;
pub const GtkPlacesOpenFlags_GTK_PLACES_OPEN_NEW_TAB: GtkPlacesOpenFlags = 2;
pub const GtkPlacesOpenFlags_GTK_PLACES_OPEN_NEW_WINDOW: GtkPlacesOpenFlags = 4;
#[doc = " GtkPlacesOpenFlags:\n @GTK_PLACES_OPEN_NORMAL: This is the default mode that #GtkPlacesSidebar uses if no other flags\n are specified. It indicates that the calling application should open the selected location\n in the normal way, for example, in the folder view beside the sidebar.\n @GTK_PLACES_OPEN_NEW_TAB: When passed to gtk_places_sidebar_set_open_flags(), this indicates\n that the application can open folders selected from the sidebar in new tabs. This value\n will be passed to the #GtkPlacesSidebar::open-location signal when the user selects\n that a location be opened in a new tab instead of in the standard fashion.\n @GTK_PLACES_OPEN_NEW_WINDOW: Similar to @GTK_PLACES_OPEN_NEW_TAB, but indicates that the application\n can open folders in new windows.\n\n These flags serve two purposes. First, the application can call gtk_places_sidebar_set_open_flags()\n using these flags as a bitmask. This tells the sidebar that the application is able to open\n folders selected from the sidebar in various ways, for example, in new tabs or in new windows in\n addition to the normal mode.\n\n Second, when one of these values gets passed back to the application in the\n #GtkPlacesSidebar::open-location signal, it means that the application should\n open the selected location in the normal way, in a new tab, or in a new\n window. The sidebar takes care of determining the desired way to open the location,\n based on the modifier keys that the user is pressing at the time the selection is made.\n\n If the application never calls gtk_places_sidebar_set_open_flags(), then the sidebar will only\n use #GTK_PLACES_OPEN_NORMAL in the #GtkPlacesSidebar::open-location signal. This is the\n default mode of operation."]
pub type GtkPlacesOpenFlags = ::std::os::raw::c_uint;
extern "C" {
pub fn gtk_places_sidebar_get_type() -> GType;
}
extern "C" {
pub fn gtk_places_sidebar_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_places_sidebar_get_open_flags(sidebar: *mut GtkPlacesSidebar) -> GtkPlacesOpenFlags;
}
extern "C" {
pub fn gtk_places_sidebar_set_open_flags(
sidebar: *mut GtkPlacesSidebar,
flags: GtkPlacesOpenFlags,
);
}
extern "C" {
pub fn gtk_places_sidebar_get_location(sidebar: *mut GtkPlacesSidebar) -> *mut GFile;
}
extern "C" {
pub fn gtk_places_sidebar_set_location(sidebar: *mut GtkPlacesSidebar, location: *mut GFile);
}
extern "C" {
pub fn gtk_places_sidebar_get_show_desktop(sidebar: *mut GtkPlacesSidebar) -> gboolean;
}
extern "C" {
pub fn gtk_places_sidebar_set_show_desktop(
sidebar: *mut GtkPlacesSidebar,
show_desktop: gboolean,
);
}
extern "C" {
pub fn gtk_places_sidebar_get_show_connect_to_server(
sidebar: *mut GtkPlacesSidebar,
) -> gboolean;
}
extern "C" {
pub fn gtk_places_sidebar_set_show_connect_to_server(
sidebar: *mut GtkPlacesSidebar,
show_connect_to_server: gboolean,
);
}
extern "C" {
pub fn gtk_places_sidebar_get_show_enter_location(sidebar: *mut GtkPlacesSidebar) -> gboolean;
}
extern "C" {
pub fn gtk_places_sidebar_set_show_enter_location(
sidebar: *mut GtkPlacesSidebar,
show_enter_location: gboolean,
);
}
extern "C" {
pub fn gtk_places_sidebar_set_local_only(sidebar: *mut GtkPlacesSidebar, local_only: gboolean);
}
extern "C" {
pub fn gtk_places_sidebar_get_local_only(sidebar: *mut GtkPlacesSidebar) -> gboolean;
}
extern "C" {
pub fn gtk_places_sidebar_add_shortcut(sidebar: *mut GtkPlacesSidebar, location: *mut GFile);
}
extern "C" {
pub fn gtk_places_sidebar_remove_shortcut(sidebar: *mut GtkPlacesSidebar, location: *mut GFile);
}
extern "C" {
pub fn gtk_places_sidebar_list_shortcuts(sidebar: *mut GtkPlacesSidebar) -> *mut GSList;
}
extern "C" {
pub fn gtk_places_sidebar_get_nth_bookmark(
sidebar: *mut GtkPlacesSidebar,
n: gint,
) -> *mut GFile;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkPrintContext {
_unused: [u8; 0],
}
pub type GtkPrintContext = _GtkPrintContext;
extern "C" {
pub fn gtk_print_context_get_type() -> GType;
}
extern "C" {
pub fn gtk_print_context_get_cairo_context(context: *mut GtkPrintContext) -> *mut cairo_t;
}
extern "C" {
pub fn gtk_print_context_get_page_setup(context: *mut GtkPrintContext) -> *mut GtkPageSetup;
}
extern "C" {
pub fn gtk_print_context_get_width(context: *mut GtkPrintContext) -> gdouble;
}
extern "C" {
pub fn gtk_print_context_get_height(context: *mut GtkPrintContext) -> gdouble;
}
extern "C" {
pub fn gtk_print_context_get_dpi_x(context: *mut GtkPrintContext) -> gdouble;
}
extern "C" {
pub fn gtk_print_context_get_dpi_y(context: *mut GtkPrintContext) -> gdouble;
}
extern "C" {
pub fn gtk_print_context_get_hard_margins(
context: *mut GtkPrintContext,
top: *mut gdouble,
bottom: *mut gdouble,
left: *mut gdouble,
right: *mut gdouble,
) -> gboolean;
}
extern "C" {
pub fn gtk_print_context_get_pango_fontmap(context: *mut GtkPrintContext) -> *mut PangoFontMap;
}
extern "C" {
pub fn gtk_print_context_create_pango_context(
context: *mut GtkPrintContext,
) -> *mut PangoContext;
}
extern "C" {
pub fn gtk_print_context_create_pango_layout(context: *mut GtkPrintContext)
-> *mut PangoLayout;
}
extern "C" {
pub fn gtk_print_context_set_cairo_context(
context: *mut GtkPrintContext,
cr: *mut cairo_t,
dpi_x: f64,
dpi_y: f64,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkPrintSettings {
_unused: [u8; 0],
}
pub type GtkPrintSettings = _GtkPrintSettings;
pub type GtkPrintSettingsFunc = ::std::option::Option<
unsafe extern "C" fn(key: *const gchar, value: *const gchar, user_data: gpointer),
>;
#[doc = " GtkPageRange:\n @start: start of page range.\n @end: end of page range.\n\n See also gtk_print_settings_set_page_ranges()."]
pub type GtkPageRange = _GtkPageRange;
#[doc = " GtkPageRange:\n @start: start of page range.\n @end: end of page range.\n\n See also gtk_print_settings_set_page_ranges()."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _GtkPageRange {
pub start: gint,
pub end: gint,
}
#[test]
fn bindgen_test_layout__GtkPageRange() {
const UNINIT: ::std::mem::MaybeUninit<_GtkPageRange> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkPageRange>(),
8usize,
concat!("Size of: ", stringify!(_GtkPageRange))
);
assert_eq!(
::std::mem::align_of::<_GtkPageRange>(),
4usize,
concat!("Alignment of ", stringify!(_GtkPageRange))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).start) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkPageRange),
"::",
stringify!(start)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_GtkPageRange),
"::",
stringify!(end)
)
);
}
extern "C" {
pub fn gtk_print_settings_get_type() -> GType;
}
extern "C" {
pub fn gtk_print_settings_new() -> *mut GtkPrintSettings;
}
extern "C" {
pub fn gtk_print_settings_copy(other: *mut GtkPrintSettings) -> *mut GtkPrintSettings;
}
extern "C" {
pub fn gtk_print_settings_new_from_file(
file_name: *const gchar,
error: *mut *mut GError,
) -> *mut GtkPrintSettings;
}
extern "C" {
pub fn gtk_print_settings_load_file(
settings: *mut GtkPrintSettings,
file_name: *const gchar,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_print_settings_to_file(
settings: *mut GtkPrintSettings,
file_name: *const gchar,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_print_settings_new_from_key_file(
key_file: *mut GKeyFile,
group_name: *const gchar,
error: *mut *mut GError,
) -> *mut GtkPrintSettings;
}
extern "C" {
pub fn gtk_print_settings_load_key_file(
settings: *mut GtkPrintSettings,
key_file: *mut GKeyFile,
group_name: *const gchar,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_print_settings_to_key_file(
settings: *mut GtkPrintSettings,
key_file: *mut GKeyFile,
group_name: *const gchar,
);
}
extern "C" {
pub fn gtk_print_settings_has_key(
settings: *mut GtkPrintSettings,
key: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_print_settings_get(
settings: *mut GtkPrintSettings,
key: *const gchar,
) -> *const gchar;
}
extern "C" {
pub fn gtk_print_settings_set(
settings: *mut GtkPrintSettings,
key: *const gchar,
value: *const gchar,
);
}
extern "C" {
pub fn gtk_print_settings_unset(settings: *mut GtkPrintSettings, key: *const gchar);
}
extern "C" {
pub fn gtk_print_settings_foreach(
settings: *mut GtkPrintSettings,
func: GtkPrintSettingsFunc,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_print_settings_get_bool(
settings: *mut GtkPrintSettings,
key: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_print_settings_set_bool(
settings: *mut GtkPrintSettings,
key: *const gchar,
value: gboolean,
);
}
extern "C" {
pub fn gtk_print_settings_get_double(
settings: *mut GtkPrintSettings,
key: *const gchar,
) -> gdouble;
}
extern "C" {
pub fn gtk_print_settings_get_double_with_default(
settings: *mut GtkPrintSettings,
key: *const gchar,
def: gdouble,
) -> gdouble;
}
extern "C" {
pub fn gtk_print_settings_set_double(
settings: *mut GtkPrintSettings,
key: *const gchar,
value: gdouble,
);
}
extern "C" {
pub fn gtk_print_settings_get_length(
settings: *mut GtkPrintSettings,
key: *const gchar,
unit: GtkUnit,
) -> gdouble;
}
extern "C" {
pub fn gtk_print_settings_set_length(
settings: *mut GtkPrintSettings,
key: *const gchar,
value: gdouble,
unit: GtkUnit,
);
}
extern "C" {
pub fn gtk_print_settings_get_int(settings: *mut GtkPrintSettings, key: *const gchar) -> gint;
}
extern "C" {
pub fn gtk_print_settings_get_int_with_default(
settings: *mut GtkPrintSettings,
key: *const gchar,
def: gint,
) -> gint;
}
extern "C" {
pub fn gtk_print_settings_set_int(
settings: *mut GtkPrintSettings,
key: *const gchar,
value: gint,
);
}
extern "C" {
pub fn gtk_print_settings_get_printer(settings: *mut GtkPrintSettings) -> *const gchar;
}
extern "C" {
pub fn gtk_print_settings_set_printer(settings: *mut GtkPrintSettings, printer: *const gchar);
}
extern "C" {
pub fn gtk_print_settings_get_orientation(
settings: *mut GtkPrintSettings,
) -> GtkPageOrientation;
}
extern "C" {
pub fn gtk_print_settings_set_orientation(
settings: *mut GtkPrintSettings,
orientation: GtkPageOrientation,
);
}
extern "C" {
pub fn gtk_print_settings_get_paper_size(settings: *mut GtkPrintSettings) -> *mut GtkPaperSize;
}
extern "C" {
pub fn gtk_print_settings_set_paper_size(
settings: *mut GtkPrintSettings,
paper_size: *mut GtkPaperSize,
);
}
extern "C" {
pub fn gtk_print_settings_get_paper_width(
settings: *mut GtkPrintSettings,
unit: GtkUnit,
) -> gdouble;
}
extern "C" {
pub fn gtk_print_settings_set_paper_width(
settings: *mut GtkPrintSettings,
width: gdouble,
unit: GtkUnit,
);
}
extern "C" {
pub fn gtk_print_settings_get_paper_height(
settings: *mut GtkPrintSettings,
unit: GtkUnit,
) -> gdouble;
}
extern "C" {
pub fn gtk_print_settings_set_paper_height(
settings: *mut GtkPrintSettings,
height: gdouble,
unit: GtkUnit,
);
}
extern "C" {
pub fn gtk_print_settings_get_use_color(settings: *mut GtkPrintSettings) -> gboolean;
}
extern "C" {
pub fn gtk_print_settings_set_use_color(settings: *mut GtkPrintSettings, use_color: gboolean);
}
extern "C" {
pub fn gtk_print_settings_get_collate(settings: *mut GtkPrintSettings) -> gboolean;
}
extern "C" {
pub fn gtk_print_settings_set_collate(settings: *mut GtkPrintSettings, collate: gboolean);
}
extern "C" {
pub fn gtk_print_settings_get_reverse(settings: *mut GtkPrintSettings) -> gboolean;
}
extern "C" {
pub fn gtk_print_settings_set_reverse(settings: *mut GtkPrintSettings, reverse: gboolean);
}
extern "C" {
pub fn gtk_print_settings_get_duplex(settings: *mut GtkPrintSettings) -> GtkPrintDuplex;
}
extern "C" {
pub fn gtk_print_settings_set_duplex(settings: *mut GtkPrintSettings, duplex: GtkPrintDuplex);
}
extern "C" {
pub fn gtk_print_settings_get_quality(settings: *mut GtkPrintSettings) -> GtkPrintQuality;
}
extern "C" {
pub fn gtk_print_settings_set_quality(
settings: *mut GtkPrintSettings,
quality: GtkPrintQuality,
);
}
extern "C" {
pub fn gtk_print_settings_get_n_copies(settings: *mut GtkPrintSettings) -> gint;
}
extern "C" {
pub fn gtk_print_settings_set_n_copies(settings: *mut GtkPrintSettings, num_copies: gint);
}
extern "C" {
pub fn gtk_print_settings_get_number_up(settings: *mut GtkPrintSettings) -> gint;
}
extern "C" {
pub fn gtk_print_settings_set_number_up(settings: *mut GtkPrintSettings, number_up: gint);
}
extern "C" {
pub fn gtk_print_settings_get_number_up_layout(
settings: *mut GtkPrintSettings,
) -> GtkNumberUpLayout;
}
extern "C" {
pub fn gtk_print_settings_set_number_up_layout(
settings: *mut GtkPrintSettings,
number_up_layout: GtkNumberUpLayout,
);
}
extern "C" {
pub fn gtk_print_settings_get_resolution(settings: *mut GtkPrintSettings) -> gint;
}
extern "C" {
pub fn gtk_print_settings_set_resolution(settings: *mut GtkPrintSettings, resolution: gint);
}
extern "C" {
pub fn gtk_print_settings_get_resolution_x(settings: *mut GtkPrintSettings) -> gint;
}
extern "C" {
pub fn gtk_print_settings_get_resolution_y(settings: *mut GtkPrintSettings) -> gint;
}
extern "C" {
pub fn gtk_print_settings_set_resolution_xy(
settings: *mut GtkPrintSettings,
resolution_x: gint,
resolution_y: gint,
);
}
extern "C" {
pub fn gtk_print_settings_get_printer_lpi(settings: *mut GtkPrintSettings) -> gdouble;
}
extern "C" {
pub fn gtk_print_settings_set_printer_lpi(settings: *mut GtkPrintSettings, lpi: gdouble);
}
extern "C" {
pub fn gtk_print_settings_get_scale(settings: *mut GtkPrintSettings) -> gdouble;
}
extern "C" {
pub fn gtk_print_settings_set_scale(settings: *mut GtkPrintSettings, scale: gdouble);
}
extern "C" {
pub fn gtk_print_settings_get_print_pages(settings: *mut GtkPrintSettings) -> GtkPrintPages;
}
extern "C" {
pub fn gtk_print_settings_set_print_pages(
settings: *mut GtkPrintSettings,
pages: GtkPrintPages,
);
}
extern "C" {
pub fn gtk_print_settings_get_page_ranges(
settings: *mut GtkPrintSettings,
num_ranges: *mut gint,
) -> *mut GtkPageRange;
}
extern "C" {
pub fn gtk_print_settings_set_page_ranges(
settings: *mut GtkPrintSettings,
page_ranges: *mut GtkPageRange,
num_ranges: gint,
);
}
extern "C" {
pub fn gtk_print_settings_get_page_set(settings: *mut GtkPrintSettings) -> GtkPageSet;
}
extern "C" {
pub fn gtk_print_settings_set_page_set(settings: *mut GtkPrintSettings, page_set: GtkPageSet);
}
extern "C" {
pub fn gtk_print_settings_get_default_source(settings: *mut GtkPrintSettings) -> *const gchar;
}
extern "C" {
pub fn gtk_print_settings_set_default_source(
settings: *mut GtkPrintSettings,
default_source: *const gchar,
);
}
extern "C" {
pub fn gtk_print_settings_get_media_type(settings: *mut GtkPrintSettings) -> *const gchar;
}
extern "C" {
pub fn gtk_print_settings_set_media_type(
settings: *mut GtkPrintSettings,
media_type: *const gchar,
);
}
extern "C" {
pub fn gtk_print_settings_get_dither(settings: *mut GtkPrintSettings) -> *const gchar;
}
extern "C" {
pub fn gtk_print_settings_set_dither(settings: *mut GtkPrintSettings, dither: *const gchar);
}
extern "C" {
pub fn gtk_print_settings_get_finishings(settings: *mut GtkPrintSettings) -> *const gchar;
}
extern "C" {
pub fn gtk_print_settings_set_finishings(
settings: *mut GtkPrintSettings,
finishings: *const gchar,
);
}
extern "C" {
pub fn gtk_print_settings_get_output_bin(settings: *mut GtkPrintSettings) -> *const gchar;
}
extern "C" {
pub fn gtk_print_settings_set_output_bin(
settings: *mut GtkPrintSettings,
output_bin: *const gchar,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkPrintOperationPreview {
_unused: [u8; 0],
}
pub type GtkPrintOperationPreview = _GtkPrintOperationPreview;
extern "C" {
pub fn gtk_print_operation_preview_get_type() -> GType;
}
extern "C" {
pub fn gtk_print_operation_preview_render_page(
preview: *mut GtkPrintOperationPreview,
page_nr: gint,
);
}
extern "C" {
pub fn gtk_print_operation_preview_end_preview(preview: *mut GtkPrintOperationPreview);
}
extern "C" {
pub fn gtk_print_operation_preview_is_selected(
preview: *mut GtkPrintOperationPreview,
page_nr: gint,
) -> gboolean;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkPrintOperationPrivate {
_unused: [u8; 0],
}
pub type GtkPrintOperationPrivate = _GtkPrintOperationPrivate;
pub type GtkPrintOperation = _GtkPrintOperation;
pub const GtkPrintStatus_GTK_PRINT_STATUS_INITIAL: GtkPrintStatus = 0;
pub const GtkPrintStatus_GTK_PRINT_STATUS_PREPARING: GtkPrintStatus = 1;
pub const GtkPrintStatus_GTK_PRINT_STATUS_GENERATING_DATA: GtkPrintStatus = 2;
pub const GtkPrintStatus_GTK_PRINT_STATUS_SENDING_DATA: GtkPrintStatus = 3;
pub const GtkPrintStatus_GTK_PRINT_STATUS_PENDING: GtkPrintStatus = 4;
pub const GtkPrintStatus_GTK_PRINT_STATUS_PENDING_ISSUE: GtkPrintStatus = 5;
pub const GtkPrintStatus_GTK_PRINT_STATUS_PRINTING: GtkPrintStatus = 6;
pub const GtkPrintStatus_GTK_PRINT_STATUS_FINISHED: GtkPrintStatus = 7;
pub const GtkPrintStatus_GTK_PRINT_STATUS_FINISHED_ABORTED: GtkPrintStatus = 8;
#[doc = " GtkPrintStatus:\n @GTK_PRINT_STATUS_INITIAL: The printing has not started yet; this\n status is set initially, and while the print dialog is shown.\n @GTK_PRINT_STATUS_PREPARING: This status is set while the begin-print\n signal is emitted and during pagination.\n @GTK_PRINT_STATUS_GENERATING_DATA: This status is set while the\n pages are being rendered.\n @GTK_PRINT_STATUS_SENDING_DATA: The print job is being sent off to the\n printer.\n @GTK_PRINT_STATUS_PENDING: The print job has been sent to the printer,\n but is not printed for some reason, e.g. the printer may be stopped.\n @GTK_PRINT_STATUS_PENDING_ISSUE: Some problem has occurred during\n printing, e.g. a paper jam.\n @GTK_PRINT_STATUS_PRINTING: The printer is processing the print job.\n @GTK_PRINT_STATUS_FINISHED: The printing has been completed successfully.\n @GTK_PRINT_STATUS_FINISHED_ABORTED: The printing has been aborted.\n\n The status gives a rough indication of the completion of a running\n print operation."]
pub type GtkPrintStatus = ::std::os::raw::c_uint;
pub const GtkPrintOperationResult_GTK_PRINT_OPERATION_RESULT_ERROR: GtkPrintOperationResult = 0;
pub const GtkPrintOperationResult_GTK_PRINT_OPERATION_RESULT_APPLY: GtkPrintOperationResult = 1;
pub const GtkPrintOperationResult_GTK_PRINT_OPERATION_RESULT_CANCEL: GtkPrintOperationResult = 2;
pub const GtkPrintOperationResult_GTK_PRINT_OPERATION_RESULT_IN_PROGRESS: GtkPrintOperationResult =
3;
#[doc = " GtkPrintOperationResult:\n @GTK_PRINT_OPERATION_RESULT_ERROR: An error has occured.\n @GTK_PRINT_OPERATION_RESULT_APPLY: The print settings should be stored.\n @GTK_PRINT_OPERATION_RESULT_CANCEL: The print operation has been canceled,\n the print settings should not be stored.\n @GTK_PRINT_OPERATION_RESULT_IN_PROGRESS: The print operation is not complete\n yet. This value will only be returned when running asynchronously.\n\n A value of this type is returned by gtk_print_operation_run()."]
pub type GtkPrintOperationResult = ::std::os::raw::c_uint;
pub const GtkPrintOperationAction_GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG: GtkPrintOperationAction =
0;
pub const GtkPrintOperationAction_GTK_PRINT_OPERATION_ACTION_PRINT: GtkPrintOperationAction = 1;
pub const GtkPrintOperationAction_GTK_PRINT_OPERATION_ACTION_PREVIEW: GtkPrintOperationAction = 2;
pub const GtkPrintOperationAction_GTK_PRINT_OPERATION_ACTION_EXPORT: GtkPrintOperationAction = 3;
#[doc = " GtkPrintOperationAction:\n @GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG: Show the print dialog.\n @GTK_PRINT_OPERATION_ACTION_PRINT: Start to print without showing\n the print dialog, based on the current print settings.\n @GTK_PRINT_OPERATION_ACTION_PREVIEW: Show the print preview.\n @GTK_PRINT_OPERATION_ACTION_EXPORT: Export to a file. This requires\n the export-filename property to be set.\n\n The @action parameter to gtk_print_operation_run()\n determines what action the print operation should perform."]
pub type GtkPrintOperationAction = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkPrintOperation {
pub parent_instance: GObject,
pub priv_: *mut GtkPrintOperationPrivate,
}
#[test]
fn bindgen_test_layout__GtkPrintOperation() {
const UNINIT: ::std::mem::MaybeUninit<_GtkPrintOperation> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkPrintOperation>(),
32usize,
concat!("Size of: ", stringify!(_GtkPrintOperation))
);
assert_eq!(
::std::mem::align_of::<_GtkPrintOperation>(),
8usize,
concat!("Alignment of ", stringify!(_GtkPrintOperation))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkPrintOperation),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkPrintOperation),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkPrintOperation {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_print_error_quark() -> GQuark;
}
extern "C" {
pub fn gtk_print_operation_get_type() -> GType;
}
extern "C" {
pub fn gtk_print_operation_new() -> *mut GtkPrintOperation;
}
extern "C" {
pub fn gtk_print_operation_set_default_page_setup(
op: *mut GtkPrintOperation,
default_page_setup: *mut GtkPageSetup,
);
}
extern "C" {
pub fn gtk_print_operation_get_default_page_setup(
op: *mut GtkPrintOperation,
) -> *mut GtkPageSetup;
}
extern "C" {
pub fn gtk_print_operation_set_print_settings(
op: *mut GtkPrintOperation,
print_settings: *mut GtkPrintSettings,
);
}
extern "C" {
pub fn gtk_print_operation_get_print_settings(
op: *mut GtkPrintOperation,
) -> *mut GtkPrintSettings;
}
extern "C" {
pub fn gtk_print_operation_set_job_name(op: *mut GtkPrintOperation, job_name: *const gchar);
}
extern "C" {
pub fn gtk_print_operation_set_n_pages(op: *mut GtkPrintOperation, n_pages: gint);
}
extern "C" {
pub fn gtk_print_operation_set_current_page(op: *mut GtkPrintOperation, current_page: gint);
}
extern "C" {
pub fn gtk_print_operation_set_use_full_page(op: *mut GtkPrintOperation, full_page: gboolean);
}
extern "C" {
pub fn gtk_print_operation_set_unit(op: *mut GtkPrintOperation, unit: GtkUnit);
}
extern "C" {
pub fn gtk_print_operation_set_export_filename(
op: *mut GtkPrintOperation,
filename: *const gchar,
);
}
extern "C" {
pub fn gtk_print_operation_set_track_print_status(
op: *mut GtkPrintOperation,
track_status: gboolean,
);
}
extern "C" {
pub fn gtk_print_operation_set_show_progress(
op: *mut GtkPrintOperation,
show_progress: gboolean,
);
}
extern "C" {
pub fn gtk_print_operation_set_allow_async(op: *mut GtkPrintOperation, allow_async: gboolean);
}
extern "C" {
pub fn gtk_print_operation_set_custom_tab_label(
op: *mut GtkPrintOperation,
label: *const gchar,
);
}
extern "C" {
pub fn gtk_print_operation_run(
op: *mut GtkPrintOperation,
action: GtkPrintOperationAction,
parent: *mut GtkWindow,
error: *mut *mut GError,
) -> GtkPrintOperationResult;
}
extern "C" {
pub fn gtk_print_operation_get_error(op: *mut GtkPrintOperation, error: *mut *mut GError);
}
extern "C" {
pub fn gtk_print_operation_get_status(op: *mut GtkPrintOperation) -> GtkPrintStatus;
}
extern "C" {
pub fn gtk_print_operation_get_status_string(op: *mut GtkPrintOperation) -> *const gchar;
}
extern "C" {
pub fn gtk_print_operation_is_finished(op: *mut GtkPrintOperation) -> gboolean;
}
extern "C" {
pub fn gtk_print_operation_cancel(op: *mut GtkPrintOperation);
}
extern "C" {
pub fn gtk_print_operation_draw_page_finish(op: *mut GtkPrintOperation);
}
extern "C" {
pub fn gtk_print_operation_set_defer_drawing(op: *mut GtkPrintOperation);
}
extern "C" {
pub fn gtk_print_operation_set_support_selection(
op: *mut GtkPrintOperation,
support_selection: gboolean,
);
}
extern "C" {
pub fn gtk_print_operation_get_support_selection(op: *mut GtkPrintOperation) -> gboolean;
}
extern "C" {
pub fn gtk_print_operation_set_has_selection(
op: *mut GtkPrintOperation,
has_selection: gboolean,
);
}
extern "C" {
pub fn gtk_print_operation_get_has_selection(op: *mut GtkPrintOperation) -> gboolean;
}
extern "C" {
pub fn gtk_print_operation_set_embed_page_setup(op: *mut GtkPrintOperation, embed: gboolean);
}
extern "C" {
pub fn gtk_print_operation_get_embed_page_setup(op: *mut GtkPrintOperation) -> gboolean;
}
extern "C" {
pub fn gtk_print_operation_get_n_pages_to_print(op: *mut GtkPrintOperation) -> gint;
}
extern "C" {
pub fn gtk_print_run_page_setup_dialog(
parent: *mut GtkWindow,
page_setup: *mut GtkPageSetup,
settings: *mut GtkPrintSettings,
) -> *mut GtkPageSetup;
}
#[doc = " GtkPageSetupDoneFunc:\n @page_setup: the #GtkPageSetup that has been\n @data: (closure): user data that has been passed to\n gtk_print_run_page_setup_dialog_async()\n\n The type of function that is passed to\n gtk_print_run_page_setup_dialog_async().\n\n This function will be called when the page setup dialog\n is dismissed, and also serves as destroy notify for @data."]
pub type GtkPageSetupDoneFunc =
::std::option::Option<unsafe extern "C" fn(page_setup: *mut GtkPageSetup, data: gpointer)>;
extern "C" {
pub fn gtk_print_run_page_setup_dialog_async(
parent: *mut GtkWindow,
page_setup: *mut GtkPageSetup,
settings: *mut GtkPrintSettings,
done_cb: GtkPageSetupDoneFunc,
data: gpointer,
);
}
pub type GtkProgressBar = _GtkProgressBar;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkProgressBarPrivate {
_unused: [u8; 0],
}
pub type GtkProgressBarPrivate = _GtkProgressBarPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkProgressBar {
pub parent: GtkWidget,
pub priv_: *mut GtkProgressBarPrivate,
}
#[test]
fn bindgen_test_layout__GtkProgressBar() {
const UNINIT: ::std::mem::MaybeUninit<_GtkProgressBar> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkProgressBar>(),
40usize,
concat!("Size of: ", stringify!(_GtkProgressBar))
);
assert_eq!(
::std::mem::align_of::<_GtkProgressBar>(),
8usize,
concat!("Alignment of ", stringify!(_GtkProgressBar))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkProgressBar),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkProgressBar),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkProgressBar {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_progress_bar_get_type() -> GType;
}
extern "C" {
pub fn gtk_progress_bar_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_progress_bar_pulse(pbar: *mut GtkProgressBar);
}
extern "C" {
pub fn gtk_progress_bar_set_text(pbar: *mut GtkProgressBar, text: *const gchar);
}
extern "C" {
pub fn gtk_progress_bar_set_fraction(pbar: *mut GtkProgressBar, fraction: gdouble);
}
extern "C" {
pub fn gtk_progress_bar_set_pulse_step(pbar: *mut GtkProgressBar, fraction: gdouble);
}
extern "C" {
pub fn gtk_progress_bar_set_inverted(pbar: *mut GtkProgressBar, inverted: gboolean);
}
extern "C" {
pub fn gtk_progress_bar_get_text(pbar: *mut GtkProgressBar) -> *const gchar;
}
extern "C" {
pub fn gtk_progress_bar_get_fraction(pbar: *mut GtkProgressBar) -> gdouble;
}
extern "C" {
pub fn gtk_progress_bar_get_pulse_step(pbar: *mut GtkProgressBar) -> gdouble;
}
extern "C" {
pub fn gtk_progress_bar_get_inverted(pbar: *mut GtkProgressBar) -> gboolean;
}
extern "C" {
pub fn gtk_progress_bar_set_ellipsize(pbar: *mut GtkProgressBar, mode: PangoEllipsizeMode);
}
extern "C" {
pub fn gtk_progress_bar_get_ellipsize(pbar: *mut GtkProgressBar) -> PangoEllipsizeMode;
}
extern "C" {
pub fn gtk_progress_bar_set_show_text(pbar: *mut GtkProgressBar, show_text: gboolean);
}
extern "C" {
pub fn gtk_progress_bar_get_show_text(pbar: *mut GtkProgressBar) -> gboolean;
}
pub type GtkRadioButton = _GtkRadioButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRadioButtonPrivate {
_unused: [u8; 0],
}
pub type GtkRadioButtonPrivate = _GtkRadioButtonPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRadioButton {
pub check_button: GtkCheckButton,
pub priv_: *mut GtkRadioButtonPrivate,
}
#[test]
fn bindgen_test_layout__GtkRadioButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkRadioButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkRadioButton>(),
72usize,
concat!("Size of: ", stringify!(_GtkRadioButton))
);
assert_eq!(
::std::mem::align_of::<_GtkRadioButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkRadioButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).check_button) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkRadioButton),
"::",
stringify!(check_button)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GtkRadioButton),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkRadioButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_radio_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_radio_button_new(group: *mut GSList) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_radio_button_new_from_widget(
radio_group_member: *mut GtkRadioButton,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_radio_button_new_with_label(
group: *mut GSList,
label: *const gchar,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_radio_button_new_with_label_from_widget(
radio_group_member: *mut GtkRadioButton,
label: *const gchar,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_radio_button_new_with_mnemonic(
group: *mut GSList,
label: *const gchar,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_radio_button_new_with_mnemonic_from_widget(
radio_group_member: *mut GtkRadioButton,
label: *const gchar,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_radio_button_get_group(radio_button: *mut GtkRadioButton) -> *mut GSList;
}
extern "C" {
pub fn gtk_radio_button_set_group(radio_button: *mut GtkRadioButton, group: *mut GSList);
}
extern "C" {
pub fn gtk_radio_button_join_group(
radio_button: *mut GtkRadioButton,
group_source: *mut GtkRadioButton,
);
}
pub type GtkRadioMenuItem = _GtkRadioMenuItem;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRadioMenuItemPrivate {
_unused: [u8; 0],
}
pub type GtkRadioMenuItemPrivate = _GtkRadioMenuItemPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRadioMenuItem {
pub check_menu_item: GtkCheckMenuItem,
pub priv_: *mut GtkRadioMenuItemPrivate,
}
#[test]
fn bindgen_test_layout__GtkRadioMenuItem() {
const UNINIT: ::std::mem::MaybeUninit<_GtkRadioMenuItem> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkRadioMenuItem>(),
72usize,
concat!("Size of: ", stringify!(_GtkRadioMenuItem))
);
assert_eq!(
::std::mem::align_of::<_GtkRadioMenuItem>(),
8usize,
concat!("Alignment of ", stringify!(_GtkRadioMenuItem))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).check_menu_item) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkRadioMenuItem),
"::",
stringify!(check_menu_item)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GtkRadioMenuItem),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkRadioMenuItem {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_radio_menu_item_get_type() -> GType;
}
extern "C" {
pub fn gtk_radio_menu_item_new(group: *mut GSList) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_radio_menu_item_new_with_label(
group: *mut GSList,
label: *const gchar,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_radio_menu_item_new_with_mnemonic(
group: *mut GSList,
label: *const gchar,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_radio_menu_item_new_from_widget(group: *mut GtkRadioMenuItem) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_radio_menu_item_new_with_mnemonic_from_widget(
group: *mut GtkRadioMenuItem,
label: *const gchar,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_radio_menu_item_new_with_label_from_widget(
group: *mut GtkRadioMenuItem,
label: *const gchar,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_radio_menu_item_get_group(radio_menu_item: *mut GtkRadioMenuItem) -> *mut GSList;
}
extern "C" {
pub fn gtk_radio_menu_item_set_group(
radio_menu_item: *mut GtkRadioMenuItem,
group: *mut GSList,
);
}
pub type GtkToggleToolButton = _GtkToggleToolButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToggleToolButtonPrivate {
_unused: [u8; 0],
}
pub type GtkToggleToolButtonPrivate = _GtkToggleToolButtonPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToggleToolButton {
pub parent: GtkToolButton,
pub priv_: *mut GtkToggleToolButtonPrivate,
}
#[test]
fn bindgen_test_layout__GtkToggleToolButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkToggleToolButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkToggleToolButton>(),
72usize,
concat!("Size of: ", stringify!(_GtkToggleToolButton))
);
assert_eq!(
::std::mem::align_of::<_GtkToggleToolButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkToggleToolButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkToggleToolButton),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GtkToggleToolButton),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkToggleToolButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_toggle_tool_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_toggle_tool_button_new() -> *mut GtkToolItem;
}
extern "C" {
pub fn gtk_toggle_tool_button_new_from_stock(stock_id: *const gchar) -> *mut GtkToolItem;
}
extern "C" {
pub fn gtk_toggle_tool_button_set_active(button: *mut GtkToggleToolButton, is_active: gboolean);
}
extern "C" {
pub fn gtk_toggle_tool_button_get_active(button: *mut GtkToggleToolButton) -> gboolean;
}
pub type GtkRadioToolButton = _GtkRadioToolButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRadioToolButton {
pub parent: GtkToggleToolButton,
}
#[test]
fn bindgen_test_layout__GtkRadioToolButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkRadioToolButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkRadioToolButton>(),
72usize,
concat!("Size of: ", stringify!(_GtkRadioToolButton))
);
assert_eq!(
::std::mem::align_of::<_GtkRadioToolButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkRadioToolButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkRadioToolButton),
"::",
stringify!(parent)
)
);
}
impl Default for _GtkRadioToolButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_radio_tool_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_radio_tool_button_new(group: *mut GSList) -> *mut GtkToolItem;
}
extern "C" {
pub fn gtk_radio_tool_button_new_from_stock(
group: *mut GSList,
stock_id: *const gchar,
) -> *mut GtkToolItem;
}
extern "C" {
pub fn gtk_radio_tool_button_new_from_widget(
group: *mut GtkRadioToolButton,
) -> *mut GtkToolItem;
}
extern "C" {
pub fn gtk_radio_tool_button_new_with_stock_from_widget(
group: *mut GtkRadioToolButton,
stock_id: *const gchar,
) -> *mut GtkToolItem;
}
extern "C" {
pub fn gtk_radio_tool_button_get_group(button: *mut GtkRadioToolButton) -> *mut GSList;
}
extern "C" {
pub fn gtk_radio_tool_button_set_group(button: *mut GtkRadioToolButton, group: *mut GSList);
}
pub type GtkRange = _GtkRange;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRangePrivate {
_unused: [u8; 0],
}
pub type GtkRangePrivate = _GtkRangePrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRange {
pub widget: GtkWidget,
pub priv_: *mut GtkRangePrivate,
}
#[test]
fn bindgen_test_layout__GtkRange() {
const UNINIT: ::std::mem::MaybeUninit<_GtkRange> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkRange>(),
40usize,
concat!("Size of: ", stringify!(_GtkRange))
);
assert_eq!(
::std::mem::align_of::<_GtkRange>(),
8usize,
concat!("Alignment of ", stringify!(_GtkRange))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).widget) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkRange),
"::",
stringify!(widget)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkRange),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkRange {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_range_get_type() -> GType;
}
extern "C" {
pub fn gtk_range_set_adjustment(range: *mut GtkRange, adjustment: *mut GtkAdjustment);
}
extern "C" {
pub fn gtk_range_get_adjustment(range: *mut GtkRange) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_range_set_inverted(range: *mut GtkRange, setting: gboolean);
}
extern "C" {
pub fn gtk_range_get_inverted(range: *mut GtkRange) -> gboolean;
}
extern "C" {
pub fn gtk_range_set_flippable(range: *mut GtkRange, flippable: gboolean);
}
extern "C" {
pub fn gtk_range_get_flippable(range: *mut GtkRange) -> gboolean;
}
extern "C" {
pub fn gtk_range_set_slider_size_fixed(range: *mut GtkRange, size_fixed: gboolean);
}
extern "C" {
pub fn gtk_range_get_slider_size_fixed(range: *mut GtkRange) -> gboolean;
}
extern "C" {
pub fn gtk_range_set_min_slider_size(range: *mut GtkRange, min_size: gint);
}
extern "C" {
pub fn gtk_range_get_min_slider_size(range: *mut GtkRange) -> gint;
}
extern "C" {
pub fn gtk_range_get_range_rect(range: *mut GtkRange, range_rect: *mut GdkRectangle);
}
extern "C" {
pub fn gtk_range_get_slider_range(
range: *mut GtkRange,
slider_start: *mut gint,
slider_end: *mut gint,
);
}
extern "C" {
pub fn gtk_range_set_lower_stepper_sensitivity(
range: *mut GtkRange,
sensitivity: GtkSensitivityType,
);
}
extern "C" {
pub fn gtk_range_get_lower_stepper_sensitivity(range: *mut GtkRange) -> GtkSensitivityType;
}
extern "C" {
pub fn gtk_range_set_upper_stepper_sensitivity(
range: *mut GtkRange,
sensitivity: GtkSensitivityType,
);
}
extern "C" {
pub fn gtk_range_get_upper_stepper_sensitivity(range: *mut GtkRange) -> GtkSensitivityType;
}
extern "C" {
pub fn gtk_range_set_increments(range: *mut GtkRange, step: gdouble, page: gdouble);
}
extern "C" {
pub fn gtk_range_set_range(range: *mut GtkRange, min: gdouble, max: gdouble);
}
extern "C" {
pub fn gtk_range_set_value(range: *mut GtkRange, value: gdouble);
}
extern "C" {
pub fn gtk_range_get_value(range: *mut GtkRange) -> gdouble;
}
extern "C" {
pub fn gtk_range_set_show_fill_level(range: *mut GtkRange, show_fill_level: gboolean);
}
extern "C" {
pub fn gtk_range_get_show_fill_level(range: *mut GtkRange) -> gboolean;
}
extern "C" {
pub fn gtk_range_set_restrict_to_fill_level(
range: *mut GtkRange,
restrict_to_fill_level: gboolean,
);
}
extern "C" {
pub fn gtk_range_get_restrict_to_fill_level(range: *mut GtkRange) -> gboolean;
}
extern "C" {
pub fn gtk_range_set_fill_level(range: *mut GtkRange, fill_level: gdouble);
}
extern "C" {
pub fn gtk_range_get_fill_level(range: *mut GtkRange) -> gdouble;
}
extern "C" {
pub fn gtk_range_set_round_digits(range: *mut GtkRange, round_digits: gint);
}
extern "C" {
pub fn gtk_range_get_round_digits(range: *mut GtkRange) -> gint;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRecentInfo {
_unused: [u8; 0],
}
pub type GtkRecentInfo = _GtkRecentInfo;
#[doc = " GtkRecentData:\n @display_name: a UTF-8 encoded string, containing the name of the recently\n used resource to be displayed, or %NULL;\n @description: a UTF-8 encoded string, containing a short description of\n the resource, or %NULL;\n @mime_type: the MIME type of the resource;\n @app_name: the name of the application that is registering this recently\n used resource;\n @app_exec: command line used to launch this resource; may contain the\n “&percnt;f” and “&percnt;u” escape characters which will be expanded\n to the resource file path and URI respectively when the command line\n is retrieved;\n @groups: (array zero-terminated=1): a vector of strings containing\n groups names;\n @is_private: whether this resource should be displayed only by the\n applications that have registered it or not.\n\n Meta-data to be passed to gtk_recent_manager_add_full() when\n registering a recently used resource."]
pub type GtkRecentData = _GtkRecentData;
#[doc = " GtkRecentManager:\n\n #GtkRecentManager-struct contains only private data\n and should be accessed using the provided API.\n\n Since: 2.10"]
pub type GtkRecentManager = _GtkRecentManager;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRecentManagerPrivate {
_unused: [u8; 0],
}
pub type GtkRecentManagerPrivate = _GtkRecentManagerPrivate;
#[doc = " GtkRecentData:\n @display_name: a UTF-8 encoded string, containing the name of the recently\n used resource to be displayed, or %NULL;\n @description: a UTF-8 encoded string, containing a short description of\n the resource, or %NULL;\n @mime_type: the MIME type of the resource;\n @app_name: the name of the application that is registering this recently\n used resource;\n @app_exec: command line used to launch this resource; may contain the\n “&percnt;f” and “&percnt;u” escape characters which will be expanded\n to the resource file path and URI respectively when the command line\n is retrieved;\n @groups: (array zero-terminated=1): a vector of strings containing\n groups names;\n @is_private: whether this resource should be displayed only by the\n applications that have registered it or not.\n\n Meta-data to be passed to gtk_recent_manager_add_full() when\n registering a recently used resource."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRecentData {
pub display_name: *mut gchar,
pub description: *mut gchar,
pub mime_type: *mut gchar,
pub app_name: *mut gchar,
pub app_exec: *mut gchar,
pub groups: *mut *mut gchar,
pub is_private: gboolean,
}
#[test]
fn bindgen_test_layout__GtkRecentData() {
const UNINIT: ::std::mem::MaybeUninit<_GtkRecentData> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkRecentData>(),
56usize,
concat!("Size of: ", stringify!(_GtkRecentData))
);
assert_eq!(
::std::mem::align_of::<_GtkRecentData>(),
8usize,
concat!("Alignment of ", stringify!(_GtkRecentData))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).display_name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentData),
"::",
stringify!(display_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentData),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mime_type) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentData),
"::",
stringify!(mime_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).app_name) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentData),
"::",
stringify!(app_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).app_exec) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentData),
"::",
stringify!(app_exec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).groups) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentData),
"::",
stringify!(groups)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_private) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentData),
"::",
stringify!(is_private)
)
);
}
impl Default for _GtkRecentData {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GtkRecentManager:\n\n #GtkRecentManager-struct contains only private data\n and should be accessed using the provided API.\n\n Since: 2.10"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRecentManager {
pub parent_instance: GObject,
pub priv_: *mut GtkRecentManagerPrivate,
}
#[test]
fn bindgen_test_layout__GtkRecentManager() {
const UNINIT: ::std::mem::MaybeUninit<_GtkRecentManager> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkRecentManager>(),
32usize,
concat!("Size of: ", stringify!(_GtkRecentManager))
);
assert_eq!(
::std::mem::align_of::<_GtkRecentManager>(),
8usize,
concat!("Alignment of ", stringify!(_GtkRecentManager))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentManager),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentManager),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkRecentManager {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_recent_manager_error_quark() -> GQuark;
}
extern "C" {
pub fn gtk_recent_manager_get_type() -> GType;
}
extern "C" {
pub fn gtk_recent_manager_new() -> *mut GtkRecentManager;
}
extern "C" {
pub fn gtk_recent_manager_get_default() -> *mut GtkRecentManager;
}
extern "C" {
pub fn gtk_recent_manager_add_item(
manager: *mut GtkRecentManager,
uri: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_recent_manager_add_full(
manager: *mut GtkRecentManager,
uri: *const gchar,
recent_data: *const GtkRecentData,
) -> gboolean;
}
extern "C" {
pub fn gtk_recent_manager_remove_item(
manager: *mut GtkRecentManager,
uri: *const gchar,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_recent_manager_lookup_item(
manager: *mut GtkRecentManager,
uri: *const gchar,
error: *mut *mut GError,
) -> *mut GtkRecentInfo;
}
extern "C" {
pub fn gtk_recent_manager_has_item(
manager: *mut GtkRecentManager,
uri: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_recent_manager_move_item(
manager: *mut GtkRecentManager,
uri: *const gchar,
new_uri: *const gchar,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_recent_manager_get_items(manager: *mut GtkRecentManager) -> *mut GList;
}
extern "C" {
pub fn gtk_recent_manager_purge_items(
manager: *mut GtkRecentManager,
error: *mut *mut GError,
) -> gint;
}
extern "C" {
pub fn gtk_recent_info_get_type() -> GType;
}
extern "C" {
pub fn gtk_recent_info_ref(info: *mut GtkRecentInfo) -> *mut GtkRecentInfo;
}
extern "C" {
pub fn gtk_recent_info_unref(info: *mut GtkRecentInfo);
}
extern "C" {
pub fn gtk_recent_info_get_uri(info: *mut GtkRecentInfo) -> *const gchar;
}
extern "C" {
pub fn gtk_recent_info_get_display_name(info: *mut GtkRecentInfo) -> *const gchar;
}
extern "C" {
pub fn gtk_recent_info_get_description(info: *mut GtkRecentInfo) -> *const gchar;
}
extern "C" {
pub fn gtk_recent_info_get_mime_type(info: *mut GtkRecentInfo) -> *const gchar;
}
extern "C" {
pub fn gtk_recent_info_get_added(info: *mut GtkRecentInfo) -> time_t;
}
extern "C" {
pub fn gtk_recent_info_get_modified(info: *mut GtkRecentInfo) -> time_t;
}
extern "C" {
pub fn gtk_recent_info_get_visited(info: *mut GtkRecentInfo) -> time_t;
}
extern "C" {
pub fn gtk_recent_info_get_private_hint(info: *mut GtkRecentInfo) -> gboolean;
}
extern "C" {
pub fn gtk_recent_info_get_application_info(
info: *mut GtkRecentInfo,
app_name: *const gchar,
app_exec: *mut *const gchar,
count: *mut guint,
time_: *mut time_t,
) -> gboolean;
}
extern "C" {
pub fn gtk_recent_info_create_app_info(
info: *mut GtkRecentInfo,
app_name: *const gchar,
error: *mut *mut GError,
) -> *mut GAppInfo;
}
extern "C" {
pub fn gtk_recent_info_get_applications(
info: *mut GtkRecentInfo,
length: *mut gsize,
) -> *mut *mut gchar;
}
extern "C" {
pub fn gtk_recent_info_last_application(info: *mut GtkRecentInfo) -> *mut gchar;
}
extern "C" {
pub fn gtk_recent_info_has_application(
info: *mut GtkRecentInfo,
app_name: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_recent_info_get_groups(
info: *mut GtkRecentInfo,
length: *mut gsize,
) -> *mut *mut gchar;
}
extern "C" {
pub fn gtk_recent_info_has_group(
info: *mut GtkRecentInfo,
group_name: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_recent_info_get_icon(info: *mut GtkRecentInfo, size: gint) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_recent_info_get_gicon(info: *mut GtkRecentInfo) -> *mut GIcon;
}
extern "C" {
pub fn gtk_recent_info_get_short_name(info: *mut GtkRecentInfo) -> *mut gchar;
}
extern "C" {
pub fn gtk_recent_info_get_uri_display(info: *mut GtkRecentInfo) -> *mut gchar;
}
extern "C" {
pub fn gtk_recent_info_get_age(info: *mut GtkRecentInfo) -> gint;
}
extern "C" {
pub fn gtk_recent_info_is_local(info: *mut GtkRecentInfo) -> gboolean;
}
extern "C" {
pub fn gtk_recent_info_exists(info: *mut GtkRecentInfo) -> gboolean;
}
extern "C" {
pub fn gtk_recent_info_match(
info_a: *mut GtkRecentInfo,
info_b: *mut GtkRecentInfo,
) -> gboolean;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRecentFilter {
_unused: [u8; 0],
}
pub type GtkRecentFilter = _GtkRecentFilter;
#[doc = " GtkRecentFilterInfo:\n @contains: #GtkRecentFilterFlags to indicate which fields are set.\n @uri: (nullable): The URI of the file being tested.\n @display_name: (nullable): The string that will be used to display\n the file in the recent chooser.\n @mime_type: (nullable): MIME type of the file.\n @applications: (nullable) (array zero-terminated=1): The list of\n applications that have registered the file.\n @groups: (nullable) (array zero-terminated=1): The groups to which\n the file belongs to.\n @age: The number of days elapsed since the file has been\n registered.\n\n A GtkRecentFilterInfo struct is used\n to pass information about the tested file to gtk_recent_filter_filter()."]
pub type GtkRecentFilterInfo = _GtkRecentFilterInfo;
pub const GtkRecentFilterFlags_GTK_RECENT_FILTER_URI: GtkRecentFilterFlags = 1;
pub const GtkRecentFilterFlags_GTK_RECENT_FILTER_DISPLAY_NAME: GtkRecentFilterFlags = 2;
pub const GtkRecentFilterFlags_GTK_RECENT_FILTER_MIME_TYPE: GtkRecentFilterFlags = 4;
pub const GtkRecentFilterFlags_GTK_RECENT_FILTER_APPLICATION: GtkRecentFilterFlags = 8;
pub const GtkRecentFilterFlags_GTK_RECENT_FILTER_GROUP: GtkRecentFilterFlags = 16;
pub const GtkRecentFilterFlags_GTK_RECENT_FILTER_AGE: GtkRecentFilterFlags = 32;
#[doc = " GtkRecentFilterFlags:\n @GTK_RECENT_FILTER_URI: the URI of the file being tested\n @GTK_RECENT_FILTER_DISPLAY_NAME: the string that will be used to\n display the file in the recent chooser\n @GTK_RECENT_FILTER_MIME_TYPE: the mime type of the file\n @GTK_RECENT_FILTER_APPLICATION: the list of applications that have\n registered the file\n @GTK_RECENT_FILTER_GROUP: the groups to which the file belongs to\n @GTK_RECENT_FILTER_AGE: the number of days elapsed since the file\n has been registered\n\n These flags indicate what parts of a #GtkRecentFilterInfo struct\n are filled or need to be filled."]
pub type GtkRecentFilterFlags = ::std::os::raw::c_uint;
#[doc = " GtkRecentFilterFunc:\n @filter_info: a #GtkRecentFilterInfo that is filled according\n to the @needed flags passed to gtk_recent_filter_add_custom()\n @user_data: user data passed to gtk_recent_filter_add_custom()\n\n The type of function that is used with custom filters,\n see gtk_recent_filter_add_custom().\n\n Returns: %TRUE if the file should be displayed"]
pub type GtkRecentFilterFunc = ::std::option::Option<
unsafe extern "C" fn(filter_info: *const GtkRecentFilterInfo, user_data: gpointer) -> gboolean,
>;
#[doc = " GtkRecentFilterInfo:\n @contains: #GtkRecentFilterFlags to indicate which fields are set.\n @uri: (nullable): The URI of the file being tested.\n @display_name: (nullable): The string that will be used to display\n the file in the recent chooser.\n @mime_type: (nullable): MIME type of the file.\n @applications: (nullable) (array zero-terminated=1): The list of\n applications that have registered the file.\n @groups: (nullable) (array zero-terminated=1): The groups to which\n the file belongs to.\n @age: The number of days elapsed since the file has been\n registered.\n\n A GtkRecentFilterInfo struct is used\n to pass information about the tested file to gtk_recent_filter_filter()."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRecentFilterInfo {
pub contains: GtkRecentFilterFlags,
pub uri: *const gchar,
pub display_name: *const gchar,
pub mime_type: *const gchar,
pub applications: *mut *const gchar,
pub groups: *mut *const gchar,
pub age: gint,
}
#[test]
fn bindgen_test_layout__GtkRecentFilterInfo() {
const UNINIT: ::std::mem::MaybeUninit<_GtkRecentFilterInfo> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkRecentFilterInfo>(),
56usize,
concat!("Size of: ", stringify!(_GtkRecentFilterInfo))
);
assert_eq!(
::std::mem::align_of::<_GtkRecentFilterInfo>(),
8usize,
concat!("Alignment of ", stringify!(_GtkRecentFilterInfo))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).contains) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentFilterInfo),
"::",
stringify!(contains)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).uri) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentFilterInfo),
"::",
stringify!(uri)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).display_name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentFilterInfo),
"::",
stringify!(display_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mime_type) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentFilterInfo),
"::",
stringify!(mime_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).applications) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentFilterInfo),
"::",
stringify!(applications)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).groups) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentFilterInfo),
"::",
stringify!(groups)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).age) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentFilterInfo),
"::",
stringify!(age)
)
);
}
impl Default for _GtkRecentFilterInfo {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_recent_filter_get_type() -> GType;
}
extern "C" {
pub fn gtk_recent_filter_new() -> *mut GtkRecentFilter;
}
extern "C" {
pub fn gtk_recent_filter_set_name(filter: *mut GtkRecentFilter, name: *const gchar);
}
extern "C" {
pub fn gtk_recent_filter_get_name(filter: *mut GtkRecentFilter) -> *const gchar;
}
extern "C" {
pub fn gtk_recent_filter_add_mime_type(filter: *mut GtkRecentFilter, mime_type: *const gchar);
}
extern "C" {
pub fn gtk_recent_filter_add_pattern(filter: *mut GtkRecentFilter, pattern: *const gchar);
}
extern "C" {
pub fn gtk_recent_filter_add_pixbuf_formats(filter: *mut GtkRecentFilter);
}
extern "C" {
pub fn gtk_recent_filter_add_application(
filter: *mut GtkRecentFilter,
application: *const gchar,
);
}
extern "C" {
pub fn gtk_recent_filter_add_group(filter: *mut GtkRecentFilter, group: *const gchar);
}
extern "C" {
pub fn gtk_recent_filter_add_age(filter: *mut GtkRecentFilter, days: gint);
}
extern "C" {
pub fn gtk_recent_filter_add_custom(
filter: *mut GtkRecentFilter,
needed: GtkRecentFilterFlags,
func: GtkRecentFilterFunc,
data: gpointer,
data_destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_recent_filter_get_needed(filter: *mut GtkRecentFilter) -> GtkRecentFilterFlags;
}
extern "C" {
pub fn gtk_recent_filter_filter(
filter: *mut GtkRecentFilter,
filter_info: *const GtkRecentFilterInfo,
) -> gboolean;
}
pub const GtkRecentSortType_GTK_RECENT_SORT_NONE: GtkRecentSortType = 0;
pub const GtkRecentSortType_GTK_RECENT_SORT_MRU: GtkRecentSortType = 1;
pub const GtkRecentSortType_GTK_RECENT_SORT_LRU: GtkRecentSortType = 2;
pub const GtkRecentSortType_GTK_RECENT_SORT_CUSTOM: GtkRecentSortType = 3;
#[doc = " GtkRecentSortType:\n @GTK_RECENT_SORT_NONE: Do not sort the returned list of recently used\n resources.\n @GTK_RECENT_SORT_MRU: Sort the returned list with the most recently used\n items first.\n @GTK_RECENT_SORT_LRU: Sort the returned list with the least recently used\n items first.\n @GTK_RECENT_SORT_CUSTOM: Sort the returned list using a custom sorting\n function passed using gtk_recent_chooser_set_sort_func().\n\n Used to specify the sorting method to be applyed to the recently\n used resource list.\n\n Since: 2.10"]
pub type GtkRecentSortType = ::std::os::raw::c_uint;
pub type GtkRecentSortFunc = ::std::option::Option<
unsafe extern "C" fn(a: *mut GtkRecentInfo, b: *mut GtkRecentInfo, user_data: gpointer) -> gint,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRecentChooser {
_unused: [u8; 0],
}
pub type GtkRecentChooser = _GtkRecentChooser;
extern "C" {
pub fn gtk_recent_chooser_error_quark() -> GQuark;
}
extern "C" {
pub fn gtk_recent_chooser_get_type() -> GType;
}
extern "C" {
pub fn gtk_recent_chooser_set_show_private(
chooser: *mut GtkRecentChooser,
show_private: gboolean,
);
}
extern "C" {
pub fn gtk_recent_chooser_get_show_private(chooser: *mut GtkRecentChooser) -> gboolean;
}
extern "C" {
pub fn gtk_recent_chooser_set_show_not_found(
chooser: *mut GtkRecentChooser,
show_not_found: gboolean,
);
}
extern "C" {
pub fn gtk_recent_chooser_get_show_not_found(chooser: *mut GtkRecentChooser) -> gboolean;
}
extern "C" {
pub fn gtk_recent_chooser_set_select_multiple(
chooser: *mut GtkRecentChooser,
select_multiple: gboolean,
);
}
extern "C" {
pub fn gtk_recent_chooser_get_select_multiple(chooser: *mut GtkRecentChooser) -> gboolean;
}
extern "C" {
pub fn gtk_recent_chooser_set_limit(chooser: *mut GtkRecentChooser, limit: gint);
}
extern "C" {
pub fn gtk_recent_chooser_get_limit(chooser: *mut GtkRecentChooser) -> gint;
}
extern "C" {
pub fn gtk_recent_chooser_set_local_only(chooser: *mut GtkRecentChooser, local_only: gboolean);
}
extern "C" {
pub fn gtk_recent_chooser_get_local_only(chooser: *mut GtkRecentChooser) -> gboolean;
}
extern "C" {
pub fn gtk_recent_chooser_set_show_tips(chooser: *mut GtkRecentChooser, show_tips: gboolean);
}
extern "C" {
pub fn gtk_recent_chooser_get_show_tips(chooser: *mut GtkRecentChooser) -> gboolean;
}
extern "C" {
pub fn gtk_recent_chooser_set_show_icons(chooser: *mut GtkRecentChooser, show_icons: gboolean);
}
extern "C" {
pub fn gtk_recent_chooser_get_show_icons(chooser: *mut GtkRecentChooser) -> gboolean;
}
extern "C" {
pub fn gtk_recent_chooser_set_sort_type(
chooser: *mut GtkRecentChooser,
sort_type: GtkRecentSortType,
);
}
extern "C" {
pub fn gtk_recent_chooser_get_sort_type(chooser: *mut GtkRecentChooser) -> GtkRecentSortType;
}
extern "C" {
pub fn gtk_recent_chooser_set_sort_func(
chooser: *mut GtkRecentChooser,
sort_func: GtkRecentSortFunc,
sort_data: gpointer,
data_destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_recent_chooser_set_current_uri(
chooser: *mut GtkRecentChooser,
uri: *const gchar,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_recent_chooser_get_current_uri(chooser: *mut GtkRecentChooser) -> *mut gchar;
}
extern "C" {
pub fn gtk_recent_chooser_get_current_item(
chooser: *mut GtkRecentChooser,
) -> *mut GtkRecentInfo;
}
extern "C" {
pub fn gtk_recent_chooser_select_uri(
chooser: *mut GtkRecentChooser,
uri: *const gchar,
error: *mut *mut GError,
) -> gboolean;
}
extern "C" {
pub fn gtk_recent_chooser_unselect_uri(chooser: *mut GtkRecentChooser, uri: *const gchar);
}
extern "C" {
pub fn gtk_recent_chooser_select_all(chooser: *mut GtkRecentChooser);
}
extern "C" {
pub fn gtk_recent_chooser_unselect_all(chooser: *mut GtkRecentChooser);
}
extern "C" {
pub fn gtk_recent_chooser_get_items(chooser: *mut GtkRecentChooser) -> *mut GList;
}
extern "C" {
pub fn gtk_recent_chooser_get_uris(
chooser: *mut GtkRecentChooser,
length: *mut gsize,
) -> *mut *mut gchar;
}
extern "C" {
pub fn gtk_recent_chooser_add_filter(
chooser: *mut GtkRecentChooser,
filter: *mut GtkRecentFilter,
);
}
extern "C" {
pub fn gtk_recent_chooser_remove_filter(
chooser: *mut GtkRecentChooser,
filter: *mut GtkRecentFilter,
);
}
extern "C" {
pub fn gtk_recent_chooser_list_filters(chooser: *mut GtkRecentChooser) -> *mut GSList;
}
extern "C" {
pub fn gtk_recent_chooser_set_filter(
chooser: *mut GtkRecentChooser,
filter: *mut GtkRecentFilter,
);
}
extern "C" {
pub fn gtk_recent_chooser_get_filter(chooser: *mut GtkRecentChooser) -> *mut GtkRecentFilter;
}
extern "C" {
pub fn gtk_recent_chooser_dialog_get_type() -> GType;
}
extern "C" {
pub fn gtk_recent_chooser_dialog_new(
title: *const gchar,
parent: *mut GtkWindow,
first_button_text: *const gchar,
...
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_recent_chooser_dialog_new_for_manager(
title: *const gchar,
parent: *mut GtkWindow,
manager: *mut GtkRecentManager,
first_button_text: *const gchar,
...
) -> *mut GtkWidget;
}
pub type GtkRecentChooserMenu = _GtkRecentChooserMenu;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRecentChooserMenuPrivate {
_unused: [u8; 0],
}
pub type GtkRecentChooserMenuPrivate = _GtkRecentChooserMenuPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRecentChooserMenu {
pub parent_instance: GtkMenu,
pub priv_: *mut GtkRecentChooserMenuPrivate,
}
#[test]
fn bindgen_test_layout__GtkRecentChooserMenu() {
const UNINIT: ::std::mem::MaybeUninit<_GtkRecentChooserMenu> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkRecentChooserMenu>(),
64usize,
concat!("Size of: ", stringify!(_GtkRecentChooserMenu))
);
assert_eq!(
::std::mem::align_of::<_GtkRecentChooserMenu>(),
8usize,
concat!("Alignment of ", stringify!(_GtkRecentChooserMenu))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentChooserMenu),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentChooserMenu),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkRecentChooserMenu {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_recent_chooser_menu_get_type() -> GType;
}
extern "C" {
pub fn gtk_recent_chooser_menu_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_recent_chooser_menu_new_for_manager(
manager: *mut GtkRecentManager,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_recent_chooser_menu_get_show_numbers(menu: *mut GtkRecentChooserMenu) -> gboolean;
}
extern "C" {
pub fn gtk_recent_chooser_menu_set_show_numbers(
menu: *mut GtkRecentChooserMenu,
show_numbers: gboolean,
);
}
extern "C" {
pub fn gtk_recent_chooser_widget_get_type() -> GType;
}
extern "C" {
pub fn gtk_recent_chooser_widget_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_recent_chooser_widget_new_for_manager(
manager: *mut GtkRecentManager,
) -> *mut GtkWidget;
}
pub type GtkRevealer = _GtkRevealer;
pub const GtkRevealerTransitionType_GTK_REVEALER_TRANSITION_TYPE_NONE: GtkRevealerTransitionType =
0;
pub const GtkRevealerTransitionType_GTK_REVEALER_TRANSITION_TYPE_CROSSFADE:
GtkRevealerTransitionType = 1;
pub const GtkRevealerTransitionType_GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT:
GtkRevealerTransitionType = 2;
pub const GtkRevealerTransitionType_GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT:
GtkRevealerTransitionType = 3;
pub const GtkRevealerTransitionType_GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP:
GtkRevealerTransitionType = 4;
pub const GtkRevealerTransitionType_GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN:
GtkRevealerTransitionType = 5;
pub type GtkRevealerTransitionType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRevealer {
pub parent_instance: GtkBin,
}
#[test]
fn bindgen_test_layout__GtkRevealer() {
const UNINIT: ::std::mem::MaybeUninit<_GtkRevealer> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkRevealer>(),
48usize,
concat!("Size of: ", stringify!(_GtkRevealer))
);
assert_eq!(
::std::mem::align_of::<_GtkRevealer>(),
8usize,
concat!("Alignment of ", stringify!(_GtkRevealer))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkRevealer),
"::",
stringify!(parent_instance)
)
);
}
impl Default for _GtkRevealer {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_revealer_get_type() -> GType;
}
extern "C" {
pub fn gtk_revealer_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_revealer_get_reveal_child(revealer: *mut GtkRevealer) -> gboolean;
}
extern "C" {
pub fn gtk_revealer_set_reveal_child(revealer: *mut GtkRevealer, reveal_child: gboolean);
}
extern "C" {
pub fn gtk_revealer_get_child_revealed(revealer: *mut GtkRevealer) -> gboolean;
}
extern "C" {
pub fn gtk_revealer_get_transition_duration(revealer: *mut GtkRevealer) -> guint;
}
extern "C" {
pub fn gtk_revealer_set_transition_duration(revealer: *mut GtkRevealer, duration: guint);
}
extern "C" {
pub fn gtk_revealer_set_transition_type(
revealer: *mut GtkRevealer,
transition: GtkRevealerTransitionType,
);
}
extern "C" {
pub fn gtk_revealer_get_transition_type(
revealer: *mut GtkRevealer,
) -> GtkRevealerTransitionType;
}
pub type GtkScale = _GtkScale;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkScalePrivate {
_unused: [u8; 0],
}
pub type GtkScalePrivate = _GtkScalePrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkScale {
pub range: GtkRange,
pub priv_: *mut GtkScalePrivate,
}
#[test]
fn bindgen_test_layout__GtkScale() {
const UNINIT: ::std::mem::MaybeUninit<_GtkScale> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkScale>(),
48usize,
concat!("Size of: ", stringify!(_GtkScale))
);
assert_eq!(
::std::mem::align_of::<_GtkScale>(),
8usize,
concat!("Alignment of ", stringify!(_GtkScale))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).range) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkScale),
"::",
stringify!(range)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkScale),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkScale {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_scale_get_type() -> GType;
}
extern "C" {
pub fn gtk_scale_new(
orientation: GtkOrientation,
adjustment: *mut GtkAdjustment,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_scale_new_with_range(
orientation: GtkOrientation,
min: gdouble,
max: gdouble,
step: gdouble,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_scale_set_digits(scale: *mut GtkScale, digits: gint);
}
extern "C" {
pub fn gtk_scale_get_digits(scale: *mut GtkScale) -> gint;
}
extern "C" {
pub fn gtk_scale_set_draw_value(scale: *mut GtkScale, draw_value: gboolean);
}
extern "C" {
pub fn gtk_scale_get_draw_value(scale: *mut GtkScale) -> gboolean;
}
extern "C" {
pub fn gtk_scale_set_has_origin(scale: *mut GtkScale, has_origin: gboolean);
}
extern "C" {
pub fn gtk_scale_get_has_origin(scale: *mut GtkScale) -> gboolean;
}
extern "C" {
pub fn gtk_scale_set_value_pos(scale: *mut GtkScale, pos: GtkPositionType);
}
extern "C" {
pub fn gtk_scale_get_value_pos(scale: *mut GtkScale) -> GtkPositionType;
}
extern "C" {
pub fn gtk_scale_get_layout(scale: *mut GtkScale) -> *mut PangoLayout;
}
extern "C" {
pub fn gtk_scale_get_layout_offsets(scale: *mut GtkScale, x: *mut gint, y: *mut gint);
}
extern "C" {
pub fn gtk_scale_add_mark(
scale: *mut GtkScale,
value: gdouble,
position: GtkPositionType,
markup: *const gchar,
);
}
extern "C" {
pub fn gtk_scale_clear_marks(scale: *mut GtkScale);
}
pub type GtkScaleButton = _GtkScaleButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkScaleButtonPrivate {
_unused: [u8; 0],
}
pub type GtkScaleButtonPrivate = _GtkScaleButtonPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkScaleButton {
pub parent: GtkButton,
pub priv_: *mut GtkScaleButtonPrivate,
}
#[test]
fn bindgen_test_layout__GtkScaleButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkScaleButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkScaleButton>(),
64usize,
concat!("Size of: ", stringify!(_GtkScaleButton))
);
assert_eq!(
::std::mem::align_of::<_GtkScaleButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkScaleButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkScaleButton),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkScaleButton),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkScaleButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_scale_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_scale_button_new(
size: GtkIconSize,
min: gdouble,
max: gdouble,
step: gdouble,
icons: *mut *const gchar,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_scale_button_set_icons(button: *mut GtkScaleButton, icons: *mut *const gchar);
}
extern "C" {
pub fn gtk_scale_button_get_value(button: *mut GtkScaleButton) -> gdouble;
}
extern "C" {
pub fn gtk_scale_button_set_value(button: *mut GtkScaleButton, value: gdouble);
}
extern "C" {
pub fn gtk_scale_button_get_adjustment(button: *mut GtkScaleButton) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_scale_button_set_adjustment(
button: *mut GtkScaleButton,
adjustment: *mut GtkAdjustment,
);
}
extern "C" {
pub fn gtk_scale_button_get_plus_button(button: *mut GtkScaleButton) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_scale_button_get_minus_button(button: *mut GtkScaleButton) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_scale_button_get_popup(button: *mut GtkScaleButton) -> *mut GtkWidget;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkScrollable {
_unused: [u8; 0],
}
pub type GtkScrollable = _GtkScrollable;
extern "C" {
pub fn gtk_scrollable_get_type() -> GType;
}
extern "C" {
pub fn gtk_scrollable_get_hadjustment(scrollable: *mut GtkScrollable) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_scrollable_set_hadjustment(
scrollable: *mut GtkScrollable,
hadjustment: *mut GtkAdjustment,
);
}
extern "C" {
pub fn gtk_scrollable_get_vadjustment(scrollable: *mut GtkScrollable) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_scrollable_set_vadjustment(
scrollable: *mut GtkScrollable,
vadjustment: *mut GtkAdjustment,
);
}
extern "C" {
pub fn gtk_scrollable_get_hscroll_policy(scrollable: *mut GtkScrollable)
-> GtkScrollablePolicy;
}
extern "C" {
pub fn gtk_scrollable_set_hscroll_policy(
scrollable: *mut GtkScrollable,
policy: GtkScrollablePolicy,
);
}
extern "C" {
pub fn gtk_scrollable_get_vscroll_policy(scrollable: *mut GtkScrollable)
-> GtkScrollablePolicy;
}
extern "C" {
pub fn gtk_scrollable_set_vscroll_policy(
scrollable: *mut GtkScrollable,
policy: GtkScrollablePolicy,
);
}
extern "C" {
pub fn gtk_scrollbar_get_type() -> GType;
}
extern "C" {
pub fn gtk_scrollbar_new(
orientation: GtkOrientation,
adjustment: *mut GtkAdjustment,
) -> *mut GtkWidget;
}
pub type GtkScrolledWindow = _GtkScrolledWindow;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkScrolledWindowPrivate {
_unused: [u8; 0],
}
pub type GtkScrolledWindowPrivate = _GtkScrolledWindowPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkScrolledWindow {
pub container: GtkBin,
pub priv_: *mut GtkScrolledWindowPrivate,
}
#[test]
fn bindgen_test_layout__GtkScrolledWindow() {
const UNINIT: ::std::mem::MaybeUninit<_GtkScrolledWindow> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkScrolledWindow>(),
56usize,
concat!("Size of: ", stringify!(_GtkScrolledWindow))
);
assert_eq!(
::std::mem::align_of::<_GtkScrolledWindow>(),
8usize,
concat!("Alignment of ", stringify!(_GtkScrolledWindow))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).container) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkScrolledWindow),
"::",
stringify!(container)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkScrolledWindow),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkScrolledWindow {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const GtkCornerType_GTK_CORNER_TOP_LEFT: GtkCornerType = 0;
pub const GtkCornerType_GTK_CORNER_BOTTOM_LEFT: GtkCornerType = 1;
pub const GtkCornerType_GTK_CORNER_TOP_RIGHT: GtkCornerType = 2;
pub const GtkCornerType_GTK_CORNER_BOTTOM_RIGHT: GtkCornerType = 3;
#[doc = " GtkCornerType:\n @GTK_CORNER_TOP_LEFT: Place the scrollbars on the right and bottom of the\n widget (default behaviour).\n @GTK_CORNER_BOTTOM_LEFT: Place the scrollbars on the top and right of the\n widget.\n @GTK_CORNER_TOP_RIGHT: Place the scrollbars on the left and bottom of the\n widget.\n @GTK_CORNER_BOTTOM_RIGHT: Place the scrollbars on the top and left of the\n widget.\n\n Specifies which corner a child widget should be placed in when packed into\n a #GtkScrolledWindow. This is effectively the opposite of where the scroll\n bars are placed."]
pub type GtkCornerType = ::std::os::raw::c_uint;
pub const GtkPolicyType_GTK_POLICY_ALWAYS: GtkPolicyType = 0;
pub const GtkPolicyType_GTK_POLICY_AUTOMATIC: GtkPolicyType = 1;
pub const GtkPolicyType_GTK_POLICY_NEVER: GtkPolicyType = 2;
#[doc = " GtkPolicyType:\n @GTK_POLICY_ALWAYS: The scrollbar is always visible. The view size is\n independent of the content.\n @GTK_POLICY_AUTOMATIC: The scrollbar will appear and disappear as necessary.\n For example, when all of a #GtkTreeView can not be seen.\n @GTK_POLICY_NEVER: The scrollbar should never appear. In this mode the\n content determines the size.\n\n Determines how the size should be computed to achieve the one of the\n visibility mode for the scrollbars."]
pub type GtkPolicyType = ::std::os::raw::c_uint;
extern "C" {
pub fn gtk_scrolled_window_get_type() -> GType;
}
extern "C" {
pub fn gtk_scrolled_window_new(
hadjustment: *mut GtkAdjustment,
vadjustment: *mut GtkAdjustment,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_scrolled_window_set_hadjustment(
scrolled_window: *mut GtkScrolledWindow,
hadjustment: *mut GtkAdjustment,
);
}
extern "C" {
pub fn gtk_scrolled_window_set_vadjustment(
scrolled_window: *mut GtkScrolledWindow,
vadjustment: *mut GtkAdjustment,
);
}
extern "C" {
pub fn gtk_scrolled_window_get_hadjustment(
scrolled_window: *mut GtkScrolledWindow,
) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_scrolled_window_get_vadjustment(
scrolled_window: *mut GtkScrolledWindow,
) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_scrolled_window_get_hscrollbar(
scrolled_window: *mut GtkScrolledWindow,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_scrolled_window_get_vscrollbar(
scrolled_window: *mut GtkScrolledWindow,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_scrolled_window_set_policy(
scrolled_window: *mut GtkScrolledWindow,
hscrollbar_policy: GtkPolicyType,
vscrollbar_policy: GtkPolicyType,
);
}
extern "C" {
pub fn gtk_scrolled_window_get_policy(
scrolled_window: *mut GtkScrolledWindow,
hscrollbar_policy: *mut GtkPolicyType,
vscrollbar_policy: *mut GtkPolicyType,
);
}
extern "C" {
pub fn gtk_scrolled_window_set_placement(
scrolled_window: *mut GtkScrolledWindow,
window_placement: GtkCornerType,
);
}
extern "C" {
pub fn gtk_scrolled_window_unset_placement(scrolled_window: *mut GtkScrolledWindow);
}
extern "C" {
pub fn gtk_scrolled_window_get_placement(
scrolled_window: *mut GtkScrolledWindow,
) -> GtkCornerType;
}
extern "C" {
pub fn gtk_scrolled_window_set_shadow_type(
scrolled_window: *mut GtkScrolledWindow,
type_: GtkShadowType,
);
}
extern "C" {
pub fn gtk_scrolled_window_get_shadow_type(
scrolled_window: *mut GtkScrolledWindow,
) -> GtkShadowType;
}
extern "C" {
pub fn gtk_scrolled_window_add_with_viewport(
scrolled_window: *mut GtkScrolledWindow,
child: *mut GtkWidget,
);
}
extern "C" {
pub fn gtk_scrolled_window_get_min_content_width(
scrolled_window: *mut GtkScrolledWindow,
) -> gint;
}
extern "C" {
pub fn gtk_scrolled_window_set_min_content_width(
scrolled_window: *mut GtkScrolledWindow,
width: gint,
);
}
extern "C" {
pub fn gtk_scrolled_window_get_min_content_height(
scrolled_window: *mut GtkScrolledWindow,
) -> gint;
}
extern "C" {
pub fn gtk_scrolled_window_set_min_content_height(
scrolled_window: *mut GtkScrolledWindow,
height: gint,
);
}
extern "C" {
pub fn gtk_scrolled_window_set_kinetic_scrolling(
scrolled_window: *mut GtkScrolledWindow,
kinetic_scrolling: gboolean,
);
}
extern "C" {
pub fn gtk_scrolled_window_get_kinetic_scrolling(
scrolled_window: *mut GtkScrolledWindow,
) -> gboolean;
}
extern "C" {
pub fn gtk_scrolled_window_set_capture_button_press(
scrolled_window: *mut GtkScrolledWindow,
capture_button_press: gboolean,
);
}
extern "C" {
pub fn gtk_scrolled_window_get_capture_button_press(
scrolled_window: *mut GtkScrolledWindow,
) -> gboolean;
}
pub type GtkSearchBar = _GtkSearchBar;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkSearchBar {
pub parent: GtkBin,
}
#[test]
fn bindgen_test_layout__GtkSearchBar() {
const UNINIT: ::std::mem::MaybeUninit<_GtkSearchBar> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkSearchBar>(),
48usize,
concat!("Size of: ", stringify!(_GtkSearchBar))
);
assert_eq!(
::std::mem::align_of::<_GtkSearchBar>(),
8usize,
concat!("Alignment of ", stringify!(_GtkSearchBar))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkSearchBar),
"::",
stringify!(parent)
)
);
}
impl Default for _GtkSearchBar {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_search_bar_get_type() -> GType;
}
extern "C" {
pub fn gtk_search_bar_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_search_bar_connect_entry(bar: *mut GtkSearchBar, entry: *mut GtkEntry);
}
extern "C" {
pub fn gtk_search_bar_get_search_mode(bar: *mut GtkSearchBar) -> gboolean;
}
extern "C" {
pub fn gtk_search_bar_set_search_mode(bar: *mut GtkSearchBar, search_mode: gboolean);
}
extern "C" {
pub fn gtk_search_bar_get_show_close_button(bar: *mut GtkSearchBar) -> gboolean;
}
extern "C" {
pub fn gtk_search_bar_set_show_close_button(bar: *mut GtkSearchBar, visible: gboolean);
}
extern "C" {
pub fn gtk_search_bar_handle_event(bar: *mut GtkSearchBar, event: *mut GdkEvent) -> gboolean;
}
extern "C" {
pub fn gtk_search_entry_get_type() -> GType;
}
extern "C" {
pub fn gtk_search_entry_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_separator_get_type() -> GType;
}
extern "C" {
pub fn gtk_separator_new(orientation: GtkOrientation) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_separator_menu_item_get_type() -> GType;
}
extern "C" {
pub fn gtk_separator_menu_item_new() -> *mut GtkWidget;
}
pub type GtkSeparatorToolItem = _GtkSeparatorToolItem;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkSeparatorToolItemPrivate {
_unused: [u8; 0],
}
pub type GtkSeparatorToolItemPrivate = _GtkSeparatorToolItemPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkSeparatorToolItem {
pub parent: GtkToolItem,
pub priv_: *mut GtkSeparatorToolItemPrivate,
}
#[test]
fn bindgen_test_layout__GtkSeparatorToolItem() {
const UNINIT: ::std::mem::MaybeUninit<_GtkSeparatorToolItem> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkSeparatorToolItem>(),
64usize,
concat!("Size of: ", stringify!(_GtkSeparatorToolItem))
);
assert_eq!(
::std::mem::align_of::<_GtkSeparatorToolItem>(),
8usize,
concat!("Alignment of ", stringify!(_GtkSeparatorToolItem))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkSeparatorToolItem),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkSeparatorToolItem),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkSeparatorToolItem {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_separator_tool_item_get_type() -> GType;
}
extern "C" {
pub fn gtk_separator_tool_item_new() -> *mut GtkToolItem;
}
extern "C" {
pub fn gtk_separator_tool_item_get_draw(item: *mut GtkSeparatorToolItem) -> gboolean;
}
extern "C" {
pub fn gtk_separator_tool_item_set_draw(item: *mut GtkSeparatorToolItem, draw: gboolean);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkSettingsPrivate {
_unused: [u8; 0],
}
pub type GtkSettingsPrivate = _GtkSettingsPrivate;
#[doc = " GtkSettingsValue:\n @origin: Origin should be something like “filename:linenumber” for\n rc files, or e.g. “XProperty” for other sources.\n @value: Valid types are LONG, DOUBLE and STRING corresponding to\n the token parsed, or a GSTRING holding an unparsed statement"]
pub type GtkSettingsValue = _GtkSettingsValue;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkSettings {
pub parent_instance: GObject,
pub priv_: *mut GtkSettingsPrivate,
}
#[test]
fn bindgen_test_layout__GtkSettings() {
const UNINIT: ::std::mem::MaybeUninit<_GtkSettings> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkSettings>(),
32usize,
concat!("Size of: ", stringify!(_GtkSettings))
);
assert_eq!(
::std::mem::align_of::<_GtkSettings>(),
8usize,
concat!("Alignment of ", stringify!(_GtkSettings))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkSettings),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkSettings),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkSettings {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GtkSettingsValue:\n @origin: Origin should be something like “filename:linenumber” for\n rc files, or e.g. “XProperty” for other sources.\n @value: Valid types are LONG, DOUBLE and STRING corresponding to\n the token parsed, or a GSTRING holding an unparsed statement"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _GtkSettingsValue {
pub origin: *mut gchar,
pub value: GValue,
}
#[test]
fn bindgen_test_layout__GtkSettingsValue() {
const UNINIT: ::std::mem::MaybeUninit<_GtkSettingsValue> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkSettingsValue>(),
32usize,
concat!("Size of: ", stringify!(_GtkSettingsValue))
);
assert_eq!(
::std::mem::align_of::<_GtkSettingsValue>(),
8usize,
concat!("Alignment of ", stringify!(_GtkSettingsValue))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).origin) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkSettingsValue),
"::",
stringify!(origin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkSettingsValue),
"::",
stringify!(value)
)
);
}
impl Default for _GtkSettingsValue {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_settings_get_type() -> GType;
}
extern "C" {
pub fn gtk_settings_get_default() -> *mut GtkSettings;
}
extern "C" {
pub fn gtk_settings_get_for_screen(screen: *mut GdkScreen) -> *mut GtkSettings;
}
extern "C" {
pub fn gtk_settings_install_property(pspec: *mut GParamSpec);
}
extern "C" {
pub fn gtk_settings_install_property_parser(
pspec: *mut GParamSpec,
parser: GtkRcPropertyParser,
);
}
extern "C" {
pub fn gtk_rc_property_parse_color(
pspec: *const GParamSpec,
gstring: *const GString,
property_value: *mut GValue,
) -> gboolean;
}
extern "C" {
pub fn gtk_rc_property_parse_enum(
pspec: *const GParamSpec,
gstring: *const GString,
property_value: *mut GValue,
) -> gboolean;
}
extern "C" {
pub fn gtk_rc_property_parse_flags(
pspec: *const GParamSpec,
gstring: *const GString,
property_value: *mut GValue,
) -> gboolean;
}
extern "C" {
pub fn gtk_rc_property_parse_requisition(
pspec: *const GParamSpec,
gstring: *const GString,
property_value: *mut GValue,
) -> gboolean;
}
extern "C" {
pub fn gtk_rc_property_parse_border(
pspec: *const GParamSpec,
gstring: *const GString,
property_value: *mut GValue,
) -> gboolean;
}
extern "C" {
pub fn gtk_settings_set_property_value(
settings: *mut GtkSettings,
name: *const gchar,
svalue: *const GtkSettingsValue,
);
}
extern "C" {
pub fn gtk_settings_set_string_property(
settings: *mut GtkSettings,
name: *const gchar,
v_string: *const gchar,
origin: *const gchar,
);
}
extern "C" {
pub fn gtk_settings_set_long_property(
settings: *mut GtkSettings,
name: *const gchar,
v_long: glong,
origin: *const gchar,
);
}
extern "C" {
pub fn gtk_settings_set_double_property(
settings: *mut GtkSettings,
name: *const gchar,
v_double: gdouble,
origin: *const gchar,
);
}
extern "C" {
pub fn gtk_show_uri(
screen: *mut GdkScreen,
uri: *const gchar,
timestamp: guint32,
error: *mut *mut GError,
) -> gboolean;
}
#[doc = " GtkRequestedSize:\n @data: A client pointer\n @minimum_size: The minimum size needed for allocation in a given orientation\n @natural_size: The natural size for allocation in a given orientation\n\n Represents a request of a screen object in a given orientation. These\n are primarily used in container implementations when allocating a natural\n size for children calling. See gtk_distribute_natural_allocation()."]
pub type GtkRequestedSize = _GtkRequestedSize;
#[doc = " GtkRequestedSize:\n @data: A client pointer\n @minimum_size: The minimum size needed for allocation in a given orientation\n @natural_size: The natural size for allocation in a given orientation\n\n Represents a request of a screen object in a given orientation. These\n are primarily used in container implementations when allocating a natural\n size for children calling. See gtk_distribute_natural_allocation()."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRequestedSize {
pub data: gpointer,
pub minimum_size: gint,
pub natural_size: gint,
}
#[test]
fn bindgen_test_layout__GtkRequestedSize() {
const UNINIT: ::std::mem::MaybeUninit<_GtkRequestedSize> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkRequestedSize>(),
16usize,
concat!("Size of: ", stringify!(_GtkRequestedSize))
);
assert_eq!(
::std::mem::align_of::<_GtkRequestedSize>(),
8usize,
concat!("Alignment of ", stringify!(_GtkRequestedSize))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkRequestedSize),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minimum_size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkRequestedSize),
"::",
stringify!(minimum_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).natural_size) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_GtkRequestedSize),
"::",
stringify!(natural_size)
)
);
}
impl Default for _GtkRequestedSize {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_distribute_natural_allocation(
extra_space: gint,
n_requested_sizes: guint,
sizes: *mut GtkRequestedSize,
) -> gint;
}
pub const GtkSpinButtonUpdatePolicy_GTK_UPDATE_ALWAYS: GtkSpinButtonUpdatePolicy = 0;
pub const GtkSpinButtonUpdatePolicy_GTK_UPDATE_IF_VALID: GtkSpinButtonUpdatePolicy = 1;
#[doc = " GtkSpinButtonUpdatePolicy:\n @GTK_UPDATE_ALWAYS: When refreshing your #GtkSpinButton, the value is\n always displayed\n @GTK_UPDATE_IF_VALID: When refreshing your #GtkSpinButton, the value is\n only displayed if it is valid within the bounds of the spin button's\n adjustment\n\n The spin button update policy determines whether the spin button displays\n values even if they are outside the bounds of its adjustment.\n See gtk_spin_button_set_update_policy()."]
pub type GtkSpinButtonUpdatePolicy = ::std::os::raw::c_uint;
pub const GtkSpinType_GTK_SPIN_STEP_FORWARD: GtkSpinType = 0;
pub const GtkSpinType_GTK_SPIN_STEP_BACKWARD: GtkSpinType = 1;
pub const GtkSpinType_GTK_SPIN_PAGE_FORWARD: GtkSpinType = 2;
pub const GtkSpinType_GTK_SPIN_PAGE_BACKWARD: GtkSpinType = 3;
pub const GtkSpinType_GTK_SPIN_HOME: GtkSpinType = 4;
pub const GtkSpinType_GTK_SPIN_END: GtkSpinType = 5;
pub const GtkSpinType_GTK_SPIN_USER_DEFINED: GtkSpinType = 6;
#[doc = " GtkSpinType:\n @GTK_SPIN_STEP_FORWARD: Increment by the adjustments step increment.\n @GTK_SPIN_STEP_BACKWARD: Decrement by the adjustments step increment.\n @GTK_SPIN_PAGE_FORWARD: Increment by the adjustments page increment.\n @GTK_SPIN_PAGE_BACKWARD: Decrement by the adjustments page increment.\n @GTK_SPIN_HOME: Go to the adjustments lower bound.\n @GTK_SPIN_END: Go to the adjustments upper bound.\n @GTK_SPIN_USER_DEFINED: Change by a specified amount.\n\n The values of the GtkSpinType enumeration are used to specify the\n change to make in gtk_spin_button_spin()."]
pub type GtkSpinType = ::std::os::raw::c_uint;
#[doc = " GtkSpinButton:\n\n The #GtkSpinButton-struct contains only private data and should\n not be directly modified."]
pub type GtkSpinButton = _GtkSpinButton;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkSpinButtonPrivate {
_unused: [u8; 0],
}
pub type GtkSpinButtonPrivate = _GtkSpinButtonPrivate;
#[doc = " GtkSpinButton:\n\n The #GtkSpinButton-struct contains only private data and should\n not be directly modified."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkSpinButton {
pub entry: GtkEntry,
pub priv_: *mut GtkSpinButtonPrivate,
}
#[test]
fn bindgen_test_layout__GtkSpinButton() {
const UNINIT: ::std::mem::MaybeUninit<_GtkSpinButton> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkSpinButton>(),
48usize,
concat!("Size of: ", stringify!(_GtkSpinButton))
);
assert_eq!(
::std::mem::align_of::<_GtkSpinButton>(),
8usize,
concat!("Alignment of ", stringify!(_GtkSpinButton))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).entry) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkSpinButton),
"::",
stringify!(entry)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkSpinButton),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkSpinButton {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_spin_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_spin_button_configure(
spin_button: *mut GtkSpinButton,
adjustment: *mut GtkAdjustment,
climb_rate: gdouble,
digits: guint,
);
}
extern "C" {
pub fn gtk_spin_button_new(
adjustment: *mut GtkAdjustment,
climb_rate: gdouble,
digits: guint,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_spin_button_new_with_range(
min: gdouble,
max: gdouble,
step: gdouble,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_spin_button_set_adjustment(
spin_button: *mut GtkSpinButton,
adjustment: *mut GtkAdjustment,
);
}
extern "C" {
pub fn gtk_spin_button_get_adjustment(spin_button: *mut GtkSpinButton) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_spin_button_set_digits(spin_button: *mut GtkSpinButton, digits: guint);
}
extern "C" {
pub fn gtk_spin_button_get_digits(spin_button: *mut GtkSpinButton) -> guint;
}
extern "C" {
pub fn gtk_spin_button_set_increments(
spin_button: *mut GtkSpinButton,
step: gdouble,
page: gdouble,
);
}
extern "C" {
pub fn gtk_spin_button_get_increments(
spin_button: *mut GtkSpinButton,
step: *mut gdouble,
page: *mut gdouble,
);
}
extern "C" {
pub fn gtk_spin_button_set_range(spin_button: *mut GtkSpinButton, min: gdouble, max: gdouble);
}
extern "C" {
pub fn gtk_spin_button_get_range(
spin_button: *mut GtkSpinButton,
min: *mut gdouble,
max: *mut gdouble,
);
}
extern "C" {
pub fn gtk_spin_button_get_value(spin_button: *mut GtkSpinButton) -> gdouble;
}
extern "C" {
pub fn gtk_spin_button_get_value_as_int(spin_button: *mut GtkSpinButton) -> gint;
}
extern "C" {
pub fn gtk_spin_button_set_value(spin_button: *mut GtkSpinButton, value: gdouble);
}
extern "C" {
pub fn gtk_spin_button_set_update_policy(
spin_button: *mut GtkSpinButton,
policy: GtkSpinButtonUpdatePolicy,
);
}
extern "C" {
pub fn gtk_spin_button_get_update_policy(
spin_button: *mut GtkSpinButton,
) -> GtkSpinButtonUpdatePolicy;
}
extern "C" {
pub fn gtk_spin_button_set_numeric(spin_button: *mut GtkSpinButton, numeric: gboolean);
}
extern "C" {
pub fn gtk_spin_button_get_numeric(spin_button: *mut GtkSpinButton) -> gboolean;
}
extern "C" {
pub fn gtk_spin_button_spin(
spin_button: *mut GtkSpinButton,
direction: GtkSpinType,
increment: gdouble,
);
}
extern "C" {
pub fn gtk_spin_button_set_wrap(spin_button: *mut GtkSpinButton, wrap: gboolean);
}
extern "C" {
pub fn gtk_spin_button_get_wrap(spin_button: *mut GtkSpinButton) -> gboolean;
}
extern "C" {
pub fn gtk_spin_button_set_snap_to_ticks(
spin_button: *mut GtkSpinButton,
snap_to_ticks: gboolean,
);
}
extern "C" {
pub fn gtk_spin_button_get_snap_to_ticks(spin_button: *mut GtkSpinButton) -> gboolean;
}
extern "C" {
pub fn gtk_spin_button_update(spin_button: *mut GtkSpinButton);
}
pub type GtkSpinner = _GtkSpinner;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkSpinnerPrivate {
_unused: [u8; 0],
}
pub type GtkSpinnerPrivate = _GtkSpinnerPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkSpinner {
pub parent: GtkWidget,
pub priv_: *mut GtkSpinnerPrivate,
}
#[test]
fn bindgen_test_layout__GtkSpinner() {
const UNINIT: ::std::mem::MaybeUninit<_GtkSpinner> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkSpinner>(),
40usize,
concat!("Size of: ", stringify!(_GtkSpinner))
);
assert_eq!(
::std::mem::align_of::<_GtkSpinner>(),
8usize,
concat!("Alignment of ", stringify!(_GtkSpinner))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkSpinner),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkSpinner),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkSpinner {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_spinner_get_type() -> GType;
}
extern "C" {
pub fn gtk_spinner_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_spinner_start(spinner: *mut GtkSpinner);
}
extern "C" {
pub fn gtk_spinner_stop(spinner: *mut GtkSpinner);
}
pub type GtkStack = _GtkStack;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_NONE: GtkStackTransitionType = 0;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_CROSSFADE: GtkStackTransitionType = 1;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT: GtkStackTransitionType = 2;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT: GtkStackTransitionType = 3;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_SLIDE_UP: GtkStackTransitionType = 4;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN: GtkStackTransitionType = 5;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT:
GtkStackTransitionType = 6;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN: GtkStackTransitionType =
7;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_OVER_UP: GtkStackTransitionType = 8;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_OVER_DOWN: GtkStackTransitionType = 9;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_OVER_LEFT: GtkStackTransitionType = 10;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_OVER_RIGHT: GtkStackTransitionType = 11;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_UNDER_UP: GtkStackTransitionType = 12;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_UNDER_DOWN: GtkStackTransitionType = 13;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_UNDER_LEFT: GtkStackTransitionType = 14;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT: GtkStackTransitionType = 15;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN: GtkStackTransitionType =
16;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP: GtkStackTransitionType =
17;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT: GtkStackTransitionType =
18;
pub const GtkStackTransitionType_GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT: GtkStackTransitionType =
19;
pub type GtkStackTransitionType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkStack {
pub parent_instance: GtkContainer,
}
#[test]
fn bindgen_test_layout__GtkStack() {
const UNINIT: ::std::mem::MaybeUninit<_GtkStack> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkStack>(),
40usize,
concat!("Size of: ", stringify!(_GtkStack))
);
assert_eq!(
::std::mem::align_of::<_GtkStack>(),
8usize,
concat!("Alignment of ", stringify!(_GtkStack))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkStack),
"::",
stringify!(parent_instance)
)
);
}
impl Default for _GtkStack {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_stack_get_type() -> GType;
}
extern "C" {
pub fn gtk_stack_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_stack_add_named(stack: *mut GtkStack, child: *mut GtkWidget, name: *const gchar);
}
extern "C" {
pub fn gtk_stack_add_titled(
stack: *mut GtkStack,
child: *mut GtkWidget,
name: *const gchar,
title: *const gchar,
);
}
extern "C" {
pub fn gtk_stack_get_child_by_name(stack: *mut GtkStack, name: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_stack_set_visible_child(stack: *mut GtkStack, child: *mut GtkWidget);
}
extern "C" {
pub fn gtk_stack_get_visible_child(stack: *mut GtkStack) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_stack_set_visible_child_name(stack: *mut GtkStack, name: *const gchar);
}
extern "C" {
pub fn gtk_stack_get_visible_child_name(stack: *mut GtkStack) -> *const gchar;
}
extern "C" {
pub fn gtk_stack_set_visible_child_full(
stack: *mut GtkStack,
name: *const gchar,
transition: GtkStackTransitionType,
);
}
extern "C" {
pub fn gtk_stack_set_homogeneous(stack: *mut GtkStack, homogeneous: gboolean);
}
extern "C" {
pub fn gtk_stack_get_homogeneous(stack: *mut GtkStack) -> gboolean;
}
extern "C" {
pub fn gtk_stack_set_transition_duration(stack: *mut GtkStack, duration: guint);
}
extern "C" {
pub fn gtk_stack_get_transition_duration(stack: *mut GtkStack) -> guint;
}
extern "C" {
pub fn gtk_stack_set_transition_type(stack: *mut GtkStack, transition: GtkStackTransitionType);
}
extern "C" {
pub fn gtk_stack_get_transition_type(stack: *mut GtkStack) -> GtkStackTransitionType;
}
extern "C" {
pub fn gtk_stack_get_transition_running(stack: *mut GtkStack) -> gboolean;
}
pub type GtkStackSwitcher = _GtkStackSwitcher;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkStackSwitcher {
pub widget: GtkBox,
}
#[test]
fn bindgen_test_layout__GtkStackSwitcher() {
const UNINIT: ::std::mem::MaybeUninit<_GtkStackSwitcher> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkStackSwitcher>(),
48usize,
concat!("Size of: ", stringify!(_GtkStackSwitcher))
);
assert_eq!(
::std::mem::align_of::<_GtkStackSwitcher>(),
8usize,
concat!("Alignment of ", stringify!(_GtkStackSwitcher))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).widget) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkStackSwitcher),
"::",
stringify!(widget)
)
);
}
impl Default for _GtkStackSwitcher {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_stack_switcher_get_type() -> GType;
}
extern "C" {
pub fn gtk_stack_switcher_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_stack_switcher_set_stack(switcher: *mut GtkStackSwitcher, stack: *mut GtkStack);
}
extern "C" {
pub fn gtk_stack_switcher_get_stack(switcher: *mut GtkStackSwitcher) -> *mut GtkStack;
}
pub type GtkStatusbar = _GtkStatusbar;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkStatusbarPrivate {
_unused: [u8; 0],
}
pub type GtkStatusbarPrivate = _GtkStatusbarPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkStatusbar {
pub parent_widget: GtkBox,
pub priv_: *mut GtkStatusbarPrivate,
}
#[test]
fn bindgen_test_layout__GtkStatusbar() {
const UNINIT: ::std::mem::MaybeUninit<_GtkStatusbar> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkStatusbar>(),
56usize,
concat!("Size of: ", stringify!(_GtkStatusbar))
);
assert_eq!(
::std::mem::align_of::<_GtkStatusbar>(),
8usize,
concat!("Alignment of ", stringify!(_GtkStatusbar))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_widget) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkStatusbar),
"::",
stringify!(parent_widget)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkStatusbar),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkStatusbar {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_statusbar_get_type() -> GType;
}
extern "C" {
pub fn gtk_statusbar_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_statusbar_get_context_id(
statusbar: *mut GtkStatusbar,
context_description: *const gchar,
) -> guint;
}
extern "C" {
pub fn gtk_statusbar_push(
statusbar: *mut GtkStatusbar,
context_id: guint,
text: *const gchar,
) -> guint;
}
extern "C" {
pub fn gtk_statusbar_pop(statusbar: *mut GtkStatusbar, context_id: guint);
}
extern "C" {
pub fn gtk_statusbar_remove(statusbar: *mut GtkStatusbar, context_id: guint, message_id: guint);
}
extern "C" {
pub fn gtk_statusbar_remove_all(statusbar: *mut GtkStatusbar, context_id: guint);
}
extern "C" {
pub fn gtk_statusbar_get_message_area(statusbar: *mut GtkStatusbar) -> *mut GtkWidget;
}
#[doc = " GtkSwitch:\n\n The #GtkSwitch-struct contains private\n data and it should only be accessed using the provided API."]
pub type GtkSwitch = _GtkSwitch;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkSwitchPrivate {
_unused: [u8; 0],
}
pub type GtkSwitchPrivate = _GtkSwitchPrivate;
#[doc = " GtkSwitch:\n\n The #GtkSwitch-struct contains private\n data and it should only be accessed using the provided API."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkSwitch {
pub parent_instance: GtkWidget,
pub priv_: *mut GtkSwitchPrivate,
}
#[test]
fn bindgen_test_layout__GtkSwitch() {
const UNINIT: ::std::mem::MaybeUninit<_GtkSwitch> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkSwitch>(),
40usize,
concat!("Size of: ", stringify!(_GtkSwitch))
);
assert_eq!(
::std::mem::align_of::<_GtkSwitch>(),
8usize,
concat!("Alignment of ", stringify!(_GtkSwitch))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkSwitch),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkSwitch),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkSwitch {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_switch_get_type() -> GType;
}
extern "C" {
pub fn gtk_switch_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_switch_set_active(sw: *mut GtkSwitch, is_active: gboolean);
}
extern "C" {
pub fn gtk_switch_get_active(sw: *mut GtkSwitch) -> gboolean;
}
extern "C" {
pub fn gtk_switch_set_state(sw: *mut GtkSwitch, state: gboolean);
}
extern "C" {
pub fn gtk_switch_get_state(sw: *mut GtkSwitch) -> gboolean;
}
#[doc = " GtkTextTagTableForeach:\n @tag: the #GtkTextTag\n @data: (closure): data passed to gtk_text_tag_table_foreach()"]
pub type GtkTextTagTableForeach =
::std::option::Option<unsafe extern "C" fn(tag: *mut GtkTextTag, data: gpointer)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTextTagTablePrivate {
_unused: [u8; 0],
}
pub type GtkTextTagTablePrivate = _GtkTextTagTablePrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTextTagTable {
pub parent_instance: GObject,
pub priv_: *mut GtkTextTagTablePrivate,
}
#[test]
fn bindgen_test_layout__GtkTextTagTable() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTextTagTable> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTextTagTable>(),
32usize,
concat!("Size of: ", stringify!(_GtkTextTagTable))
);
assert_eq!(
::std::mem::align_of::<_GtkTextTagTable>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTextTagTable))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextTagTable),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextTagTable),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkTextTagTable {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_text_tag_table_get_type() -> GType;
}
extern "C" {
pub fn gtk_text_tag_table_new() -> *mut GtkTextTagTable;
}
extern "C" {
pub fn gtk_text_tag_table_add(table: *mut GtkTextTagTable, tag: *mut GtkTextTag) -> gboolean;
}
extern "C" {
pub fn gtk_text_tag_table_remove(table: *mut GtkTextTagTable, tag: *mut GtkTextTag);
}
extern "C" {
pub fn gtk_text_tag_table_lookup(
table: *mut GtkTextTagTable,
name: *const gchar,
) -> *mut GtkTextTag;
}
extern "C" {
pub fn gtk_text_tag_table_foreach(
table: *mut GtkTextTagTable,
func: GtkTextTagTableForeach,
data: gpointer,
);
}
extern "C" {
pub fn gtk_text_tag_table_get_size(table: *mut GtkTextTagTable) -> gint;
}
pub type GtkTextMark = _GtkTextMark;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTextMark {
pub parent_instance: GObject,
pub segment: gpointer,
}
#[test]
fn bindgen_test_layout__GtkTextMark() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTextMark> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTextMark>(),
32usize,
concat!("Size of: ", stringify!(_GtkTextMark))
);
assert_eq!(
::std::mem::align_of::<_GtkTextMark>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTextMark))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextMark),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).segment) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextMark),
"::",
stringify!(segment)
)
);
}
impl Default for _GtkTextMark {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_text_mark_get_type() -> GType;
}
extern "C" {
pub fn gtk_text_mark_new(name: *const gchar, left_gravity: gboolean) -> *mut GtkTextMark;
}
extern "C" {
pub fn gtk_text_mark_set_visible(mark: *mut GtkTextMark, setting: gboolean);
}
extern "C" {
pub fn gtk_text_mark_get_visible(mark: *mut GtkTextMark) -> gboolean;
}
extern "C" {
pub fn gtk_text_mark_get_name(mark: *mut GtkTextMark) -> *const gchar;
}
extern "C" {
pub fn gtk_text_mark_get_deleted(mark: *mut GtkTextMark) -> gboolean;
}
extern "C" {
pub fn gtk_text_mark_get_buffer(mark: *mut GtkTextMark) -> *mut GtkTextBuffer;
}
extern "C" {
pub fn gtk_text_mark_get_left_gravity(mark: *mut GtkTextMark) -> gboolean;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTextBufferPrivate {
_unused: [u8; 0],
}
pub type GtkTextBufferPrivate = _GtkTextBufferPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTextBuffer {
pub parent_instance: GObject,
pub priv_: *mut GtkTextBufferPrivate,
}
#[test]
fn bindgen_test_layout__GtkTextBuffer() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTextBuffer> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTextBuffer>(),
32usize,
concat!("Size of: ", stringify!(_GtkTextBuffer))
);
assert_eq!(
::std::mem::align_of::<_GtkTextBuffer>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTextBuffer))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextBuffer),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextBuffer),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkTextBuffer {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_text_buffer_get_type() -> GType;
}
extern "C" {
pub fn gtk_text_buffer_new(table: *mut GtkTextTagTable) -> *mut GtkTextBuffer;
}
extern "C" {
pub fn gtk_text_buffer_get_line_count(buffer: *mut GtkTextBuffer) -> gint;
}
extern "C" {
pub fn gtk_text_buffer_get_char_count(buffer: *mut GtkTextBuffer) -> gint;
}
extern "C" {
pub fn gtk_text_buffer_get_tag_table(buffer: *mut GtkTextBuffer) -> *mut GtkTextTagTable;
}
extern "C" {
pub fn gtk_text_buffer_set_text(buffer: *mut GtkTextBuffer, text: *const gchar, len: gint);
}
extern "C" {
pub fn gtk_text_buffer_insert(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
text: *const gchar,
len: gint,
);
}
extern "C" {
pub fn gtk_text_buffer_insert_at_cursor(
buffer: *mut GtkTextBuffer,
text: *const gchar,
len: gint,
);
}
extern "C" {
pub fn gtk_text_buffer_insert_interactive(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
text: *const gchar,
len: gint,
default_editable: gboolean,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_buffer_insert_interactive_at_cursor(
buffer: *mut GtkTextBuffer,
text: *const gchar,
len: gint,
default_editable: gboolean,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_buffer_insert_range(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
start: *const GtkTextIter,
end: *const GtkTextIter,
);
}
extern "C" {
pub fn gtk_text_buffer_insert_range_interactive(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
start: *const GtkTextIter,
end: *const GtkTextIter,
default_editable: gboolean,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_buffer_insert_with_tags(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
text: *const gchar,
len: gint,
first_tag: *mut GtkTextTag,
...
);
}
extern "C" {
pub fn gtk_text_buffer_insert_with_tags_by_name(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
text: *const gchar,
len: gint,
first_tag_name: *const gchar,
...
);
}
extern "C" {
pub fn gtk_text_buffer_delete(
buffer: *mut GtkTextBuffer,
start: *mut GtkTextIter,
end: *mut GtkTextIter,
);
}
extern "C" {
pub fn gtk_text_buffer_delete_interactive(
buffer: *mut GtkTextBuffer,
start_iter: *mut GtkTextIter,
end_iter: *mut GtkTextIter,
default_editable: gboolean,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_buffer_backspace(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
interactive: gboolean,
default_editable: gboolean,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_buffer_get_text(
buffer: *mut GtkTextBuffer,
start: *const GtkTextIter,
end: *const GtkTextIter,
include_hidden_chars: gboolean,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_text_buffer_get_slice(
buffer: *mut GtkTextBuffer,
start: *const GtkTextIter,
end: *const GtkTextIter,
include_hidden_chars: gboolean,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_text_buffer_insert_pixbuf(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
pixbuf: *mut GdkPixbuf,
);
}
extern "C" {
pub fn gtk_text_buffer_insert_child_anchor(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
anchor: *mut GtkTextChildAnchor,
);
}
extern "C" {
pub fn gtk_text_buffer_create_child_anchor(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
) -> *mut GtkTextChildAnchor;
}
extern "C" {
pub fn gtk_text_buffer_add_mark(
buffer: *mut GtkTextBuffer,
mark: *mut GtkTextMark,
where_: *const GtkTextIter,
);
}
extern "C" {
pub fn gtk_text_buffer_create_mark(
buffer: *mut GtkTextBuffer,
mark_name: *const gchar,
where_: *const GtkTextIter,
left_gravity: gboolean,
) -> *mut GtkTextMark;
}
extern "C" {
pub fn gtk_text_buffer_move_mark(
buffer: *mut GtkTextBuffer,
mark: *mut GtkTextMark,
where_: *const GtkTextIter,
);
}
extern "C" {
pub fn gtk_text_buffer_delete_mark(buffer: *mut GtkTextBuffer, mark: *mut GtkTextMark);
}
extern "C" {
pub fn gtk_text_buffer_get_mark(
buffer: *mut GtkTextBuffer,
name: *const gchar,
) -> *mut GtkTextMark;
}
extern "C" {
pub fn gtk_text_buffer_move_mark_by_name(
buffer: *mut GtkTextBuffer,
name: *const gchar,
where_: *const GtkTextIter,
);
}
extern "C" {
pub fn gtk_text_buffer_delete_mark_by_name(buffer: *mut GtkTextBuffer, name: *const gchar);
}
extern "C" {
pub fn gtk_text_buffer_get_insert(buffer: *mut GtkTextBuffer) -> *mut GtkTextMark;
}
extern "C" {
pub fn gtk_text_buffer_get_selection_bound(buffer: *mut GtkTextBuffer) -> *mut GtkTextMark;
}
extern "C" {
pub fn gtk_text_buffer_place_cursor(buffer: *mut GtkTextBuffer, where_: *const GtkTextIter);
}
extern "C" {
pub fn gtk_text_buffer_select_range(
buffer: *mut GtkTextBuffer,
ins: *const GtkTextIter,
bound: *const GtkTextIter,
);
}
extern "C" {
pub fn gtk_text_buffer_apply_tag(
buffer: *mut GtkTextBuffer,
tag: *mut GtkTextTag,
start: *const GtkTextIter,
end: *const GtkTextIter,
);
}
extern "C" {
pub fn gtk_text_buffer_remove_tag(
buffer: *mut GtkTextBuffer,
tag: *mut GtkTextTag,
start: *const GtkTextIter,
end: *const GtkTextIter,
);
}
extern "C" {
pub fn gtk_text_buffer_apply_tag_by_name(
buffer: *mut GtkTextBuffer,
name: *const gchar,
start: *const GtkTextIter,
end: *const GtkTextIter,
);
}
extern "C" {
pub fn gtk_text_buffer_remove_tag_by_name(
buffer: *mut GtkTextBuffer,
name: *const gchar,
start: *const GtkTextIter,
end: *const GtkTextIter,
);
}
extern "C" {
pub fn gtk_text_buffer_remove_all_tags(
buffer: *mut GtkTextBuffer,
start: *const GtkTextIter,
end: *const GtkTextIter,
);
}
extern "C" {
pub fn gtk_text_buffer_create_tag(
buffer: *mut GtkTextBuffer,
tag_name: *const gchar,
first_property_name: *const gchar,
...
) -> *mut GtkTextTag;
}
extern "C" {
pub fn gtk_text_buffer_get_iter_at_line_offset(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
line_number: gint,
char_offset: gint,
);
}
extern "C" {
pub fn gtk_text_buffer_get_iter_at_line_index(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
line_number: gint,
byte_index: gint,
);
}
extern "C" {
pub fn gtk_text_buffer_get_iter_at_offset(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
char_offset: gint,
);
}
extern "C" {
pub fn gtk_text_buffer_get_iter_at_line(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
line_number: gint,
);
}
extern "C" {
pub fn gtk_text_buffer_get_start_iter(buffer: *mut GtkTextBuffer, iter: *mut GtkTextIter);
}
extern "C" {
pub fn gtk_text_buffer_get_end_iter(buffer: *mut GtkTextBuffer, iter: *mut GtkTextIter);
}
extern "C" {
pub fn gtk_text_buffer_get_bounds(
buffer: *mut GtkTextBuffer,
start: *mut GtkTextIter,
end: *mut GtkTextIter,
);
}
extern "C" {
pub fn gtk_text_buffer_get_iter_at_mark(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
mark: *mut GtkTextMark,
);
}
extern "C" {
pub fn gtk_text_buffer_get_iter_at_child_anchor(
buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
anchor: *mut GtkTextChildAnchor,
);
}
extern "C" {
pub fn gtk_text_buffer_get_modified(buffer: *mut GtkTextBuffer) -> gboolean;
}
extern "C" {
pub fn gtk_text_buffer_set_modified(buffer: *mut GtkTextBuffer, setting: gboolean);
}
extern "C" {
pub fn gtk_text_buffer_get_has_selection(buffer: *mut GtkTextBuffer) -> gboolean;
}
extern "C" {
pub fn gtk_text_buffer_add_selection_clipboard(
buffer: *mut GtkTextBuffer,
clipboard: *mut GtkClipboard,
);
}
extern "C" {
pub fn gtk_text_buffer_remove_selection_clipboard(
buffer: *mut GtkTextBuffer,
clipboard: *mut GtkClipboard,
);
}
extern "C" {
pub fn gtk_text_buffer_cut_clipboard(
buffer: *mut GtkTextBuffer,
clipboard: *mut GtkClipboard,
default_editable: gboolean,
);
}
extern "C" {
pub fn gtk_text_buffer_copy_clipboard(buffer: *mut GtkTextBuffer, clipboard: *mut GtkClipboard);
}
extern "C" {
pub fn gtk_text_buffer_paste_clipboard(
buffer: *mut GtkTextBuffer,
clipboard: *mut GtkClipboard,
override_location: *mut GtkTextIter,
default_editable: gboolean,
);
}
extern "C" {
pub fn gtk_text_buffer_get_selection_bounds(
buffer: *mut GtkTextBuffer,
start: *mut GtkTextIter,
end: *mut GtkTextIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_buffer_delete_selection(
buffer: *mut GtkTextBuffer,
interactive: gboolean,
default_editable: gboolean,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_buffer_begin_user_action(buffer: *mut GtkTextBuffer);
}
extern "C" {
pub fn gtk_text_buffer_end_user_action(buffer: *mut GtkTextBuffer);
}
extern "C" {
pub fn gtk_text_buffer_get_copy_target_list(buffer: *mut GtkTextBuffer) -> *mut GtkTargetList;
}
extern "C" {
pub fn gtk_text_buffer_get_paste_target_list(buffer: *mut GtkTextBuffer) -> *mut GtkTargetList;
}
#[doc = " GtkTextBufferSerializeFunc:\n @register_buffer: the #GtkTextBuffer for which the format is registered\n @content_buffer: the #GtkTextBuffer to serialize\n @start: start of the block of text to serialize\n @end: end of the block of text to serialize\n @length: Return location for the length of the serialized data\n @user_data: user data that was specified when registering the format\n\n A function that is called to serialize the content of a text buffer.\n It must return the serialized form of the content.\n\n Returns: a newly-allocated array of guint8 which contains the serialized\n data, or %NULL if an error occurred"]
pub type GtkTextBufferSerializeFunc = ::std::option::Option<
unsafe extern "C" fn(
register_buffer: *mut GtkTextBuffer,
content_buffer: *mut GtkTextBuffer,
start: *const GtkTextIter,
end: *const GtkTextIter,
length: *mut gsize,
user_data: gpointer,
) -> *mut guint8,
>;
#[doc = " GtkTextBufferDeserializeFunc:\n @register_buffer: the #GtkTextBuffer the format is registered with\n @content_buffer: the #GtkTextBuffer to deserialize into\n @iter: insertion point for the deserialized text\n @data: (array length=length): data to deserialize\n @length: length of @data\n @create_tags: %TRUE if deserializing may create tags\n @user_data: user data that was specified when registering the format\n @error: return location for a #GError\n\n A function that is called to deserialize rich text that has been\n serialized with gtk_text_buffer_serialize(), and insert it at @iter.\n\n Returns: %TRUE on success, %FALSE otherwise"]
pub type GtkTextBufferDeserializeFunc = ::std::option::Option<
unsafe extern "C" fn(
register_buffer: *mut GtkTextBuffer,
content_buffer: *mut GtkTextBuffer,
iter: *mut GtkTextIter,
data: *const guint8,
length: gsize,
create_tags: gboolean,
user_data: gpointer,
error: *mut *mut GError,
) -> gboolean,
>;
extern "C" {
pub fn gtk_text_buffer_register_serialize_format(
buffer: *mut GtkTextBuffer,
mime_type: *const gchar,
function: GtkTextBufferSerializeFunc,
user_data: gpointer,
user_data_destroy: GDestroyNotify,
) -> GdkAtom;
}
extern "C" {
pub fn gtk_text_buffer_register_serialize_tagset(
buffer: *mut GtkTextBuffer,
tagset_name: *const gchar,
) -> GdkAtom;
}
extern "C" {
pub fn gtk_text_buffer_register_deserialize_format(
buffer: *mut GtkTextBuffer,
mime_type: *const gchar,
function: GtkTextBufferDeserializeFunc,
user_data: gpointer,
user_data_destroy: GDestroyNotify,
) -> GdkAtom;
}
extern "C" {
pub fn gtk_text_buffer_register_deserialize_tagset(
buffer: *mut GtkTextBuffer,
tagset_name: *const gchar,
) -> GdkAtom;
}
extern "C" {
pub fn gtk_text_buffer_unregister_serialize_format(buffer: *mut GtkTextBuffer, format: GdkAtom);
}
extern "C" {
pub fn gtk_text_buffer_unregister_deserialize_format(
buffer: *mut GtkTextBuffer,
format: GdkAtom,
);
}
extern "C" {
pub fn gtk_text_buffer_deserialize_set_can_create_tags(
buffer: *mut GtkTextBuffer,
format: GdkAtom,
can_create_tags: gboolean,
);
}
extern "C" {
pub fn gtk_text_buffer_deserialize_get_can_create_tags(
buffer: *mut GtkTextBuffer,
format: GdkAtom,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_buffer_get_serialize_formats(
buffer: *mut GtkTextBuffer,
n_formats: *mut gint,
) -> *mut GdkAtom;
}
extern "C" {
pub fn gtk_text_buffer_get_deserialize_formats(
buffer: *mut GtkTextBuffer,
n_formats: *mut gint,
) -> *mut GdkAtom;
}
extern "C" {
pub fn gtk_text_buffer_serialize(
register_buffer: *mut GtkTextBuffer,
content_buffer: *mut GtkTextBuffer,
format: GdkAtom,
start: *const GtkTextIter,
end: *const GtkTextIter,
length: *mut gsize,
) -> *mut guint8;
}
extern "C" {
pub fn gtk_text_buffer_deserialize(
register_buffer: *mut GtkTextBuffer,
content_buffer: *mut GtkTextBuffer,
format: GdkAtom,
iter: *mut GtkTextIter,
data: *const guint8,
length: gsize,
error: *mut *mut GError,
) -> gboolean;
}
pub const GtkTextWindowType_GTK_TEXT_WINDOW_PRIVATE: GtkTextWindowType = 0;
pub const GtkTextWindowType_GTK_TEXT_WINDOW_WIDGET: GtkTextWindowType = 1;
pub const GtkTextWindowType_GTK_TEXT_WINDOW_TEXT: GtkTextWindowType = 2;
pub const GtkTextWindowType_GTK_TEXT_WINDOW_LEFT: GtkTextWindowType = 3;
pub const GtkTextWindowType_GTK_TEXT_WINDOW_RIGHT: GtkTextWindowType = 4;
pub const GtkTextWindowType_GTK_TEXT_WINDOW_TOP: GtkTextWindowType = 5;
pub const GtkTextWindowType_GTK_TEXT_WINDOW_BOTTOM: GtkTextWindowType = 6;
#[doc = " GtkTextWindowType:\n @GTK_TEXT_WINDOW_WIDGET: Window that floats over scrolling areas.\n @GTK_TEXT_WINDOW_TEXT: Scrollable text window.\n @GTK_TEXT_WINDOW_LEFT: Left side border window.\n @GTK_TEXT_WINDOW_RIGHT: Right side border window.\n @GTK_TEXT_WINDOW_TOP: Top border window.\n @GTK_TEXT_WINDOW_BOTTOM: Bottom border window.\n\n Used to reference the parts of #GtkTextView."]
pub type GtkTextWindowType = ::std::os::raw::c_uint;
pub type GtkTextView = _GtkTextView;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTextViewPrivate {
_unused: [u8; 0],
}
pub type GtkTextViewPrivate = _GtkTextViewPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTextView {
pub parent_instance: GtkContainer,
pub priv_: *mut GtkTextViewPrivate,
}
#[test]
fn bindgen_test_layout__GtkTextView() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTextView> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTextView>(),
48usize,
concat!("Size of: ", stringify!(_GtkTextView))
);
assert_eq!(
::std::mem::align_of::<_GtkTextView>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTextView))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextView),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkTextView),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkTextView {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_text_view_get_type() -> GType;
}
extern "C" {
pub fn gtk_text_view_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_text_view_new_with_buffer(buffer: *mut GtkTextBuffer) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_text_view_set_buffer(text_view: *mut GtkTextView, buffer: *mut GtkTextBuffer);
}
extern "C" {
pub fn gtk_text_view_get_buffer(text_view: *mut GtkTextView) -> *mut GtkTextBuffer;
}
extern "C" {
pub fn gtk_text_view_scroll_to_iter(
text_view: *mut GtkTextView,
iter: *mut GtkTextIter,
within_margin: gdouble,
use_align: gboolean,
xalign: gdouble,
yalign: gdouble,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_view_scroll_to_mark(
text_view: *mut GtkTextView,
mark: *mut GtkTextMark,
within_margin: gdouble,
use_align: gboolean,
xalign: gdouble,
yalign: gdouble,
);
}
extern "C" {
pub fn gtk_text_view_scroll_mark_onscreen(text_view: *mut GtkTextView, mark: *mut GtkTextMark);
}
extern "C" {
pub fn gtk_text_view_move_mark_onscreen(
text_view: *mut GtkTextView,
mark: *mut GtkTextMark,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_view_place_cursor_onscreen(text_view: *mut GtkTextView) -> gboolean;
}
extern "C" {
pub fn gtk_text_view_get_visible_rect(
text_view: *mut GtkTextView,
visible_rect: *mut GdkRectangle,
);
}
extern "C" {
pub fn gtk_text_view_set_cursor_visible(text_view: *mut GtkTextView, setting: gboolean);
}
extern "C" {
pub fn gtk_text_view_get_cursor_visible(text_view: *mut GtkTextView) -> gboolean;
}
extern "C" {
pub fn gtk_text_view_get_cursor_locations(
text_view: *mut GtkTextView,
iter: *const GtkTextIter,
strong: *mut GdkRectangle,
weak: *mut GdkRectangle,
);
}
extern "C" {
pub fn gtk_text_view_get_iter_location(
text_view: *mut GtkTextView,
iter: *const GtkTextIter,
location: *mut GdkRectangle,
);
}
extern "C" {
pub fn gtk_text_view_get_iter_at_location(
text_view: *mut GtkTextView,
iter: *mut GtkTextIter,
x: gint,
y: gint,
);
}
extern "C" {
pub fn gtk_text_view_get_iter_at_position(
text_view: *mut GtkTextView,
iter: *mut GtkTextIter,
trailing: *mut gint,
x: gint,
y: gint,
);
}
extern "C" {
pub fn gtk_text_view_get_line_yrange(
text_view: *mut GtkTextView,
iter: *const GtkTextIter,
y: *mut gint,
height: *mut gint,
);
}
extern "C" {
pub fn gtk_text_view_get_line_at_y(
text_view: *mut GtkTextView,
target_iter: *mut GtkTextIter,
y: gint,
line_top: *mut gint,
);
}
extern "C" {
pub fn gtk_text_view_buffer_to_window_coords(
text_view: *mut GtkTextView,
win: GtkTextWindowType,
buffer_x: gint,
buffer_y: gint,
window_x: *mut gint,
window_y: *mut gint,
);
}
extern "C" {
pub fn gtk_text_view_window_to_buffer_coords(
text_view: *mut GtkTextView,
win: GtkTextWindowType,
window_x: gint,
window_y: gint,
buffer_x: *mut gint,
buffer_y: *mut gint,
);
}
extern "C" {
pub fn gtk_text_view_get_hadjustment(text_view: *mut GtkTextView) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_text_view_get_vadjustment(text_view: *mut GtkTextView) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_text_view_get_window(
text_view: *mut GtkTextView,
win: GtkTextWindowType,
) -> *mut GdkWindow;
}
extern "C" {
pub fn gtk_text_view_get_window_type(
text_view: *mut GtkTextView,
window: *mut GdkWindow,
) -> GtkTextWindowType;
}
extern "C" {
pub fn gtk_text_view_set_border_window_size(
text_view: *mut GtkTextView,
type_: GtkTextWindowType,
size: gint,
);
}
extern "C" {
pub fn gtk_text_view_get_border_window_size(
text_view: *mut GtkTextView,
type_: GtkTextWindowType,
) -> gint;
}
extern "C" {
pub fn gtk_text_view_forward_display_line(
text_view: *mut GtkTextView,
iter: *mut GtkTextIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_view_backward_display_line(
text_view: *mut GtkTextView,
iter: *mut GtkTextIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_view_forward_display_line_end(
text_view: *mut GtkTextView,
iter: *mut GtkTextIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_view_backward_display_line_start(
text_view: *mut GtkTextView,
iter: *mut GtkTextIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_view_starts_display_line(
text_view: *mut GtkTextView,
iter: *const GtkTextIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_view_move_visually(
text_view: *mut GtkTextView,
iter: *mut GtkTextIter,
count: gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_view_im_context_filter_keypress(
text_view: *mut GtkTextView,
event: *mut GdkEventKey,
) -> gboolean;
}
extern "C" {
pub fn gtk_text_view_reset_im_context(text_view: *mut GtkTextView);
}
extern "C" {
pub fn gtk_text_view_add_child_at_anchor(
text_view: *mut GtkTextView,
child: *mut GtkWidget,
anchor: *mut GtkTextChildAnchor,
);
}
extern "C" {
pub fn gtk_text_view_add_child_in_window(
text_view: *mut GtkTextView,
child: *mut GtkWidget,
which_window: GtkTextWindowType,
xpos: gint,
ypos: gint,
);
}
extern "C" {
pub fn gtk_text_view_move_child(
text_view: *mut GtkTextView,
child: *mut GtkWidget,
xpos: gint,
ypos: gint,
);
}
extern "C" {
pub fn gtk_text_view_set_wrap_mode(text_view: *mut GtkTextView, wrap_mode: GtkWrapMode);
}
extern "C" {
pub fn gtk_text_view_get_wrap_mode(text_view: *mut GtkTextView) -> GtkWrapMode;
}
extern "C" {
pub fn gtk_text_view_set_editable(text_view: *mut GtkTextView, setting: gboolean);
}
extern "C" {
pub fn gtk_text_view_get_editable(text_view: *mut GtkTextView) -> gboolean;
}
extern "C" {
pub fn gtk_text_view_set_overwrite(text_view: *mut GtkTextView, overwrite: gboolean);
}
extern "C" {
pub fn gtk_text_view_get_overwrite(text_view: *mut GtkTextView) -> gboolean;
}
extern "C" {
pub fn gtk_text_view_set_accepts_tab(text_view: *mut GtkTextView, accepts_tab: gboolean);
}
extern "C" {
pub fn gtk_text_view_get_accepts_tab(text_view: *mut GtkTextView) -> gboolean;
}
extern "C" {
pub fn gtk_text_view_set_pixels_above_lines(
text_view: *mut GtkTextView,
pixels_above_lines: gint,
);
}
extern "C" {
pub fn gtk_text_view_get_pixels_above_lines(text_view: *mut GtkTextView) -> gint;
}
extern "C" {
pub fn gtk_text_view_set_pixels_below_lines(
text_view: *mut GtkTextView,
pixels_below_lines: gint,
);
}
extern "C" {
pub fn gtk_text_view_get_pixels_below_lines(text_view: *mut GtkTextView) -> gint;
}
extern "C" {
pub fn gtk_text_view_set_pixels_inside_wrap(
text_view: *mut GtkTextView,
pixels_inside_wrap: gint,
);
}
extern "C" {
pub fn gtk_text_view_get_pixels_inside_wrap(text_view: *mut GtkTextView) -> gint;
}
extern "C" {
pub fn gtk_text_view_set_justification(
text_view: *mut GtkTextView,
justification: GtkJustification,
);
}
extern "C" {
pub fn gtk_text_view_get_justification(text_view: *mut GtkTextView) -> GtkJustification;
}
extern "C" {
pub fn gtk_text_view_set_left_margin(text_view: *mut GtkTextView, left_margin: gint);
}
extern "C" {
pub fn gtk_text_view_get_left_margin(text_view: *mut GtkTextView) -> gint;
}
extern "C" {
pub fn gtk_text_view_set_right_margin(text_view: *mut GtkTextView, right_margin: gint);
}
extern "C" {
pub fn gtk_text_view_get_right_margin(text_view: *mut GtkTextView) -> gint;
}
extern "C" {
pub fn gtk_text_view_set_indent(text_view: *mut GtkTextView, indent: gint);
}
extern "C" {
pub fn gtk_text_view_get_indent(text_view: *mut GtkTextView) -> gint;
}
extern "C" {
pub fn gtk_text_view_set_tabs(text_view: *mut GtkTextView, tabs: *mut PangoTabArray);
}
extern "C" {
pub fn gtk_text_view_get_tabs(text_view: *mut GtkTextView) -> *mut PangoTabArray;
}
extern "C" {
pub fn gtk_text_view_get_default_attributes(
text_view: *mut GtkTextView,
) -> *mut GtkTextAttributes;
}
extern "C" {
pub fn gtk_text_view_set_input_purpose(text_view: *mut GtkTextView, purpose: GtkInputPurpose);
}
extern "C" {
pub fn gtk_text_view_get_input_purpose(text_view: *mut GtkTextView) -> GtkInputPurpose;
}
extern "C" {
pub fn gtk_text_view_set_input_hints(text_view: *mut GtkTextView, hints: GtkInputHints);
}
extern "C" {
pub fn gtk_text_view_get_input_hints(text_view: *mut GtkTextView) -> GtkInputHints;
}
pub type GtkToolbar = _GtkToolbar;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToolbarPrivate {
_unused: [u8; 0],
}
pub type GtkToolbarPrivate = _GtkToolbarPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToolbar {
pub container: GtkContainer,
pub priv_: *mut GtkToolbarPrivate,
}
#[test]
fn bindgen_test_layout__GtkToolbar() {
const UNINIT: ::std::mem::MaybeUninit<_GtkToolbar> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkToolbar>(),
48usize,
concat!("Size of: ", stringify!(_GtkToolbar))
);
assert_eq!(
::std::mem::align_of::<_GtkToolbar>(),
8usize,
concat!("Alignment of ", stringify!(_GtkToolbar))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).container) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkToolbar),
"::",
stringify!(container)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkToolbar),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkToolbar {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_toolbar_get_type() -> GType;
}
extern "C" {
pub fn gtk_toolbar_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_toolbar_insert(toolbar: *mut GtkToolbar, item: *mut GtkToolItem, pos: gint);
}
extern "C" {
pub fn gtk_toolbar_get_item_index(toolbar: *mut GtkToolbar, item: *mut GtkToolItem) -> gint;
}
extern "C" {
pub fn gtk_toolbar_get_n_items(toolbar: *mut GtkToolbar) -> gint;
}
extern "C" {
pub fn gtk_toolbar_get_nth_item(toolbar: *mut GtkToolbar, n: gint) -> *mut GtkToolItem;
}
extern "C" {
pub fn gtk_toolbar_get_show_arrow(toolbar: *mut GtkToolbar) -> gboolean;
}
extern "C" {
pub fn gtk_toolbar_set_show_arrow(toolbar: *mut GtkToolbar, show_arrow: gboolean);
}
extern "C" {
pub fn gtk_toolbar_get_style(toolbar: *mut GtkToolbar) -> GtkToolbarStyle;
}
extern "C" {
pub fn gtk_toolbar_set_style(toolbar: *mut GtkToolbar, style: GtkToolbarStyle);
}
extern "C" {
pub fn gtk_toolbar_unset_style(toolbar: *mut GtkToolbar);
}
extern "C" {
pub fn gtk_toolbar_get_icon_size(toolbar: *mut GtkToolbar) -> GtkIconSize;
}
extern "C" {
pub fn gtk_toolbar_set_icon_size(toolbar: *mut GtkToolbar, icon_size: GtkIconSize);
}
extern "C" {
pub fn gtk_toolbar_unset_icon_size(toolbar: *mut GtkToolbar);
}
extern "C" {
pub fn gtk_toolbar_get_relief_style(toolbar: *mut GtkToolbar) -> GtkReliefStyle;
}
extern "C" {
pub fn gtk_toolbar_get_drop_index(toolbar: *mut GtkToolbar, x: gint, y: gint) -> gint;
}
extern "C" {
pub fn gtk_toolbar_set_drop_highlight_item(
toolbar: *mut GtkToolbar,
tool_item: *mut GtkToolItem,
index_: gint,
);
}
#[doc = " GtkToolItemGroup:\n\n This should not be accessed directly. Use the accessor functions below."]
pub type GtkToolItemGroup = _GtkToolItemGroup;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToolItemGroupPrivate {
_unused: [u8; 0],
}
pub type GtkToolItemGroupPrivate = _GtkToolItemGroupPrivate;
#[doc = " GtkToolItemGroup:\n\n This should not be accessed directly. Use the accessor functions below."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToolItemGroup {
pub parent_instance: GtkContainer,
pub priv_: *mut GtkToolItemGroupPrivate,
}
#[test]
fn bindgen_test_layout__GtkToolItemGroup() {
const UNINIT: ::std::mem::MaybeUninit<_GtkToolItemGroup> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkToolItemGroup>(),
48usize,
concat!("Size of: ", stringify!(_GtkToolItemGroup))
);
assert_eq!(
::std::mem::align_of::<_GtkToolItemGroup>(),
8usize,
concat!("Alignment of ", stringify!(_GtkToolItemGroup))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkToolItemGroup),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkToolItemGroup),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkToolItemGroup {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_tool_item_group_get_type() -> GType;
}
extern "C" {
pub fn gtk_tool_item_group_new(label: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_tool_item_group_set_label(group: *mut GtkToolItemGroup, label: *const gchar);
}
extern "C" {
pub fn gtk_tool_item_group_set_label_widget(
group: *mut GtkToolItemGroup,
label_widget: *mut GtkWidget,
);
}
extern "C" {
pub fn gtk_tool_item_group_set_collapsed(group: *mut GtkToolItemGroup, collapsed: gboolean);
}
extern "C" {
pub fn gtk_tool_item_group_set_ellipsize(
group: *mut GtkToolItemGroup,
ellipsize: PangoEllipsizeMode,
);
}
extern "C" {
pub fn gtk_tool_item_group_set_header_relief(
group: *mut GtkToolItemGroup,
style: GtkReliefStyle,
);
}
extern "C" {
pub fn gtk_tool_item_group_get_label(group: *mut GtkToolItemGroup) -> *const gchar;
}
extern "C" {
pub fn gtk_tool_item_group_get_label_widget(group: *mut GtkToolItemGroup) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_tool_item_group_get_collapsed(group: *mut GtkToolItemGroup) -> gboolean;
}
extern "C" {
pub fn gtk_tool_item_group_get_ellipsize(group: *mut GtkToolItemGroup) -> PangoEllipsizeMode;
}
extern "C" {
pub fn gtk_tool_item_group_get_header_relief(group: *mut GtkToolItemGroup) -> GtkReliefStyle;
}
extern "C" {
pub fn gtk_tool_item_group_insert(
group: *mut GtkToolItemGroup,
item: *mut GtkToolItem,
position: gint,
);
}
extern "C" {
pub fn gtk_tool_item_group_set_item_position(
group: *mut GtkToolItemGroup,
item: *mut GtkToolItem,
position: gint,
);
}
extern "C" {
pub fn gtk_tool_item_group_get_item_position(
group: *mut GtkToolItemGroup,
item: *mut GtkToolItem,
) -> gint;
}
extern "C" {
pub fn gtk_tool_item_group_get_n_items(group: *mut GtkToolItemGroup) -> guint;
}
extern "C" {
pub fn gtk_tool_item_group_get_nth_item(
group: *mut GtkToolItemGroup,
index: guint,
) -> *mut GtkToolItem;
}
extern "C" {
pub fn gtk_tool_item_group_get_drop_item(
group: *mut GtkToolItemGroup,
x: gint,
y: gint,
) -> *mut GtkToolItem;
}
#[doc = " GtkToolPalette:\n\n This should not be accessed directly. Use the accessor functions below."]
pub type GtkToolPalette = _GtkToolPalette;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToolPalettePrivate {
_unused: [u8; 0],
}
pub type GtkToolPalettePrivate = _GtkToolPalettePrivate;
pub const GtkToolPaletteDragTargets_GTK_TOOL_PALETTE_DRAG_ITEMS: GtkToolPaletteDragTargets = 1;
pub const GtkToolPaletteDragTargets_GTK_TOOL_PALETTE_DRAG_GROUPS: GtkToolPaletteDragTargets = 2;
#[doc = " GtkToolPaletteDragTargets:\n @GTK_TOOL_PALETTE_DRAG_ITEMS: Support drag of items.\n @GTK_TOOL_PALETTE_DRAG_GROUPS: Support drag of groups.\n\n Flags used to specify the supported drag targets."]
pub type GtkToolPaletteDragTargets = ::std::os::raw::c_uint;
#[doc = " GtkToolPalette:\n\n This should not be accessed directly. Use the accessor functions below."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToolPalette {
pub parent_instance: GtkContainer,
pub priv_: *mut GtkToolPalettePrivate,
}
#[test]
fn bindgen_test_layout__GtkToolPalette() {
const UNINIT: ::std::mem::MaybeUninit<_GtkToolPalette> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkToolPalette>(),
48usize,
concat!("Size of: ", stringify!(_GtkToolPalette))
);
assert_eq!(
::std::mem::align_of::<_GtkToolPalette>(),
8usize,
concat!("Alignment of ", stringify!(_GtkToolPalette))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkToolPalette),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkToolPalette),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkToolPalette {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_tool_palette_get_type() -> GType;
}
extern "C" {
pub fn gtk_tool_palette_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_tool_palette_set_group_position(
palette: *mut GtkToolPalette,
group: *mut GtkToolItemGroup,
position: gint,
);
}
extern "C" {
pub fn gtk_tool_palette_set_exclusive(
palette: *mut GtkToolPalette,
group: *mut GtkToolItemGroup,
exclusive: gboolean,
);
}
extern "C" {
pub fn gtk_tool_palette_set_expand(
palette: *mut GtkToolPalette,
group: *mut GtkToolItemGroup,
expand: gboolean,
);
}
extern "C" {
pub fn gtk_tool_palette_get_group_position(
palette: *mut GtkToolPalette,
group: *mut GtkToolItemGroup,
) -> gint;
}
extern "C" {
pub fn gtk_tool_palette_get_exclusive(
palette: *mut GtkToolPalette,
group: *mut GtkToolItemGroup,
) -> gboolean;
}
extern "C" {
pub fn gtk_tool_palette_get_expand(
palette: *mut GtkToolPalette,
group: *mut GtkToolItemGroup,
) -> gboolean;
}
extern "C" {
pub fn gtk_tool_palette_set_icon_size(palette: *mut GtkToolPalette, icon_size: GtkIconSize);
}
extern "C" {
pub fn gtk_tool_palette_unset_icon_size(palette: *mut GtkToolPalette);
}
extern "C" {
pub fn gtk_tool_palette_set_style(palette: *mut GtkToolPalette, style: GtkToolbarStyle);
}
extern "C" {
pub fn gtk_tool_palette_unset_style(palette: *mut GtkToolPalette);
}
extern "C" {
pub fn gtk_tool_palette_get_icon_size(palette: *mut GtkToolPalette) -> GtkIconSize;
}
extern "C" {
pub fn gtk_tool_palette_get_style(palette: *mut GtkToolPalette) -> GtkToolbarStyle;
}
extern "C" {
pub fn gtk_tool_palette_get_drop_item(
palette: *mut GtkToolPalette,
x: gint,
y: gint,
) -> *mut GtkToolItem;
}
extern "C" {
pub fn gtk_tool_palette_get_drop_group(
palette: *mut GtkToolPalette,
x: gint,
y: gint,
) -> *mut GtkToolItemGroup;
}
extern "C" {
pub fn gtk_tool_palette_get_drag_item(
palette: *mut GtkToolPalette,
selection: *const GtkSelectionData,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_tool_palette_set_drag_source(
palette: *mut GtkToolPalette,
targets: GtkToolPaletteDragTargets,
);
}
extern "C" {
pub fn gtk_tool_palette_add_drag_dest(
palette: *mut GtkToolPalette,
widget: *mut GtkWidget,
flags: GtkDestDefaults,
targets: GtkToolPaletteDragTargets,
actions: GdkDragAction,
);
}
extern "C" {
pub fn gtk_tool_palette_get_hadjustment(palette: *mut GtkToolPalette) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_tool_palette_get_vadjustment(palette: *mut GtkToolPalette) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_tool_palette_get_drag_target_item() -> *const GtkTargetEntry;
}
extern "C" {
pub fn gtk_tool_palette_get_drag_target_group() -> *const GtkTargetEntry;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToolShell {
_unused: [u8; 0],
}
pub type GtkToolShell = _GtkToolShell;
extern "C" {
pub fn gtk_tool_shell_get_type() -> GType;
}
extern "C" {
pub fn gtk_tool_shell_get_icon_size(shell: *mut GtkToolShell) -> GtkIconSize;
}
extern "C" {
pub fn gtk_tool_shell_get_orientation(shell: *mut GtkToolShell) -> GtkOrientation;
}
extern "C" {
pub fn gtk_tool_shell_get_style(shell: *mut GtkToolShell) -> GtkToolbarStyle;
}
extern "C" {
pub fn gtk_tool_shell_get_relief_style(shell: *mut GtkToolShell) -> GtkReliefStyle;
}
extern "C" {
pub fn gtk_tool_shell_rebuild_menu(shell: *mut GtkToolShell);
}
extern "C" {
pub fn gtk_tool_shell_get_text_orientation(shell: *mut GtkToolShell) -> GtkOrientation;
}
extern "C" {
pub fn gtk_tool_shell_get_text_alignment(shell: *mut GtkToolShell) -> gfloat;
}
extern "C" {
pub fn gtk_tool_shell_get_ellipsize_mode(shell: *mut GtkToolShell) -> PangoEllipsizeMode;
}
extern "C" {
pub fn gtk_tool_shell_get_text_size_group(shell: *mut GtkToolShell) -> *mut GtkSizeGroup;
}
extern "C" {
pub fn gtk_test_init(
argcp: *mut ::std::os::raw::c_int,
argvp: *mut *mut *mut ::std::os::raw::c_char,
...
);
}
extern "C" {
pub fn gtk_test_register_all_types();
}
extern "C" {
pub fn gtk_test_list_all_types(n_types: *mut guint) -> *const GType;
}
extern "C" {
pub fn gtk_test_find_widget(
widget: *mut GtkWidget,
label_pattern: *const gchar,
widget_type: GType,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_test_create_widget(
widget_type: GType,
first_property_name: *const gchar,
...
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_test_create_simple_window(
window_title: *const gchar,
dialog_text: *const gchar,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_test_display_button_window(
window_title: *const gchar,
dialog_text: *const gchar,
...
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_test_slider_set_perc(widget: *mut GtkWidget, percentage: f64);
}
extern "C" {
pub fn gtk_test_slider_get_value(widget: *mut GtkWidget) -> f64;
}
extern "C" {
pub fn gtk_test_spin_button_click(
spinner: *mut GtkSpinButton,
button: guint,
upwards: gboolean,
) -> gboolean;
}
extern "C" {
pub fn gtk_test_widget_wait_for_draw(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_test_widget_click(
widget: *mut GtkWidget,
button: guint,
modifiers: GdkModifierType,
) -> gboolean;
}
extern "C" {
pub fn gtk_test_widget_send_key(
widget: *mut GtkWidget,
keyval: guint,
modifiers: GdkModifierType,
) -> gboolean;
}
extern "C" {
pub fn gtk_test_text_set(widget: *mut GtkWidget, string: *const gchar);
}
extern "C" {
pub fn gtk_test_text_get(widget: *mut GtkWidget) -> *mut gchar;
}
extern "C" {
pub fn gtk_test_find_sibling(base_widget: *mut GtkWidget, widget_type: GType)
-> *mut GtkWidget;
}
extern "C" {
pub fn gtk_test_find_label(
widget: *mut GtkWidget,
label_pattern: *const gchar,
) -> *mut GtkWidget;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeDragSource {
_unused: [u8; 0],
}
pub type GtkTreeDragSource = _GtkTreeDragSource;
extern "C" {
pub fn gtk_tree_drag_source_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_drag_source_row_draggable(
drag_source: *mut GtkTreeDragSource,
path: *mut GtkTreePath,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_drag_source_drag_data_delete(
drag_source: *mut GtkTreeDragSource,
path: *mut GtkTreePath,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_drag_source_drag_data_get(
drag_source: *mut GtkTreeDragSource,
path: *mut GtkTreePath,
selection_data: *mut GtkSelectionData,
) -> gboolean;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeDragDest {
_unused: [u8; 0],
}
pub type GtkTreeDragDest = _GtkTreeDragDest;
extern "C" {
pub fn gtk_tree_drag_dest_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_drag_dest_drag_data_received(
drag_dest: *mut GtkTreeDragDest,
dest: *mut GtkTreePath,
selection_data: *mut GtkSelectionData,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_drag_dest_row_drop_possible(
drag_dest: *mut GtkTreeDragDest,
dest_path: *mut GtkTreePath,
selection_data: *mut GtkSelectionData,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_set_row_drag_data(
selection_data: *mut GtkSelectionData,
tree_model: *mut GtkTreeModel,
path: *mut GtkTreePath,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_get_row_drag_data(
selection_data: *mut GtkSelectionData,
tree_model: *mut *mut GtkTreeModel,
path: *mut *mut GtkTreePath,
) -> gboolean;
}
pub type GtkTreeModelSort = _GtkTreeModelSort;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeModelSortPrivate {
_unused: [u8; 0],
}
pub type GtkTreeModelSortPrivate = _GtkTreeModelSortPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeModelSort {
pub parent: GObject,
pub priv_: *mut GtkTreeModelSortPrivate,
}
#[test]
fn bindgen_test_layout__GtkTreeModelSort() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTreeModelSort> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTreeModelSort>(),
32usize,
concat!("Size of: ", stringify!(_GtkTreeModelSort))
);
assert_eq!(
::std::mem::align_of::<_GtkTreeModelSort>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTreeModelSort))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeModelSort),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeModelSort),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkTreeModelSort {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_tree_model_sort_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_model_sort_new_with_model(child_model: *mut GtkTreeModel) -> *mut GtkTreeModel;
}
extern "C" {
pub fn gtk_tree_model_sort_get_model(tree_model: *mut GtkTreeModelSort) -> *mut GtkTreeModel;
}
extern "C" {
pub fn gtk_tree_model_sort_convert_child_path_to_path(
tree_model_sort: *mut GtkTreeModelSort,
child_path: *mut GtkTreePath,
) -> *mut GtkTreePath;
}
extern "C" {
pub fn gtk_tree_model_sort_convert_child_iter_to_iter(
tree_model_sort: *mut GtkTreeModelSort,
sort_iter: *mut GtkTreeIter,
child_iter: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_model_sort_convert_path_to_child_path(
tree_model_sort: *mut GtkTreeModelSort,
sorted_path: *mut GtkTreePath,
) -> *mut GtkTreePath;
}
extern "C" {
pub fn gtk_tree_model_sort_convert_iter_to_child_iter(
tree_model_sort: *mut GtkTreeModelSort,
child_iter: *mut GtkTreeIter,
sorted_iter: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_tree_model_sort_reset_default_sort_func(tree_model_sort: *mut GtkTreeModelSort);
}
extern "C" {
pub fn gtk_tree_model_sort_clear_cache(tree_model_sort: *mut GtkTreeModelSort);
}
extern "C" {
pub fn gtk_tree_model_sort_iter_is_valid(
tree_model_sort: *mut GtkTreeModelSort,
iter: *mut GtkTreeIter,
) -> gboolean;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeSelectionPrivate {
_unused: [u8; 0],
}
pub type GtkTreeSelectionPrivate = _GtkTreeSelectionPrivate;
#[doc = " GtkTreeSelectionFunc:\n @selection: A #GtkTreeSelection\n @model: A #GtkTreeModel being viewed\n @path: The #GtkTreePath of the row in question\n @path_currently_selected: %TRUE, if the path is currently selected\n @data: (closure): user data\n\n A function used by gtk_tree_selection_set_select_function() to filter\n whether or not a row may be selected. It is called whenever a row's\n state might change. A return value of %TRUE indicates to @selection\n that it is okay to change the selection.\n\n Returns: %TRUE, if the selection state of the row can be toggled"]
pub type GtkTreeSelectionFunc = ::std::option::Option<
unsafe extern "C" fn(
selection: *mut GtkTreeSelection,
model: *mut GtkTreeModel,
path: *mut GtkTreePath,
path_currently_selected: gboolean,
data: gpointer,
) -> gboolean,
>;
#[doc = " GtkTreeSelectionForeachFunc:\n @model: The #GtkTreeModel being viewed\n @path: The #GtkTreePath of a selected row\n @iter: A #GtkTreeIter pointing to a selected row\n @data: (closure): user data\n\n A function used by gtk_tree_selection_selected_foreach() to map all\n selected rows. It will be called on every selected row in the view."]
pub type GtkTreeSelectionForeachFunc = ::std::option::Option<
unsafe extern "C" fn(
model: *mut GtkTreeModel,
path: *mut GtkTreePath,
iter: *mut GtkTreeIter,
data: gpointer,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeSelection {
pub parent: GObject,
pub priv_: *mut GtkTreeSelectionPrivate,
}
#[test]
fn bindgen_test_layout__GtkTreeSelection() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTreeSelection> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTreeSelection>(),
32usize,
concat!("Size of: ", stringify!(_GtkTreeSelection))
);
assert_eq!(
::std::mem::align_of::<_GtkTreeSelection>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTreeSelection))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeSelection),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeSelection),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkTreeSelection {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_tree_selection_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_selection_set_mode(selection: *mut GtkTreeSelection, type_: GtkSelectionMode);
}
extern "C" {
pub fn gtk_tree_selection_get_mode(selection: *mut GtkTreeSelection) -> GtkSelectionMode;
}
extern "C" {
pub fn gtk_tree_selection_set_select_function(
selection: *mut GtkTreeSelection,
func: GtkTreeSelectionFunc,
data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_tree_selection_get_user_data(selection: *mut GtkTreeSelection) -> gpointer;
}
extern "C" {
pub fn gtk_tree_selection_get_tree_view(selection: *mut GtkTreeSelection) -> *mut GtkTreeView;
}
extern "C" {
pub fn gtk_tree_selection_get_select_function(
selection: *mut GtkTreeSelection,
) -> GtkTreeSelectionFunc;
}
extern "C" {
pub fn gtk_tree_selection_get_selected(
selection: *mut GtkTreeSelection,
model: *mut *mut GtkTreeModel,
iter: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_selection_get_selected_rows(
selection: *mut GtkTreeSelection,
model: *mut *mut GtkTreeModel,
) -> *mut GList;
}
extern "C" {
pub fn gtk_tree_selection_count_selected_rows(selection: *mut GtkTreeSelection) -> gint;
}
extern "C" {
pub fn gtk_tree_selection_selected_foreach(
selection: *mut GtkTreeSelection,
func: GtkTreeSelectionForeachFunc,
data: gpointer,
);
}
extern "C" {
pub fn gtk_tree_selection_select_path(selection: *mut GtkTreeSelection, path: *mut GtkTreePath);
}
extern "C" {
pub fn gtk_tree_selection_unselect_path(
selection: *mut GtkTreeSelection,
path: *mut GtkTreePath,
);
}
extern "C" {
pub fn gtk_tree_selection_select_iter(selection: *mut GtkTreeSelection, iter: *mut GtkTreeIter);
}
extern "C" {
pub fn gtk_tree_selection_unselect_iter(
selection: *mut GtkTreeSelection,
iter: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_tree_selection_path_is_selected(
selection: *mut GtkTreeSelection,
path: *mut GtkTreePath,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_selection_iter_is_selected(
selection: *mut GtkTreeSelection,
iter: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_selection_select_all(selection: *mut GtkTreeSelection);
}
extern "C" {
pub fn gtk_tree_selection_unselect_all(selection: *mut GtkTreeSelection);
}
extern "C" {
pub fn gtk_tree_selection_select_range(
selection: *mut GtkTreeSelection,
start_path: *mut GtkTreePath,
end_path: *mut GtkTreePath,
);
}
extern "C" {
pub fn gtk_tree_selection_unselect_range(
selection: *mut GtkTreeSelection,
start_path: *mut GtkTreePath,
end_path: *mut GtkTreePath,
);
}
pub type GtkTreeStore = _GtkTreeStore;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeStorePrivate {
_unused: [u8; 0],
}
pub type GtkTreeStorePrivate = _GtkTreeStorePrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTreeStore {
pub parent: GObject,
pub priv_: *mut GtkTreeStorePrivate,
}
#[test]
fn bindgen_test_layout__GtkTreeStore() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTreeStore> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTreeStore>(),
32usize,
concat!("Size of: ", stringify!(_GtkTreeStore))
);
assert_eq!(
::std::mem::align_of::<_GtkTreeStore>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTreeStore))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeStore),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkTreeStore),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkTreeStore {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_tree_store_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_store_new(n_columns: gint, ...) -> *mut GtkTreeStore;
}
extern "C" {
pub fn gtk_tree_store_newv(n_columns: gint, types: *mut GType) -> *mut GtkTreeStore;
}
extern "C" {
pub fn gtk_tree_store_set_column_types(
tree_store: *mut GtkTreeStore,
n_columns: gint,
types: *mut GType,
);
}
extern "C" {
pub fn gtk_tree_store_set_value(
tree_store: *mut GtkTreeStore,
iter: *mut GtkTreeIter,
column: gint,
value: *mut GValue,
);
}
extern "C" {
pub fn gtk_tree_store_set(tree_store: *mut GtkTreeStore, iter: *mut GtkTreeIter, ...);
}
extern "C" {
pub fn gtk_tree_store_set_valuesv(
tree_store: *mut GtkTreeStore,
iter: *mut GtkTreeIter,
columns: *mut gint,
values: *mut GValue,
n_values: gint,
);
}
extern "C" {
pub fn gtk_tree_store_remove(tree_store: *mut GtkTreeStore, iter: *mut GtkTreeIter)
-> gboolean;
}
extern "C" {
pub fn gtk_tree_store_insert(
tree_store: *mut GtkTreeStore,
iter: *mut GtkTreeIter,
parent: *mut GtkTreeIter,
position: gint,
);
}
extern "C" {
pub fn gtk_tree_store_insert_before(
tree_store: *mut GtkTreeStore,
iter: *mut GtkTreeIter,
parent: *mut GtkTreeIter,
sibling: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_tree_store_insert_after(
tree_store: *mut GtkTreeStore,
iter: *mut GtkTreeIter,
parent: *mut GtkTreeIter,
sibling: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_tree_store_insert_with_values(
tree_store: *mut GtkTreeStore,
iter: *mut GtkTreeIter,
parent: *mut GtkTreeIter,
position: gint,
...
);
}
extern "C" {
pub fn gtk_tree_store_insert_with_valuesv(
tree_store: *mut GtkTreeStore,
iter: *mut GtkTreeIter,
parent: *mut GtkTreeIter,
position: gint,
columns: *mut gint,
values: *mut GValue,
n_values: gint,
);
}
extern "C" {
pub fn gtk_tree_store_prepend(
tree_store: *mut GtkTreeStore,
iter: *mut GtkTreeIter,
parent: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_tree_store_append(
tree_store: *mut GtkTreeStore,
iter: *mut GtkTreeIter,
parent: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_tree_store_is_ancestor(
tree_store: *mut GtkTreeStore,
iter: *mut GtkTreeIter,
descendant: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_store_iter_depth(tree_store: *mut GtkTreeStore, iter: *mut GtkTreeIter)
-> gint;
}
extern "C" {
pub fn gtk_tree_store_clear(tree_store: *mut GtkTreeStore);
}
extern "C" {
pub fn gtk_tree_store_iter_is_valid(
tree_store: *mut GtkTreeStore,
iter: *mut GtkTreeIter,
) -> gboolean;
}
extern "C" {
pub fn gtk_tree_store_reorder(
tree_store: *mut GtkTreeStore,
parent: *mut GtkTreeIter,
new_order: *mut gint,
);
}
extern "C" {
pub fn gtk_tree_store_swap(
tree_store: *mut GtkTreeStore,
a: *mut GtkTreeIter,
b: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_tree_store_move_before(
tree_store: *mut GtkTreeStore,
iter: *mut GtkTreeIter,
position: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_tree_store_move_after(
tree_store: *mut GtkTreeStore,
iter: *mut GtkTreeIter,
position: *mut GtkTreeIter,
);
}
extern "C" {
pub fn gtk_license_get_type() -> GType;
}
extern "C" {
pub fn gtk_accel_flags_get_type() -> GType;
}
extern "C" {
pub fn gtk_application_inhibit_flags_get_type() -> GType;
}
extern "C" {
pub fn gtk_assistant_page_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_button_box_style_get_type() -> GType;
}
extern "C" {
pub fn gtk_builder_error_get_type() -> GType;
}
extern "C" {
pub fn gtk_calendar_display_options_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_renderer_state_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_renderer_mode_get_type() -> GType;
}
extern "C" {
pub fn gtk_cell_renderer_accel_mode_get_type() -> GType;
}
extern "C" {
pub fn gtk_resize_mode_get_type() -> GType;
}
extern "C" {
pub fn gtk_css_provider_error_get_type() -> GType;
}
extern "C" {
pub fn gtk_css_section_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_debug_flag_get_type() -> GType;
}
extern "C" {
pub fn gtk_dialog_flags_get_type() -> GType;
}
extern "C" {
pub fn gtk_response_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_dest_defaults_get_type() -> GType;
}
extern "C" {
pub fn gtk_target_flags_get_type() -> GType;
}
extern "C" {
pub fn gtk_entry_icon_position_get_type() -> GType;
}
extern "C" {
pub fn gtk_align_get_type() -> GType;
}
extern "C" {
pub fn gtk_arrow_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_baseline_position_get_type() -> GType;
}
extern "C" {
pub fn gtk_delete_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_direction_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_icon_size_get_type() -> GType;
}
extern "C" {
pub fn gtk_sensitivity_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_text_direction_get_type() -> GType;
}
extern "C" {
pub fn gtk_justification_get_type() -> GType;
}
extern "C" {
pub fn gtk_menu_direction_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_message_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_movement_step_get_type() -> GType;
}
extern "C" {
pub fn gtk_scroll_step_get_type() -> GType;
}
extern "C" {
pub fn gtk_orientation_get_type() -> GType;
}
extern "C" {
pub fn gtk_pack_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_position_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_relief_style_get_type() -> GType;
}
extern "C" {
pub fn gtk_scroll_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_selection_mode_get_type() -> GType;
}
extern "C" {
pub fn gtk_shadow_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_state_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_toolbar_style_get_type() -> GType;
}
extern "C" {
pub fn gtk_wrap_mode_get_type() -> GType;
}
extern "C" {
pub fn gtk_sort_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_im_preedit_style_get_type() -> GType;
}
extern "C" {
pub fn gtk_im_status_style_get_type() -> GType;
}
extern "C" {
pub fn gtk_pack_direction_get_type() -> GType;
}
extern "C" {
pub fn gtk_print_pages_get_type() -> GType;
}
extern "C" {
pub fn gtk_page_set_get_type() -> GType;
}
extern "C" {
pub fn gtk_number_up_layout_get_type() -> GType;
}
extern "C" {
pub fn gtk_page_orientation_get_type() -> GType;
}
extern "C" {
pub fn gtk_print_quality_get_type() -> GType;
}
extern "C" {
pub fn gtk_print_duplex_get_type() -> GType;
}
extern "C" {
pub fn gtk_unit_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_view_grid_lines_get_type() -> GType;
}
extern "C" {
pub fn gtk_drag_result_get_type() -> GType;
}
extern "C" {
pub fn gtk_size_group_mode_get_type() -> GType;
}
extern "C" {
pub fn gtk_size_request_mode_get_type() -> GType;
}
extern "C" {
pub fn gtk_scrollable_policy_get_type() -> GType;
}
extern "C" {
pub fn gtk_state_flags_get_type() -> GType;
}
extern "C" {
pub fn gtk_region_flags_get_type() -> GType;
}
extern "C" {
pub fn gtk_junction_sides_get_type() -> GType;
}
extern "C" {
pub fn gtk_border_style_get_type() -> GType;
}
extern "C" {
pub fn gtk_level_bar_mode_get_type() -> GType;
}
extern "C" {
pub fn gtk_input_purpose_get_type() -> GType;
}
extern "C" {
pub fn gtk_input_hints_get_type() -> GType;
}
extern "C" {
pub fn gtk_propagation_phase_get_type() -> GType;
}
extern "C" {
pub fn gtk_event_sequence_state_get_type() -> GType;
}
extern "C" {
pub fn gtk_pan_direction_get_type() -> GType;
}
extern "C" {
pub fn gtk_file_chooser_action_get_type() -> GType;
}
extern "C" {
pub fn gtk_file_chooser_confirmation_get_type() -> GType;
}
extern "C" {
pub fn gtk_file_chooser_error_get_type() -> GType;
}
extern "C" {
pub fn gtk_file_filter_flags_get_type() -> GType;
}
extern "C" {
pub fn gtk_icon_lookup_flags_get_type() -> GType;
}
extern "C" {
pub fn gtk_icon_theme_error_get_type() -> GType;
}
extern "C" {
pub fn gtk_icon_view_drop_position_get_type() -> GType;
}
extern "C" {
pub fn gtk_image_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_arrow_placement_get_type() -> GType;
}
extern "C" {
pub fn gtk_buttons_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_notebook_tab_get_type() -> GType;
}
extern "C" {
pub fn gtk_places_open_flags_get_type() -> GType;
}
extern "C" {
pub fn gtk_print_status_get_type() -> GType;
}
extern "C" {
pub fn gtk_print_operation_result_get_type() -> GType;
}
extern "C" {
pub fn gtk_print_operation_action_get_type() -> GType;
}
extern "C" {
pub fn gtk_print_error_get_type() -> GType;
}
extern "C" {
pub fn gtk_recent_sort_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_recent_chooser_error_get_type() -> GType;
}
extern "C" {
pub fn gtk_recent_filter_flags_get_type() -> GType;
}
extern "C" {
pub fn gtk_recent_manager_error_get_type() -> GType;
}
extern "C" {
pub fn gtk_revealer_transition_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_corner_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_policy_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_spin_button_update_policy_get_type() -> GType;
}
extern "C" {
pub fn gtk_spin_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_stack_transition_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_text_buffer_target_info_get_type() -> GType;
}
extern "C" {
pub fn gtk_text_search_flags_get_type() -> GType;
}
extern "C" {
pub fn gtk_text_window_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_text_view_layer_get_type() -> GType;
}
extern "C" {
pub fn gtk_toolbar_space_style_get_type() -> GType;
}
extern "C" {
pub fn gtk_tool_palette_drag_targets_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_model_flags_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_view_drop_position_get_type() -> GType;
}
extern "C" {
pub fn gtk_tree_view_column_sizing_get_type() -> GType;
}
extern "C" {
pub fn gtk_widget_help_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_window_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_window_position_get_type() -> GType;
}
extern "C" {
pub fn gtk_rc_flags_get_type() -> GType;
}
extern "C" {
pub fn gtk_rc_token_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_path_priority_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_path_type_get_type() -> GType;
}
extern "C" {
pub fn gtk_expander_style_get_type() -> GType;
}
extern "C" {
pub fn gtk_attach_options_get_type() -> GType;
}
extern "C" {
pub fn gtk_ui_manager_item_type_get_type() -> GType;
}
pub type GtkViewport = _GtkViewport;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkViewportPrivate {
_unused: [u8; 0],
}
pub type GtkViewportPrivate = _GtkViewportPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkViewport {
pub bin: GtkBin,
pub priv_: *mut GtkViewportPrivate,
}
#[test]
fn bindgen_test_layout__GtkViewport() {
const UNINIT: ::std::mem::MaybeUninit<_GtkViewport> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkViewport>(),
56usize,
concat!("Size of: ", stringify!(_GtkViewport))
);
assert_eq!(
::std::mem::align_of::<_GtkViewport>(),
8usize,
concat!("Alignment of ", stringify!(_GtkViewport))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bin) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkViewport),
"::",
stringify!(bin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkViewport),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkViewport {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_viewport_get_type() -> GType;
}
extern "C" {
pub fn gtk_viewport_new(
hadjustment: *mut GtkAdjustment,
vadjustment: *mut GtkAdjustment,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_viewport_get_hadjustment(viewport: *mut GtkViewport) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_viewport_get_vadjustment(viewport: *mut GtkViewport) -> *mut GtkAdjustment;
}
extern "C" {
pub fn gtk_viewport_set_hadjustment(viewport: *mut GtkViewport, adjustment: *mut GtkAdjustment);
}
extern "C" {
pub fn gtk_viewport_set_vadjustment(viewport: *mut GtkViewport, adjustment: *mut GtkAdjustment);
}
extern "C" {
pub fn gtk_viewport_set_shadow_type(viewport: *mut GtkViewport, type_: GtkShadowType);
}
extern "C" {
pub fn gtk_viewport_get_shadow_type(viewport: *mut GtkViewport) -> GtkShadowType;
}
extern "C" {
pub fn gtk_viewport_get_bin_window(viewport: *mut GtkViewport) -> *mut GdkWindow;
}
extern "C" {
pub fn gtk_viewport_get_view_window(viewport: *mut GtkViewport) -> *mut GdkWindow;
}
extern "C" {
pub fn gtk_volume_button_get_type() -> GType;
}
extern "C" {
pub fn gtk_volume_button_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_widget_path_get_type() -> GType;
}
extern "C" {
pub fn gtk_widget_path_new() -> *mut GtkWidgetPath;
}
extern "C" {
pub fn gtk_widget_path_copy(path: *const GtkWidgetPath) -> *mut GtkWidgetPath;
}
extern "C" {
pub fn gtk_widget_path_ref(path: *mut GtkWidgetPath) -> *mut GtkWidgetPath;
}
extern "C" {
pub fn gtk_widget_path_unref(path: *mut GtkWidgetPath);
}
extern "C" {
pub fn gtk_widget_path_free(path: *mut GtkWidgetPath);
}
extern "C" {
pub fn gtk_widget_path_to_string(path: *const GtkWidgetPath) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn gtk_widget_path_length(path: *const GtkWidgetPath) -> gint;
}
extern "C" {
pub fn gtk_widget_path_append_type(path: *mut GtkWidgetPath, type_: GType) -> gint;
}
extern "C" {
pub fn gtk_widget_path_prepend_type(path: *mut GtkWidgetPath, type_: GType);
}
extern "C" {
pub fn gtk_widget_path_append_with_siblings(
path: *mut GtkWidgetPath,
siblings: *mut GtkWidgetPath,
sibling_index: guint,
) -> gint;
}
extern "C" {
pub fn gtk_widget_path_append_for_widget(
path: *mut GtkWidgetPath,
widget: *mut GtkWidget,
) -> gint;
}
extern "C" {
pub fn gtk_widget_path_iter_get_object_type(path: *const GtkWidgetPath, pos: gint) -> GType;
}
extern "C" {
pub fn gtk_widget_path_iter_set_object_type(path: *mut GtkWidgetPath, pos: gint, type_: GType);
}
extern "C" {
pub fn gtk_widget_path_iter_get_siblings(
path: *const GtkWidgetPath,
pos: gint,
) -> *const GtkWidgetPath;
}
extern "C" {
pub fn gtk_widget_path_iter_get_sibling_index(path: *const GtkWidgetPath, pos: gint) -> guint;
}
extern "C" {
pub fn gtk_widget_path_iter_get_name(path: *const GtkWidgetPath, pos: gint) -> *const gchar;
}
extern "C" {
pub fn gtk_widget_path_iter_set_name(path: *mut GtkWidgetPath, pos: gint, name: *const gchar);
}
extern "C" {
pub fn gtk_widget_path_iter_has_name(
path: *const GtkWidgetPath,
pos: gint,
name: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_widget_path_iter_has_qname(
path: *const GtkWidgetPath,
pos: gint,
qname: GQuark,
) -> gboolean;
}
extern "C" {
pub fn gtk_widget_path_iter_get_state(path: *const GtkWidgetPath, pos: gint) -> GtkStateFlags;
}
extern "C" {
pub fn gtk_widget_path_iter_set_state(
path: *mut GtkWidgetPath,
pos: gint,
state: GtkStateFlags,
);
}
extern "C" {
pub fn gtk_widget_path_iter_add_class(path: *mut GtkWidgetPath, pos: gint, name: *const gchar);
}
extern "C" {
pub fn gtk_widget_path_iter_remove_class(
path: *mut GtkWidgetPath,
pos: gint,
name: *const gchar,
);
}
extern "C" {
pub fn gtk_widget_path_iter_clear_classes(path: *mut GtkWidgetPath, pos: gint);
}
extern "C" {
pub fn gtk_widget_path_iter_list_classes(path: *const GtkWidgetPath, pos: gint) -> *mut GSList;
}
extern "C" {
pub fn gtk_widget_path_iter_has_class(
path: *const GtkWidgetPath,
pos: gint,
name: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_widget_path_iter_has_qclass(
path: *const GtkWidgetPath,
pos: gint,
qname: GQuark,
) -> gboolean;
}
extern "C" {
pub fn gtk_widget_path_iter_add_region(
path: *mut GtkWidgetPath,
pos: gint,
name: *const gchar,
flags: GtkRegionFlags,
);
}
extern "C" {
pub fn gtk_widget_path_iter_remove_region(
path: *mut GtkWidgetPath,
pos: gint,
name: *const gchar,
);
}
extern "C" {
pub fn gtk_widget_path_iter_clear_regions(path: *mut GtkWidgetPath, pos: gint);
}
extern "C" {
pub fn gtk_widget_path_iter_list_regions(path: *const GtkWidgetPath, pos: gint) -> *mut GSList;
}
extern "C" {
pub fn gtk_widget_path_iter_has_region(
path: *const GtkWidgetPath,
pos: gint,
name: *const gchar,
flags: *mut GtkRegionFlags,
) -> gboolean;
}
extern "C" {
pub fn gtk_widget_path_iter_has_qregion(
path: *const GtkWidgetPath,
pos: gint,
qname: GQuark,
flags: *mut GtkRegionFlags,
) -> gboolean;
}
extern "C" {
pub fn gtk_widget_path_get_object_type(path: *const GtkWidgetPath) -> GType;
}
extern "C" {
pub fn gtk_widget_path_is_type(path: *const GtkWidgetPath, type_: GType) -> gboolean;
}
extern "C" {
pub fn gtk_widget_path_has_parent(path: *const GtkWidgetPath, type_: GType) -> gboolean;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkWindowGroup {
pub parent_instance: GObject,
pub priv_: *mut GtkWindowGroupPrivate,
}
#[test]
fn bindgen_test_layout__GtkWindowGroup() {
const UNINIT: ::std::mem::MaybeUninit<_GtkWindowGroup> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkWindowGroup>(),
32usize,
concat!("Size of: ", stringify!(_GtkWindowGroup))
);
assert_eq!(
::std::mem::align_of::<_GtkWindowGroup>(),
8usize,
concat!("Alignment of ", stringify!(_GtkWindowGroup))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkWindowGroup),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkWindowGroup),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkWindowGroup {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_window_group_get_type() -> GType;
}
extern "C" {
pub fn gtk_window_group_new() -> *mut GtkWindowGroup;
}
extern "C" {
pub fn gtk_window_group_add_window(window_group: *mut GtkWindowGroup, window: *mut GtkWindow);
}
extern "C" {
pub fn gtk_window_group_remove_window(
window_group: *mut GtkWindowGroup,
window: *mut GtkWindow,
);
}
extern "C" {
pub fn gtk_window_group_list_windows(window_group: *mut GtkWindowGroup) -> *mut GList;
}
extern "C" {
pub fn gtk_window_group_get_current_grab(window_group: *mut GtkWindowGroup) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_window_group_get_current_device_grab(
window_group: *mut GtkWindowGroup,
device: *mut GdkDevice,
) -> *mut GtkWidget;
}
pub type GtkArrow = _GtkArrow;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkArrowPrivate {
_unused: [u8; 0],
}
pub type GtkArrowPrivate = _GtkArrowPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkArrow {
pub misc: GtkMisc,
pub priv_: *mut GtkArrowPrivate,
}
#[test]
fn bindgen_test_layout__GtkArrow() {
const UNINIT: ::std::mem::MaybeUninit<_GtkArrow> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkArrow>(),
48usize,
concat!("Size of: ", stringify!(_GtkArrow))
);
assert_eq!(
::std::mem::align_of::<_GtkArrow>(),
8usize,
concat!("Alignment of ", stringify!(_GtkArrow))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).misc) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkArrow),
"::",
stringify!(misc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkArrow),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkArrow {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_arrow_get_type() -> GType;
}
extern "C" {
pub fn gtk_arrow_new(arrow_type: GtkArrowType, shadow_type: GtkShadowType) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_arrow_set(
arrow: *mut GtkArrow,
arrow_type: GtkArrowType,
shadow_type: GtkShadowType,
);
}
pub type GtkAction = _GtkAction;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkActionPrivate {
_unused: [u8; 0],
}
pub type GtkActionPrivate = _GtkActionPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAction {
pub object: GObject,
pub private_data: *mut GtkActionPrivate,
}
#[test]
fn bindgen_test_layout__GtkAction() {
const UNINIT: ::std::mem::MaybeUninit<_GtkAction> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkAction>(),
32usize,
concat!("Size of: ", stringify!(_GtkAction))
);
assert_eq!(
::std::mem::align_of::<_GtkAction>(),
8usize,
concat!("Alignment of ", stringify!(_GtkAction))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).object) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkAction),
"::",
stringify!(object)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).private_data) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkAction),
"::",
stringify!(private_data)
)
);
}
impl Default for _GtkAction {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_action_get_type() -> GType;
}
extern "C" {
pub fn gtk_action_new(
name: *const gchar,
label: *const gchar,
tooltip: *const gchar,
stock_id: *const gchar,
) -> *mut GtkAction;
}
extern "C" {
pub fn gtk_action_get_name(action: *mut GtkAction) -> *const gchar;
}
extern "C" {
pub fn gtk_action_is_sensitive(action: *mut GtkAction) -> gboolean;
}
extern "C" {
pub fn gtk_action_get_sensitive(action: *mut GtkAction) -> gboolean;
}
extern "C" {
pub fn gtk_action_set_sensitive(action: *mut GtkAction, sensitive: gboolean);
}
extern "C" {
pub fn gtk_action_is_visible(action: *mut GtkAction) -> gboolean;
}
extern "C" {
pub fn gtk_action_get_visible(action: *mut GtkAction) -> gboolean;
}
extern "C" {
pub fn gtk_action_set_visible(action: *mut GtkAction, visible: gboolean);
}
extern "C" {
pub fn gtk_action_activate(action: *mut GtkAction);
}
extern "C" {
pub fn gtk_action_create_icon(action: *mut GtkAction, icon_size: GtkIconSize)
-> *mut GtkWidget;
}
extern "C" {
pub fn gtk_action_create_menu_item(action: *mut GtkAction) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_action_create_tool_item(action: *mut GtkAction) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_action_create_menu(action: *mut GtkAction) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_action_get_proxies(action: *mut GtkAction) -> *mut GSList;
}
extern "C" {
pub fn gtk_action_connect_accelerator(action: *mut GtkAction);
}
extern "C" {
pub fn gtk_action_disconnect_accelerator(action: *mut GtkAction);
}
extern "C" {
pub fn gtk_action_get_accel_path(action: *mut GtkAction) -> *const gchar;
}
extern "C" {
pub fn gtk_action_get_accel_closure(action: *mut GtkAction) -> *mut GClosure;
}
extern "C" {
pub fn gtk_action_block_activate(action: *mut GtkAction);
}
extern "C" {
pub fn gtk_action_unblock_activate(action: *mut GtkAction);
}
extern "C" {
pub fn gtk_action_set_accel_path(action: *mut GtkAction, accel_path: *const gchar);
}
extern "C" {
pub fn gtk_action_set_accel_group(action: *mut GtkAction, accel_group: *mut GtkAccelGroup);
}
extern "C" {
pub fn gtk_action_set_label(action: *mut GtkAction, label: *const gchar);
}
extern "C" {
pub fn gtk_action_get_label(action: *mut GtkAction) -> *const gchar;
}
extern "C" {
pub fn gtk_action_set_short_label(action: *mut GtkAction, short_label: *const gchar);
}
extern "C" {
pub fn gtk_action_get_short_label(action: *mut GtkAction) -> *const gchar;
}
extern "C" {
pub fn gtk_action_set_tooltip(action: *mut GtkAction, tooltip: *const gchar);
}
extern "C" {
pub fn gtk_action_get_tooltip(action: *mut GtkAction) -> *const gchar;
}
extern "C" {
pub fn gtk_action_set_stock_id(action: *mut GtkAction, stock_id: *const gchar);
}
extern "C" {
pub fn gtk_action_get_stock_id(action: *mut GtkAction) -> *const gchar;
}
extern "C" {
pub fn gtk_action_set_gicon(action: *mut GtkAction, icon: *mut GIcon);
}
extern "C" {
pub fn gtk_action_get_gicon(action: *mut GtkAction) -> *mut GIcon;
}
extern "C" {
pub fn gtk_action_set_icon_name(action: *mut GtkAction, icon_name: *const gchar);
}
extern "C" {
pub fn gtk_action_get_icon_name(action: *mut GtkAction) -> *const gchar;
}
extern "C" {
pub fn gtk_action_set_visible_horizontal(action: *mut GtkAction, visible_horizontal: gboolean);
}
extern "C" {
pub fn gtk_action_get_visible_horizontal(action: *mut GtkAction) -> gboolean;
}
extern "C" {
pub fn gtk_action_set_visible_vertical(action: *mut GtkAction, visible_vertical: gboolean);
}
extern "C" {
pub fn gtk_action_get_visible_vertical(action: *mut GtkAction) -> gboolean;
}
extern "C" {
pub fn gtk_action_set_is_important(action: *mut GtkAction, is_important: gboolean);
}
extern "C" {
pub fn gtk_action_get_is_important(action: *mut GtkAction) -> gboolean;
}
extern "C" {
pub fn gtk_action_set_always_show_image(action: *mut GtkAction, always_show: gboolean);
}
extern "C" {
pub fn gtk_action_get_always_show_image(action: *mut GtkAction) -> gboolean;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkActivatable {
_unused: [u8; 0],
}
pub type GtkActivatable = _GtkActivatable;
extern "C" {
pub fn gtk_activatable_get_type() -> GType;
}
extern "C" {
pub fn gtk_activatable_sync_action_properties(
activatable: *mut GtkActivatable,
action: *mut GtkAction,
);
}
extern "C" {
pub fn gtk_activatable_set_related_action(
activatable: *mut GtkActivatable,
action: *mut GtkAction,
);
}
extern "C" {
pub fn gtk_activatable_get_related_action(activatable: *mut GtkActivatable) -> *mut GtkAction;
}
extern "C" {
pub fn gtk_activatable_set_use_action_appearance(
activatable: *mut GtkActivatable,
use_appearance: gboolean,
);
}
extern "C" {
pub fn gtk_activatable_get_use_action_appearance(activatable: *mut GtkActivatable) -> gboolean;
}
extern "C" {
pub fn gtk_activatable_do_set_related_action(
activatable: *mut GtkActivatable,
action: *mut GtkAction,
);
}
#[doc = " GtkTranslateFunc:\n @path: The id of the message. In #GtkActionGroup this will be a label\n or tooltip from a #GtkActionEntry.\n @func_data: (closure): user data passed in when registering the\n function\n\n The function used to translate messages in e.g. #GtkIconFactory\n and #GtkActionGroup.\n\n Returns: the translated message\n\n Deprecated: 3.10"]
pub type GtkTranslateFunc = ::std::option::Option<
unsafe extern "C" fn(path: *const gchar, func_data: gpointer) -> *mut gchar,
>;
#[doc = " GtkStockItem:\n @stock_id: Identifier.\n @label: User visible label.\n @modifier: Modifier type for keyboard accelerator\n @keyval: Keyboard accelerator\n @translation_domain: Translation domain of the menu or toolbar item\n\n Deprecated: 3.10"]
pub type GtkStockItem = _GtkStockItem;
#[doc = " GtkStockItem:\n @stock_id: Identifier.\n @label: User visible label.\n @modifier: Modifier type for keyboard accelerator\n @keyval: Keyboard accelerator\n @translation_domain: Translation domain of the menu or toolbar item\n\n Deprecated: 3.10"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkStockItem {
pub stock_id: *mut gchar,
pub label: *mut gchar,
pub modifier: GdkModifierType,
pub keyval: guint,
pub translation_domain: *mut gchar,
}
#[test]
fn bindgen_test_layout__GtkStockItem() {
const UNINIT: ::std::mem::MaybeUninit<_GtkStockItem> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkStockItem>(),
32usize,
concat!("Size of: ", stringify!(_GtkStockItem))
);
assert_eq!(
::std::mem::align_of::<_GtkStockItem>(),
8usize,
concat!("Alignment of ", stringify!(_GtkStockItem))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stock_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkStockItem),
"::",
stringify!(stock_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkStockItem),
"::",
stringify!(label)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).modifier) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GtkStockItem),
"::",
stringify!(modifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).keyval) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_GtkStockItem),
"::",
stringify!(keyval)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).translation_domain) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkStockItem),
"::",
stringify!(translation_domain)
)
);
}
impl Default for _GtkStockItem {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_stock_add(items: *const GtkStockItem, n_items: guint);
}
extern "C" {
pub fn gtk_stock_add_static(items: *const GtkStockItem, n_items: guint);
}
extern "C" {
pub fn gtk_stock_lookup(stock_id: *const gchar, item: *mut GtkStockItem) -> gboolean;
}
extern "C" {
pub fn gtk_stock_list_ids() -> *mut GSList;
}
extern "C" {
pub fn gtk_stock_item_copy(item: *const GtkStockItem) -> *mut GtkStockItem;
}
extern "C" {
pub fn gtk_stock_item_free(item: *mut GtkStockItem);
}
extern "C" {
pub fn gtk_stock_set_translate_func(
domain: *const gchar,
func: GtkTranslateFunc,
data: gpointer,
notify: GDestroyNotify,
);
}
pub type GtkActionGroup = _GtkActionGroup;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkActionGroupPrivate {
_unused: [u8; 0],
}
pub type GtkActionGroupPrivate = _GtkActionGroupPrivate;
#[doc = " GtkActionEntry:\n @name: The name of the action.\n @stock_id: The stock id for the action, or the name of an icon from the\n icon theme.\n @label: The label for the action. This field should typically be marked\n for translation, see gtk_action_group_set_translation_domain(). If\n @label is %NULL, the label of the stock item with id @stock_id is used.\n @accelerator: The accelerator for the action, in the format understood by\n gtk_accelerator_parse().\n @tooltip: The tooltip for the action. This field should typically be\n marked for translation, see gtk_action_group_set_translation_domain().\n @callback: The function to call when the action is activated.\n\n #GtkActionEntry structs are used with gtk_action_group_add_actions() to\n construct actions.\n\n Deprecated: 3.10"]
pub type GtkActionEntry = _GtkActionEntry;
#[doc = " GtkToggleActionEntry:\n @name: The name of the action.\n @stock_id: The stock id for the action, or the name of an icon from the\n icon theme.\n @label: The label for the action. This field should typically be marked\n for translation, see gtk_action_group_set_translation_domain().\n @accelerator: The accelerator for the action, in the format understood by\n gtk_accelerator_parse().\n @tooltip: The tooltip for the action. This field should typically be\n marked for translation, see gtk_action_group_set_translation_domain().\n @callback: The function to call when the action is activated.\n @is_active: The initial state of the toggle action.\n\n #GtkToggleActionEntry structs are used with\n gtk_action_group_add_toggle_actions() to construct toggle actions.\n\n Deprecated: 3.10"]
pub type GtkToggleActionEntry = _GtkToggleActionEntry;
#[doc = " GtkRadioActionEntry:\n @name: The name of the action.\n @stock_id: The stock id for the action, or the name of an icon from the\n icon theme.\n @label: The label for the action. This field should typically be marked\n for translation, see gtk_action_group_set_translation_domain().\n @accelerator: The accelerator for the action, in the format understood by\n gtk_accelerator_parse().\n @tooltip: The tooltip for the action. This field should typically be\n marked for translation, see gtk_action_group_set_translation_domain().\n @value: The value to set on the radio action. See\n gtk_radio_action_get_current_value().\n\n #GtkRadioActionEntry structs are used with\n gtk_action_group_add_radio_actions() to construct groups of radio actions.\n\n Deprecated: 3.10"]
pub type GtkRadioActionEntry = _GtkRadioActionEntry;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkActionGroup {
pub parent: GObject,
pub priv_: *mut GtkActionGroupPrivate,
}
#[test]
fn bindgen_test_layout__GtkActionGroup() {
const UNINIT: ::std::mem::MaybeUninit<_GtkActionGroup> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkActionGroup>(),
32usize,
concat!("Size of: ", stringify!(_GtkActionGroup))
);
assert_eq!(
::std::mem::align_of::<_GtkActionGroup>(),
8usize,
concat!("Alignment of ", stringify!(_GtkActionGroup))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkActionGroup),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkActionGroup),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkActionGroup {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GtkActionEntry:\n @name: The name of the action.\n @stock_id: The stock id for the action, or the name of an icon from the\n icon theme.\n @label: The label for the action. This field should typically be marked\n for translation, see gtk_action_group_set_translation_domain(). If\n @label is %NULL, the label of the stock item with id @stock_id is used.\n @accelerator: The accelerator for the action, in the format understood by\n gtk_accelerator_parse().\n @tooltip: The tooltip for the action. This field should typically be\n marked for translation, see gtk_action_group_set_translation_domain().\n @callback: The function to call when the action is activated.\n\n #GtkActionEntry structs are used with gtk_action_group_add_actions() to\n construct actions.\n\n Deprecated: 3.10"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkActionEntry {
pub name: *const gchar,
pub stock_id: *const gchar,
pub label: *const gchar,
pub accelerator: *const gchar,
pub tooltip: *const gchar,
pub callback: GCallback,
}
#[test]
fn bindgen_test_layout__GtkActionEntry() {
const UNINIT: ::std::mem::MaybeUninit<_GtkActionEntry> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkActionEntry>(),
48usize,
concat!("Size of: ", stringify!(_GtkActionEntry))
);
assert_eq!(
::std::mem::align_of::<_GtkActionEntry>(),
8usize,
concat!("Alignment of ", stringify!(_GtkActionEntry))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkActionEntry),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stock_id) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkActionEntry),
"::",
stringify!(stock_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GtkActionEntry),
"::",
stringify!(label)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).accelerator) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkActionEntry),
"::",
stringify!(accelerator)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tooltip) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkActionEntry),
"::",
stringify!(tooltip)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).callback) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkActionEntry),
"::",
stringify!(callback)
)
);
}
impl Default for _GtkActionEntry {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GtkToggleActionEntry:\n @name: The name of the action.\n @stock_id: The stock id for the action, or the name of an icon from the\n icon theme.\n @label: The label for the action. This field should typically be marked\n for translation, see gtk_action_group_set_translation_domain().\n @accelerator: The accelerator for the action, in the format understood by\n gtk_accelerator_parse().\n @tooltip: The tooltip for the action. This field should typically be\n marked for translation, see gtk_action_group_set_translation_domain().\n @callback: The function to call when the action is activated.\n @is_active: The initial state of the toggle action.\n\n #GtkToggleActionEntry structs are used with\n gtk_action_group_add_toggle_actions() to construct toggle actions.\n\n Deprecated: 3.10"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToggleActionEntry {
pub name: *const gchar,
pub stock_id: *const gchar,
pub label: *const gchar,
pub accelerator: *const gchar,
pub tooltip: *const gchar,
pub callback: GCallback,
pub is_active: gboolean,
}
#[test]
fn bindgen_test_layout__GtkToggleActionEntry() {
const UNINIT: ::std::mem::MaybeUninit<_GtkToggleActionEntry> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkToggleActionEntry>(),
56usize,
concat!("Size of: ", stringify!(_GtkToggleActionEntry))
);
assert_eq!(
::std::mem::align_of::<_GtkToggleActionEntry>(),
8usize,
concat!("Alignment of ", stringify!(_GtkToggleActionEntry))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkToggleActionEntry),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stock_id) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkToggleActionEntry),
"::",
stringify!(stock_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GtkToggleActionEntry),
"::",
stringify!(label)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).accelerator) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkToggleActionEntry),
"::",
stringify!(accelerator)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tooltip) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkToggleActionEntry),
"::",
stringify!(tooltip)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).callback) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkToggleActionEntry),
"::",
stringify!(callback)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_active) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkToggleActionEntry),
"::",
stringify!(is_active)
)
);
}
impl Default for _GtkToggleActionEntry {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " GtkRadioActionEntry:\n @name: The name of the action.\n @stock_id: The stock id for the action, or the name of an icon from the\n icon theme.\n @label: The label for the action. This field should typically be marked\n for translation, see gtk_action_group_set_translation_domain().\n @accelerator: The accelerator for the action, in the format understood by\n gtk_accelerator_parse().\n @tooltip: The tooltip for the action. This field should typically be\n marked for translation, see gtk_action_group_set_translation_domain().\n @value: The value to set on the radio action. See\n gtk_radio_action_get_current_value().\n\n #GtkRadioActionEntry structs are used with\n gtk_action_group_add_radio_actions() to construct groups of radio actions.\n\n Deprecated: 3.10"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRadioActionEntry {
pub name: *const gchar,
pub stock_id: *const gchar,
pub label: *const gchar,
pub accelerator: *const gchar,
pub tooltip: *const gchar,
pub value: gint,
}
#[test]
fn bindgen_test_layout__GtkRadioActionEntry() {
const UNINIT: ::std::mem::MaybeUninit<_GtkRadioActionEntry> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkRadioActionEntry>(),
48usize,
concat!("Size of: ", stringify!(_GtkRadioActionEntry))
);
assert_eq!(
::std::mem::align_of::<_GtkRadioActionEntry>(),
8usize,
concat!("Alignment of ", stringify!(_GtkRadioActionEntry))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkRadioActionEntry),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stock_id) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GtkRadioActionEntry),
"::",
stringify!(stock_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_GtkRadioActionEntry),
"::",
stringify!(label)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).accelerator) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkRadioActionEntry),
"::",
stringify!(accelerator)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tooltip) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkRadioActionEntry),
"::",
stringify!(tooltip)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkRadioActionEntry),
"::",
stringify!(value)
)
);
}
impl Default for _GtkRadioActionEntry {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_action_group_get_type() -> GType;
}
extern "C" {
pub fn gtk_action_group_new(name: *const gchar) -> *mut GtkActionGroup;
}
extern "C" {
pub fn gtk_action_group_get_name(action_group: *mut GtkActionGroup) -> *const gchar;
}
extern "C" {
pub fn gtk_action_group_get_sensitive(action_group: *mut GtkActionGroup) -> gboolean;
}
extern "C" {
pub fn gtk_action_group_set_sensitive(action_group: *mut GtkActionGroup, sensitive: gboolean);
}
extern "C" {
pub fn gtk_action_group_get_visible(action_group: *mut GtkActionGroup) -> gboolean;
}
extern "C" {
pub fn gtk_action_group_set_visible(action_group: *mut GtkActionGroup, visible: gboolean);
}
extern "C" {
pub fn gtk_action_group_get_accel_group(
action_group: *mut GtkActionGroup,
) -> *mut GtkAccelGroup;
}
extern "C" {
pub fn gtk_action_group_set_accel_group(
action_group: *mut GtkActionGroup,
accel_group: *mut GtkAccelGroup,
);
}
extern "C" {
pub fn gtk_action_group_get_action(
action_group: *mut GtkActionGroup,
action_name: *const gchar,
) -> *mut GtkAction;
}
extern "C" {
pub fn gtk_action_group_list_actions(action_group: *mut GtkActionGroup) -> *mut GList;
}
extern "C" {
pub fn gtk_action_group_add_action(action_group: *mut GtkActionGroup, action: *mut GtkAction);
}
extern "C" {
pub fn gtk_action_group_add_action_with_accel(
action_group: *mut GtkActionGroup,
action: *mut GtkAction,
accelerator: *const gchar,
);
}
extern "C" {
pub fn gtk_action_group_remove_action(
action_group: *mut GtkActionGroup,
action: *mut GtkAction,
);
}
extern "C" {
pub fn gtk_action_group_add_actions(
action_group: *mut GtkActionGroup,
entries: *const GtkActionEntry,
n_entries: guint,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_action_group_add_toggle_actions(
action_group: *mut GtkActionGroup,
entries: *const GtkToggleActionEntry,
n_entries: guint,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_action_group_add_radio_actions(
action_group: *mut GtkActionGroup,
entries: *const GtkRadioActionEntry,
n_entries: guint,
value: gint,
on_change: GCallback,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_action_group_add_actions_full(
action_group: *mut GtkActionGroup,
entries: *const GtkActionEntry,
n_entries: guint,
user_data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_action_group_add_toggle_actions_full(
action_group: *mut GtkActionGroup,
entries: *const GtkToggleActionEntry,
n_entries: guint,
user_data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_action_group_add_radio_actions_full(
action_group: *mut GtkActionGroup,
entries: *const GtkRadioActionEntry,
n_entries: guint,
value: gint,
on_change: GCallback,
user_data: gpointer,
destroy: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_action_group_set_translate_func(
action_group: *mut GtkActionGroup,
func: GtkTranslateFunc,
data: gpointer,
notify: GDestroyNotify,
);
}
extern "C" {
pub fn gtk_action_group_set_translation_domain(
action_group: *mut GtkActionGroup,
domain: *const gchar,
);
}
extern "C" {
pub fn gtk_action_group_translate_string(
action_group: *mut GtkActionGroup,
string: *const gchar,
) -> *const gchar;
}
pub type GtkAlignment = _GtkAlignment;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAlignmentPrivate {
_unused: [u8; 0],
}
pub type GtkAlignmentPrivate = _GtkAlignmentPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkAlignment {
pub bin: GtkBin,
pub priv_: *mut GtkAlignmentPrivate,
}
#[test]
fn bindgen_test_layout__GtkAlignment() {
const UNINIT: ::std::mem::MaybeUninit<_GtkAlignment> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkAlignment>(),
56usize,
concat!("Size of: ", stringify!(_GtkAlignment))
);
assert_eq!(
::std::mem::align_of::<_GtkAlignment>(),
8usize,
concat!("Alignment of ", stringify!(_GtkAlignment))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bin) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkAlignment),
"::",
stringify!(bin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkAlignment),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkAlignment {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_alignment_get_type() -> GType;
}
extern "C" {
pub fn gtk_alignment_new(
xalign: gfloat,
yalign: gfloat,
xscale: gfloat,
yscale: gfloat,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_alignment_set(
alignment: *mut GtkAlignment,
xalign: gfloat,
yalign: gfloat,
xscale: gfloat,
yscale: gfloat,
);
}
extern "C" {
pub fn gtk_alignment_set_padding(
alignment: *mut GtkAlignment,
padding_top: guint,
padding_bottom: guint,
padding_left: guint,
padding_right: guint,
);
}
extern "C" {
pub fn gtk_alignment_get_padding(
alignment: *mut GtkAlignment,
padding_top: *mut guint,
padding_bottom: *mut guint,
padding_left: *mut guint,
padding_right: *mut guint,
);
}
pub type GtkColorSelection = _GtkColorSelection;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkColorSelectionPrivate {
_unused: [u8; 0],
}
pub type GtkColorSelectionPrivate = _GtkColorSelectionPrivate;
#[doc = " GtkColorSelectionChangePaletteWithScreenFunc:\n @screen:\n @colors: (array length=n_colors): Array of colors\n @n_colors: Number of colors in the array\n\n Since: 2.2\n Deprecated: 3.4"]
pub type GtkColorSelectionChangePaletteWithScreenFunc = ::std::option::Option<
unsafe extern "C" fn(screen: *mut GdkScreen, colors: *const GdkColor, n_colors: gint),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkColorSelection {
pub parent_instance: GtkBox,
pub private_data: *mut GtkColorSelectionPrivate,
}
#[test]
fn bindgen_test_layout__GtkColorSelection() {
const UNINIT: ::std::mem::MaybeUninit<_GtkColorSelection> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkColorSelection>(),
56usize,
concat!("Size of: ", stringify!(_GtkColorSelection))
);
assert_eq!(
::std::mem::align_of::<_GtkColorSelection>(),
8usize,
concat!("Alignment of ", stringify!(_GtkColorSelection))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkColorSelection),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).private_data) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkColorSelection),
"::",
stringify!(private_data)
)
);
}
impl Default for _GtkColorSelection {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_color_selection_get_type() -> GType;
}
extern "C" {
pub fn gtk_color_selection_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_color_selection_get_has_opacity_control(
colorsel: *mut GtkColorSelection,
) -> gboolean;
}
extern "C" {
pub fn gtk_color_selection_set_has_opacity_control(
colorsel: *mut GtkColorSelection,
has_opacity: gboolean,
);
}
extern "C" {
pub fn gtk_color_selection_get_has_palette(colorsel: *mut GtkColorSelection) -> gboolean;
}
extern "C" {
pub fn gtk_color_selection_set_has_palette(
colorsel: *mut GtkColorSelection,
has_palette: gboolean,
);
}
extern "C" {
pub fn gtk_color_selection_set_current_alpha(colorsel: *mut GtkColorSelection, alpha: guint16);
}
extern "C" {
pub fn gtk_color_selection_get_current_alpha(colorsel: *mut GtkColorSelection) -> guint16;
}
extern "C" {
pub fn gtk_color_selection_set_previous_alpha(colorsel: *mut GtkColorSelection, alpha: guint16);
}
extern "C" {
pub fn gtk_color_selection_get_previous_alpha(colorsel: *mut GtkColorSelection) -> guint16;
}
extern "C" {
pub fn gtk_color_selection_set_current_rgba(
colorsel: *mut GtkColorSelection,
rgba: *const GdkRGBA,
);
}
extern "C" {
pub fn gtk_color_selection_get_current_rgba(
colorsel: *mut GtkColorSelection,
rgba: *mut GdkRGBA,
);
}
extern "C" {
pub fn gtk_color_selection_set_previous_rgba(
colorsel: *mut GtkColorSelection,
rgba: *const GdkRGBA,
);
}
extern "C" {
pub fn gtk_color_selection_get_previous_rgba(
colorsel: *mut GtkColorSelection,
rgba: *mut GdkRGBA,
);
}
extern "C" {
pub fn gtk_color_selection_is_adjusting(colorsel: *mut GtkColorSelection) -> gboolean;
}
extern "C" {
pub fn gtk_color_selection_palette_from_string(
str_: *const gchar,
colors: *mut *mut GdkColor,
n_colors: *mut gint,
) -> gboolean;
}
extern "C" {
pub fn gtk_color_selection_palette_to_string(
colors: *const GdkColor,
n_colors: gint,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_color_selection_set_change_palette_with_screen_hook(
func: GtkColorSelectionChangePaletteWithScreenFunc,
) -> GtkColorSelectionChangePaletteWithScreenFunc;
}
extern "C" {
pub fn gtk_color_selection_set_current_color(
colorsel: *mut GtkColorSelection,
color: *const GdkColor,
);
}
extern "C" {
pub fn gtk_color_selection_get_current_color(
colorsel: *mut GtkColorSelection,
color: *mut GdkColor,
);
}
extern "C" {
pub fn gtk_color_selection_set_previous_color(
colorsel: *mut GtkColorSelection,
color: *const GdkColor,
);
}
extern "C" {
pub fn gtk_color_selection_get_previous_color(
colorsel: *mut GtkColorSelection,
color: *mut GdkColor,
);
}
pub type GtkColorSelectionDialog = _GtkColorSelectionDialog;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkColorSelectionDialogPrivate {
_unused: [u8; 0],
}
pub type GtkColorSelectionDialogPrivate = _GtkColorSelectionDialogPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkColorSelectionDialog {
pub parent_instance: GtkDialog,
pub priv_: *mut GtkColorSelectionDialogPrivate,
}
#[test]
fn bindgen_test_layout__GtkColorSelectionDialog() {
const UNINIT: ::std::mem::MaybeUninit<_GtkColorSelectionDialog> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkColorSelectionDialog>(),
72usize,
concat!("Size of: ", stringify!(_GtkColorSelectionDialog))
);
assert_eq!(
::std::mem::align_of::<_GtkColorSelectionDialog>(),
8usize,
concat!("Alignment of ", stringify!(_GtkColorSelectionDialog))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkColorSelectionDialog),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GtkColorSelectionDialog),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkColorSelectionDialog {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_color_selection_dialog_get_type() -> GType;
}
extern "C" {
pub fn gtk_color_selection_dialog_new(title: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_color_selection_dialog_get_color_selection(
colorsel: *mut GtkColorSelectionDialog,
) -> *mut GtkWidget;
}
pub type GtkFontSelection = _GtkFontSelection;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFontSelectionPrivate {
_unused: [u8; 0],
}
pub type GtkFontSelectionPrivate = _GtkFontSelectionPrivate;
pub type GtkFontSelectionDialog = _GtkFontSelectionDialog;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFontSelectionDialogPrivate {
_unused: [u8; 0],
}
pub type GtkFontSelectionDialogPrivate = _GtkFontSelectionDialogPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFontSelection {
pub parent_instance: GtkBox,
pub priv_: *mut GtkFontSelectionPrivate,
}
#[test]
fn bindgen_test_layout__GtkFontSelection() {
const UNINIT: ::std::mem::MaybeUninit<_GtkFontSelection> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkFontSelection>(),
56usize,
concat!("Size of: ", stringify!(_GtkFontSelection))
);
assert_eq!(
::std::mem::align_of::<_GtkFontSelection>(),
8usize,
concat!("Alignment of ", stringify!(_GtkFontSelection))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkFontSelection),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkFontSelection),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkFontSelection {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkFontSelectionDialog {
pub parent_instance: GtkDialog,
pub priv_: *mut GtkFontSelectionDialogPrivate,
}
#[test]
fn bindgen_test_layout__GtkFontSelectionDialog() {
const UNINIT: ::std::mem::MaybeUninit<_GtkFontSelectionDialog> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkFontSelectionDialog>(),
72usize,
concat!("Size of: ", stringify!(_GtkFontSelectionDialog))
);
assert_eq!(
::std::mem::align_of::<_GtkFontSelectionDialog>(),
8usize,
concat!("Alignment of ", stringify!(_GtkFontSelectionDialog))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkFontSelectionDialog),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_GtkFontSelectionDialog),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkFontSelectionDialog {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_font_selection_get_type() -> GType;
}
extern "C" {
pub fn gtk_font_selection_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_font_selection_get_family_list(fontsel: *mut GtkFontSelection) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_font_selection_get_face_list(fontsel: *mut GtkFontSelection) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_font_selection_get_size_entry(fontsel: *mut GtkFontSelection) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_font_selection_get_size_list(fontsel: *mut GtkFontSelection) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_font_selection_get_preview_entry(fontsel: *mut GtkFontSelection) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_font_selection_get_family(fontsel: *mut GtkFontSelection) -> *mut PangoFontFamily;
}
extern "C" {
pub fn gtk_font_selection_get_face(fontsel: *mut GtkFontSelection) -> *mut PangoFontFace;
}
extern "C" {
pub fn gtk_font_selection_get_size(fontsel: *mut GtkFontSelection) -> gint;
}
extern "C" {
pub fn gtk_font_selection_get_font_name(fontsel: *mut GtkFontSelection) -> *mut gchar;
}
extern "C" {
pub fn gtk_font_selection_set_font_name(
fontsel: *mut GtkFontSelection,
fontname: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_font_selection_get_preview_text(fontsel: *mut GtkFontSelection) -> *const gchar;
}
extern "C" {
pub fn gtk_font_selection_set_preview_text(fontsel: *mut GtkFontSelection, text: *const gchar);
}
extern "C" {
pub fn gtk_font_selection_dialog_get_type() -> GType;
}
extern "C" {
pub fn gtk_font_selection_dialog_new(title: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_font_selection_dialog_get_ok_button(
fsd: *mut GtkFontSelectionDialog,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_font_selection_dialog_get_cancel_button(
fsd: *mut GtkFontSelectionDialog,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_font_selection_dialog_get_font_selection(
fsd: *mut GtkFontSelectionDialog,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_font_selection_dialog_get_font_name(fsd: *mut GtkFontSelectionDialog) -> *mut gchar;
}
extern "C" {
pub fn gtk_font_selection_dialog_set_font_name(
fsd: *mut GtkFontSelectionDialog,
fontname: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_font_selection_dialog_get_preview_text(
fsd: *mut GtkFontSelectionDialog,
) -> *const gchar;
}
extern "C" {
pub fn gtk_font_selection_dialog_set_preview_text(
fsd: *mut GtkFontSelectionDialog,
text: *const gchar,
);
}
extern "C" {
pub fn gtk_symbolic_color_get_type() -> GType;
}
extern "C" {
pub fn gtk_symbolic_color_new_literal(color: *const GdkRGBA) -> *mut GtkSymbolicColor;
}
extern "C" {
pub fn gtk_symbolic_color_new_name(name: *const gchar) -> *mut GtkSymbolicColor;
}
extern "C" {
pub fn gtk_symbolic_color_new_shade(
color: *mut GtkSymbolicColor,
factor: gdouble,
) -> *mut GtkSymbolicColor;
}
extern "C" {
pub fn gtk_symbolic_color_new_alpha(
color: *mut GtkSymbolicColor,
factor: gdouble,
) -> *mut GtkSymbolicColor;
}
extern "C" {
pub fn gtk_symbolic_color_new_mix(
color1: *mut GtkSymbolicColor,
color2: *mut GtkSymbolicColor,
factor: gdouble,
) -> *mut GtkSymbolicColor;
}
extern "C" {
pub fn gtk_symbolic_color_new_win32(
theme_class: *const gchar,
id: gint,
) -> *mut GtkSymbolicColor;
}
extern "C" {
pub fn gtk_symbolic_color_ref(color: *mut GtkSymbolicColor) -> *mut GtkSymbolicColor;
}
extern "C" {
pub fn gtk_symbolic_color_unref(color: *mut GtkSymbolicColor);
}
extern "C" {
pub fn gtk_symbolic_color_to_string(
color: *mut GtkSymbolicColor,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn gtk_symbolic_color_resolve(
color: *mut GtkSymbolicColor,
props: *mut GtkStyleProperties,
resolved_color: *mut GdkRGBA,
) -> gboolean;
}
extern "C" {
pub fn gtk_gradient_get_type() -> GType;
}
extern "C" {
pub fn gtk_gradient_new_linear(
x0: gdouble,
y0: gdouble,
x1: gdouble,
y1: gdouble,
) -> *mut GtkGradient;
}
extern "C" {
pub fn gtk_gradient_new_radial(
x0: gdouble,
y0: gdouble,
radius0: gdouble,
x1: gdouble,
y1: gdouble,
radius1: gdouble,
) -> *mut GtkGradient;
}
extern "C" {
pub fn gtk_gradient_add_color_stop(
gradient: *mut GtkGradient,
offset: gdouble,
color: *mut GtkSymbolicColor,
);
}
extern "C" {
pub fn gtk_gradient_ref(gradient: *mut GtkGradient) -> *mut GtkGradient;
}
extern "C" {
pub fn gtk_gradient_unref(gradient: *mut GtkGradient);
}
extern "C" {
pub fn gtk_gradient_resolve(
gradient: *mut GtkGradient,
props: *mut GtkStyleProperties,
resolved_gradient: *mut *mut cairo_pattern_t,
) -> gboolean;
}
extern "C" {
pub fn gtk_gradient_resolve_for_context(
gradient: *mut GtkGradient,
context: *mut GtkStyleContext,
) -> *mut cairo_pattern_t;
}
extern "C" {
pub fn gtk_gradient_to_string(gradient: *mut GtkGradient) -> *mut ::std::os::raw::c_char;
}
pub type GtkHandleBox = _GtkHandleBox;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkHandleBoxPrivate {
_unused: [u8; 0],
}
pub type GtkHandleBoxPrivate = _GtkHandleBoxPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkHandleBox {
pub bin: GtkBin,
pub priv_: *mut GtkHandleBoxPrivate,
}
#[test]
fn bindgen_test_layout__GtkHandleBox() {
const UNINIT: ::std::mem::MaybeUninit<_GtkHandleBox> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkHandleBox>(),
56usize,
concat!("Size of: ", stringify!(_GtkHandleBox))
);
assert_eq!(
::std::mem::align_of::<_GtkHandleBox>(),
8usize,
concat!("Alignment of ", stringify!(_GtkHandleBox))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bin) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkHandleBox),
"::",
stringify!(bin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_GtkHandleBox),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkHandleBox {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_handle_box_get_type() -> GType;
}
extern "C" {
pub fn gtk_handle_box_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_handle_box_set_shadow_type(handle_box: *mut GtkHandleBox, type_: GtkShadowType);
}
extern "C" {
pub fn gtk_handle_box_get_shadow_type(handle_box: *mut GtkHandleBox) -> GtkShadowType;
}
extern "C" {
pub fn gtk_handle_box_set_handle_position(
handle_box: *mut GtkHandleBox,
position: GtkPositionType,
);
}
extern "C" {
pub fn gtk_handle_box_get_handle_position(handle_box: *mut GtkHandleBox) -> GtkPositionType;
}
extern "C" {
pub fn gtk_handle_box_set_snap_edge(handle_box: *mut GtkHandleBox, edge: GtkPositionType);
}
extern "C" {
pub fn gtk_handle_box_get_snap_edge(handle_box: *mut GtkHandleBox) -> GtkPositionType;
}
extern "C" {
pub fn gtk_handle_box_get_child_detached(handle_box: *mut GtkHandleBox) -> gboolean;
}
extern "C" {
pub fn gtk_hbutton_box_get_type() -> GType;
}
extern "C" {
pub fn gtk_hbutton_box_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_hbox_get_type() -> GType;
}
extern "C" {
pub fn gtk_hbox_new(homogeneous: gboolean, spacing: gint) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_hpaned_get_type() -> GType;
}
extern "C" {
pub fn gtk_hpaned_new() -> *mut GtkWidget;
}
pub type GtkHSV = _GtkHSV;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkHSVPrivate {
_unused: [u8; 0],
}
pub type GtkHSVPrivate = _GtkHSVPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkHSV {
pub parent_instance: GtkWidget,
pub priv_: *mut GtkHSVPrivate,
}
#[test]
fn bindgen_test_layout__GtkHSV() {
const UNINIT: ::std::mem::MaybeUninit<_GtkHSV> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkHSV>(),
40usize,
concat!("Size of: ", stringify!(_GtkHSV))
);
assert_eq!(
::std::mem::align_of::<_GtkHSV>(),
8usize,
concat!("Alignment of ", stringify!(_GtkHSV))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkHSV),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkHSV),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkHSV {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_hsv_get_type() -> GType;
}
extern "C" {
pub fn gtk_hsv_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_hsv_set_color(hsv: *mut GtkHSV, h: f64, s: f64, v: f64);
}
extern "C" {
pub fn gtk_hsv_get_color(hsv: *mut GtkHSV, h: *mut gdouble, s: *mut gdouble, v: *mut gdouble);
}
extern "C" {
pub fn gtk_hsv_set_metrics(hsv: *mut GtkHSV, size: gint, ring_width: gint);
}
extern "C" {
pub fn gtk_hsv_get_metrics(hsv: *mut GtkHSV, size: *mut gint, ring_width: *mut gint);
}
extern "C" {
pub fn gtk_hsv_is_adjusting(hsv: *mut GtkHSV) -> gboolean;
}
extern "C" {
pub fn gtk_hscale_get_type() -> GType;
}
extern "C" {
pub fn gtk_hscale_new(adjustment: *mut GtkAdjustment) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_hscale_new_with_range(min: gdouble, max: gdouble, step: gdouble) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_hscrollbar_get_type() -> GType;
}
extern "C" {
pub fn gtk_hscrollbar_new(adjustment: *mut GtkAdjustment) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_hseparator_get_type() -> GType;
}
extern "C" {
pub fn gtk_hseparator_new() -> *mut GtkWidget;
}
pub type GtkImageMenuItem = _GtkImageMenuItem;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkImageMenuItemPrivate {
_unused: [u8; 0],
}
pub type GtkImageMenuItemPrivate = _GtkImageMenuItemPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkImageMenuItem {
pub menu_item: GtkMenuItem,
pub priv_: *mut GtkImageMenuItemPrivate,
}
#[test]
fn bindgen_test_layout__GtkImageMenuItem() {
const UNINIT: ::std::mem::MaybeUninit<_GtkImageMenuItem> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkImageMenuItem>(),
64usize,
concat!("Size of: ", stringify!(_GtkImageMenuItem))
);
assert_eq!(
::std::mem::align_of::<_GtkImageMenuItem>(),
8usize,
concat!("Alignment of ", stringify!(_GtkImageMenuItem))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).menu_item) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkImageMenuItem),
"::",
stringify!(menu_item)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_GtkImageMenuItem),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkImageMenuItem {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_image_menu_item_get_type() -> GType;
}
extern "C" {
pub fn gtk_image_menu_item_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_image_menu_item_new_with_label(label: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_image_menu_item_new_with_mnemonic(label: *const gchar) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_image_menu_item_new_from_stock(
stock_id: *const gchar,
accel_group: *mut GtkAccelGroup,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_image_menu_item_set_always_show_image(
image_menu_item: *mut GtkImageMenuItem,
always_show: gboolean,
);
}
extern "C" {
pub fn gtk_image_menu_item_get_always_show_image(
image_menu_item: *mut GtkImageMenuItem,
) -> gboolean;
}
extern "C" {
pub fn gtk_image_menu_item_set_image(
image_menu_item: *mut GtkImageMenuItem,
image: *mut GtkWidget,
);
}
extern "C" {
pub fn gtk_image_menu_item_get_image(image_menu_item: *mut GtkImageMenuItem) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_image_menu_item_set_use_stock(
image_menu_item: *mut GtkImageMenuItem,
use_stock: gboolean,
);
}
extern "C" {
pub fn gtk_image_menu_item_get_use_stock(image_menu_item: *mut GtkImageMenuItem) -> gboolean;
}
extern "C" {
pub fn gtk_image_menu_item_set_accel_group(
image_menu_item: *mut GtkImageMenuItem,
accel_group: *mut GtkAccelGroup,
);
}
pub type GtkNumerableIcon = _GtkNumerableIcon;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkNumerableIconPrivate {
_unused: [u8; 0],
}
pub type GtkNumerableIconPrivate = _GtkNumerableIconPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkNumerableIcon {
pub parent: GEmblemedIcon,
pub priv_: *mut GtkNumerableIconPrivate,
}
#[test]
fn bindgen_test_layout__GtkNumerableIcon() {
const UNINIT: ::std::mem::MaybeUninit<_GtkNumerableIcon> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkNumerableIcon>(),
40usize,
concat!("Size of: ", stringify!(_GtkNumerableIcon))
);
assert_eq!(
::std::mem::align_of::<_GtkNumerableIcon>(),
8usize,
concat!("Alignment of ", stringify!(_GtkNumerableIcon))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkNumerableIcon),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkNumerableIcon),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkNumerableIcon {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_numerable_icon_get_type() -> GType;
}
extern "C" {
pub fn gtk_numerable_icon_new(base_icon: *mut GIcon) -> *mut GIcon;
}
extern "C" {
pub fn gtk_numerable_icon_new_with_style_context(
base_icon: *mut GIcon,
context: *mut GtkStyleContext,
) -> *mut GIcon;
}
extern "C" {
pub fn gtk_numerable_icon_get_style_context(
self_: *mut GtkNumerableIcon,
) -> *mut GtkStyleContext;
}
extern "C" {
pub fn gtk_numerable_icon_set_style_context(
self_: *mut GtkNumerableIcon,
style: *mut GtkStyleContext,
);
}
extern "C" {
pub fn gtk_numerable_icon_get_count(self_: *mut GtkNumerableIcon) -> gint;
}
extern "C" {
pub fn gtk_numerable_icon_set_count(self_: *mut GtkNumerableIcon, count: gint);
}
extern "C" {
pub fn gtk_numerable_icon_get_label(self_: *mut GtkNumerableIcon) -> *const gchar;
}
extern "C" {
pub fn gtk_numerable_icon_set_label(self_: *mut GtkNumerableIcon, label: *const gchar);
}
extern "C" {
pub fn gtk_numerable_icon_set_background_gicon(self_: *mut GtkNumerableIcon, icon: *mut GIcon);
}
extern "C" {
pub fn gtk_numerable_icon_get_background_gicon(self_: *mut GtkNumerableIcon) -> *mut GIcon;
}
extern "C" {
pub fn gtk_numerable_icon_set_background_icon_name(
self_: *mut GtkNumerableIcon,
icon_name: *const gchar,
);
}
extern "C" {
pub fn gtk_numerable_icon_get_background_icon_name(
self_: *mut GtkNumerableIcon,
) -> *const gchar;
}
pub type GtkToggleAction = _GtkToggleAction;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToggleActionPrivate {
_unused: [u8; 0],
}
pub type GtkToggleActionPrivate = _GtkToggleActionPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkToggleAction {
pub parent: GtkAction,
pub private_data: *mut GtkToggleActionPrivate,
}
#[test]
fn bindgen_test_layout__GtkToggleAction() {
const UNINIT: ::std::mem::MaybeUninit<_GtkToggleAction> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkToggleAction>(),
40usize,
concat!("Size of: ", stringify!(_GtkToggleAction))
);
assert_eq!(
::std::mem::align_of::<_GtkToggleAction>(),
8usize,
concat!("Alignment of ", stringify!(_GtkToggleAction))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkToggleAction),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).private_data) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkToggleAction),
"::",
stringify!(private_data)
)
);
}
impl Default for _GtkToggleAction {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_toggle_action_get_type() -> GType;
}
extern "C" {
pub fn gtk_toggle_action_new(
name: *const gchar,
label: *const gchar,
tooltip: *const gchar,
stock_id: *const gchar,
) -> *mut GtkToggleAction;
}
extern "C" {
pub fn gtk_toggle_action_toggled(action: *mut GtkToggleAction);
}
extern "C" {
pub fn gtk_toggle_action_set_active(action: *mut GtkToggleAction, is_active: gboolean);
}
extern "C" {
pub fn gtk_toggle_action_get_active(action: *mut GtkToggleAction) -> gboolean;
}
extern "C" {
pub fn gtk_toggle_action_set_draw_as_radio(
action: *mut GtkToggleAction,
draw_as_radio: gboolean,
);
}
extern "C" {
pub fn gtk_toggle_action_get_draw_as_radio(action: *mut GtkToggleAction) -> gboolean;
}
pub type GtkRadioAction = _GtkRadioAction;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRadioActionPrivate {
_unused: [u8; 0],
}
pub type GtkRadioActionPrivate = _GtkRadioActionPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRadioAction {
pub parent: GtkToggleAction,
pub private_data: *mut GtkRadioActionPrivate,
}
#[test]
fn bindgen_test_layout__GtkRadioAction() {
const UNINIT: ::std::mem::MaybeUninit<_GtkRadioAction> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkRadioAction>(),
48usize,
concat!("Size of: ", stringify!(_GtkRadioAction))
);
assert_eq!(
::std::mem::align_of::<_GtkRadioAction>(),
8usize,
concat!("Alignment of ", stringify!(_GtkRadioAction))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkRadioAction),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).private_data) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkRadioAction),
"::",
stringify!(private_data)
)
);
}
impl Default for _GtkRadioAction {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_radio_action_get_type() -> GType;
}
extern "C" {
pub fn gtk_radio_action_new(
name: *const gchar,
label: *const gchar,
tooltip: *const gchar,
stock_id: *const gchar,
value: gint,
) -> *mut GtkRadioAction;
}
extern "C" {
pub fn gtk_radio_action_get_group(action: *mut GtkRadioAction) -> *mut GSList;
}
extern "C" {
pub fn gtk_radio_action_set_group(action: *mut GtkRadioAction, group: *mut GSList);
}
extern "C" {
pub fn gtk_radio_action_join_group(
action: *mut GtkRadioAction,
group_source: *mut GtkRadioAction,
);
}
extern "C" {
pub fn gtk_radio_action_get_current_value(action: *mut GtkRadioAction) -> gint;
}
extern "C" {
pub fn gtk_radio_action_set_current_value(action: *mut GtkRadioAction, current_value: gint);
}
pub const GtkRcFlags_GTK_RC_FG: GtkRcFlags = 1;
pub const GtkRcFlags_GTK_RC_BG: GtkRcFlags = 2;
pub const GtkRcFlags_GTK_RC_TEXT: GtkRcFlags = 4;
pub const GtkRcFlags_GTK_RC_BASE: GtkRcFlags = 8;
#[doc = " GtkRcFlags:\n @GTK_RC_FG :Deprecated\n @GTK_RC_BG: Deprecated\n @GTK_RC_TEXT: Deprecated\n @GTK_RC_BASE: Deprecated\n\n Deprecated"]
pub type GtkRcFlags = ::std::os::raw::c_uint;
#[doc = " GtkRcStyle:\n @name: Name\n @bg_pixmap_name: Pixmap name\n @font_desc: A #PangoFontDescription\n @color_flags: #GtkRcFlags\n @fg: Foreground colors\n @bg: Background colors\n @text: Text colors\n @base: Base colors\n @xthickness: X thickness\n @ythickness: Y thickness\n\n The #GtkRcStyle-struct is used to represent a set\n of information about the appearance of a widget.\n This can later be composited together with other\n #GtkRcStyle-struct<!-- -->s to form a #GtkStyle."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRcStyle {
pub parent_instance: GObject,
pub name: *mut gchar,
pub bg_pixmap_name: [*mut gchar; 5usize],
pub font_desc: *mut PangoFontDescription,
pub color_flags: [GtkRcFlags; 5usize],
pub fg: [GdkColor; 5usize],
pub bg: [GdkColor; 5usize],
pub text: [GdkColor; 5usize],
pub base: [GdkColor; 5usize],
pub xthickness: gint,
pub ythickness: gint,
pub rc_properties: *mut GArray,
pub rc_style_lists: *mut GSList,
pub icon_factories: *mut GSList,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub __bindgen_padding_0: [u8; 7usize],
}
#[test]
fn bindgen_test_layout__GtkRcStyle() {
const UNINIT: ::std::mem::MaybeUninit<_GtkRcStyle> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkRcStyle>(),
384usize,
concat!("Size of: ", stringify!(_GtkRcStyle))
);
assert_eq!(
::std::mem::align_of::<_GtkRcStyle>(),
8usize,
concat!("Alignment of ", stringify!(_GtkRcStyle))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkRcStyle),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkRcStyle),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_pixmap_name) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkRcStyle),
"::",
stringify!(bg_pixmap_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_desc) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_GtkRcStyle),
"::",
stringify!(font_desc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).color_flags) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_GtkRcStyle),
"::",
stringify!(color_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fg) as usize - ptr as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(_GtkRcStyle),
"::",
stringify!(fg)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_GtkRcStyle),
"::",
stringify!(bg)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
220usize,
concat!(
"Offset of field: ",
stringify!(_GtkRcStyle),
"::",
stringify!(text)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).base) as usize - ptr as usize },
280usize,
concat!(
"Offset of field: ",
stringify!(_GtkRcStyle),
"::",
stringify!(base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xthickness) as usize - ptr as usize },
340usize,
concat!(
"Offset of field: ",
stringify!(_GtkRcStyle),
"::",
stringify!(xthickness)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ythickness) as usize - ptr as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(_GtkRcStyle),
"::",
stringify!(ythickness)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rc_properties) as usize - ptr as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(_GtkRcStyle),
"::",
stringify!(rc_properties)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rc_style_lists) as usize - ptr as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(_GtkRcStyle),
"::",
stringify!(rc_style_lists)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).icon_factories) as usize - ptr as usize },
368usize,
concat!(
"Offset of field: ",
stringify!(_GtkRcStyle),
"::",
stringify!(icon_factories)
)
);
}
impl Default for _GtkRcStyle {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl _GtkRcStyle {
#[inline]
pub fn engine_specified(&self) -> guint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
}
#[inline]
pub fn set_engine_specified(&mut self, val: guint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(engine_specified: guint) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let engine_specified: u32 = unsafe { ::std::mem::transmute(engine_specified) };
engine_specified as u64
});
__bindgen_bitfield_unit
}
}
extern "C" {
pub fn gtk_rc_add_default_file(filename: *const gchar);
}
extern "C" {
pub fn gtk_rc_set_default_files(filenames: *mut *mut gchar);
}
extern "C" {
pub fn gtk_rc_get_default_files() -> *mut *mut gchar;
}
extern "C" {
pub fn gtk_rc_get_style(widget: *mut GtkWidget) -> *mut GtkStyle;
}
extern "C" {
pub fn gtk_rc_get_style_by_paths(
settings: *mut GtkSettings,
widget_path: *const ::std::os::raw::c_char,
class_path: *const ::std::os::raw::c_char,
type_: GType,
) -> *mut GtkStyle;
}
extern "C" {
pub fn gtk_rc_reparse_all_for_settings(
settings: *mut GtkSettings,
force_load: gboolean,
) -> gboolean;
}
extern "C" {
pub fn gtk_rc_reset_styles(settings: *mut GtkSettings);
}
extern "C" {
pub fn gtk_rc_find_pixmap_in_path(
settings: *mut GtkSettings,
scanner: *mut GScanner,
pixmap_file: *const gchar,
) -> *mut gchar;
}
extern "C" {
pub fn gtk_rc_parse(filename: *const gchar);
}
extern "C" {
pub fn gtk_rc_parse_string(rc_string: *const gchar);
}
extern "C" {
pub fn gtk_rc_reparse_all() -> gboolean;
}
extern "C" {
pub fn gtk_rc_style_get_type() -> GType;
}
extern "C" {
pub fn gtk_rc_style_new() -> *mut GtkRcStyle;
}
extern "C" {
pub fn gtk_rc_style_copy(orig: *mut GtkRcStyle) -> *mut GtkRcStyle;
}
extern "C" {
pub fn gtk_rc_find_module_in_path(module_file: *const gchar) -> *mut gchar;
}
extern "C" {
pub fn gtk_rc_get_theme_dir() -> *mut gchar;
}
extern "C" {
pub fn gtk_rc_get_module_dir() -> *mut gchar;
}
extern "C" {
pub fn gtk_rc_get_im_module_path() -> *mut gchar;
}
extern "C" {
pub fn gtk_rc_get_im_module_file() -> *mut gchar;
}
pub const GtkPathPriorityType_GTK_PATH_PRIO_LOWEST: GtkPathPriorityType = 0;
pub const GtkPathPriorityType_GTK_PATH_PRIO_GTK: GtkPathPriorityType = 4;
pub const GtkPathPriorityType_GTK_PATH_PRIO_APPLICATION: GtkPathPriorityType = 8;
pub const GtkPathPriorityType_GTK_PATH_PRIO_THEME: GtkPathPriorityType = 10;
pub const GtkPathPriorityType_GTK_PATH_PRIO_RC: GtkPathPriorityType = 12;
pub const GtkPathPriorityType_GTK_PATH_PRIO_HIGHEST: GtkPathPriorityType = 15;
#[doc = " GtkPathPriorityType:\n @GTK_PATH_PRIO_LOWEST: Deprecated\n @GTK_PATH_PRIO_GTK: Deprecated\n @GTK_PATH_PRIO_APPLICATION: Deprecated\n @GTK_PATH_PRIO_THEME: Deprecated\n @GTK_PATH_PRIO_RC: Deprecated\n @GTK_PATH_PRIO_HIGHEST: Deprecated\n\n Priorities for path lookups.\n See also gtk_binding_set_add_path().\n\n Deprecated: 3.0"]
pub type GtkPathPriorityType = ::std::os::raw::c_uint;
pub const GtkPathType_GTK_PATH_WIDGET: GtkPathType = 0;
pub const GtkPathType_GTK_PATH_WIDGET_CLASS: GtkPathType = 1;
pub const GtkPathType_GTK_PATH_CLASS: GtkPathType = 2;
#[doc = " GtkPathType:\n @GTK_PATH_WIDGET: Deprecated\n @GTK_PATH_WIDGET_CLASS: Deprecated\n @GTK_PATH_CLASS: Deprecated\n\n Widget path types.\n See also gtk_binding_set_add_path().\n\n Deprecated: 3.0"]
pub type GtkPathType = ::std::os::raw::c_uint;
extern "C" {
pub fn gtk_rc_scanner_new() -> *mut GScanner;
}
extern "C" {
pub fn gtk_rc_parse_color(scanner: *mut GScanner, color: *mut GdkColor) -> guint;
}
extern "C" {
pub fn gtk_rc_parse_color_full(
scanner: *mut GScanner,
style: *mut GtkRcStyle,
color: *mut GdkColor,
) -> guint;
}
extern "C" {
pub fn gtk_rc_parse_state(scanner: *mut GScanner, state: *mut GtkStateType) -> guint;
}
extern "C" {
pub fn gtk_rc_parse_priority(
scanner: *mut GScanner,
priority: *mut GtkPathPriorityType,
) -> guint;
}
extern "C" {
pub fn gtk_binding_set_add_path(
binding_set: *mut GtkBindingSet,
path_type: GtkPathType,
path_pattern: *const gchar,
priority: GtkPathPriorityType,
);
}
pub type GtkRecentAction = _GtkRecentAction;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRecentActionPrivate {
_unused: [u8; 0],
}
pub type GtkRecentActionPrivate = _GtkRecentActionPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkRecentAction {
pub parent_instance: GtkAction,
pub priv_: *mut GtkRecentActionPrivate,
}
#[test]
fn bindgen_test_layout__GtkRecentAction() {
const UNINIT: ::std::mem::MaybeUninit<_GtkRecentAction> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkRecentAction>(),
40usize,
concat!("Size of: ", stringify!(_GtkRecentAction))
);
assert_eq!(
::std::mem::align_of::<_GtkRecentAction>(),
8usize,
concat!("Alignment of ", stringify!(_GtkRecentAction))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentAction),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_GtkRecentAction),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkRecentAction {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_recent_action_get_type() -> GType;
}
extern "C" {
pub fn gtk_recent_action_new(
name: *const gchar,
label: *const gchar,
tooltip: *const gchar,
stock_id: *const gchar,
) -> *mut GtkAction;
}
extern "C" {
pub fn gtk_recent_action_new_for_manager(
name: *const gchar,
label: *const gchar,
tooltip: *const gchar,
stock_id: *const gchar,
manager: *mut GtkRecentManager,
) -> *mut GtkAction;
}
extern "C" {
pub fn gtk_recent_action_get_show_numbers(action: *mut GtkRecentAction) -> gboolean;
}
extern "C" {
pub fn gtk_recent_action_set_show_numbers(action: *mut GtkRecentAction, show_numbers: gboolean);
}
pub type GtkStatusIcon = _GtkStatusIcon;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkStatusIconPrivate {
_unused: [u8; 0],
}
pub type GtkStatusIconPrivate = _GtkStatusIconPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkStatusIcon {
pub parent_instance: GObject,
pub priv_: *mut GtkStatusIconPrivate,
}
#[test]
fn bindgen_test_layout__GtkStatusIcon() {
const UNINIT: ::std::mem::MaybeUninit<_GtkStatusIcon> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkStatusIcon>(),
32usize,
concat!("Size of: ", stringify!(_GtkStatusIcon))
);
assert_eq!(
::std::mem::align_of::<_GtkStatusIcon>(),
8usize,
concat!("Alignment of ", stringify!(_GtkStatusIcon))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkStatusIcon),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkStatusIcon),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkStatusIcon {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_status_icon_get_type() -> GType;
}
extern "C" {
pub fn gtk_status_icon_new() -> *mut GtkStatusIcon;
}
extern "C" {
pub fn gtk_status_icon_new_from_pixbuf(pixbuf: *mut GdkPixbuf) -> *mut GtkStatusIcon;
}
extern "C" {
pub fn gtk_status_icon_new_from_file(filename: *const gchar) -> *mut GtkStatusIcon;
}
extern "C" {
pub fn gtk_status_icon_new_from_stock(stock_id: *const gchar) -> *mut GtkStatusIcon;
}
extern "C" {
pub fn gtk_status_icon_new_from_icon_name(icon_name: *const gchar) -> *mut GtkStatusIcon;
}
extern "C" {
pub fn gtk_status_icon_new_from_gicon(icon: *mut GIcon) -> *mut GtkStatusIcon;
}
extern "C" {
pub fn gtk_status_icon_set_from_pixbuf(status_icon: *mut GtkStatusIcon, pixbuf: *mut GdkPixbuf);
}
extern "C" {
pub fn gtk_status_icon_set_from_file(status_icon: *mut GtkStatusIcon, filename: *const gchar);
}
extern "C" {
pub fn gtk_status_icon_set_from_stock(status_icon: *mut GtkStatusIcon, stock_id: *const gchar);
}
extern "C" {
pub fn gtk_status_icon_set_from_icon_name(
status_icon: *mut GtkStatusIcon,
icon_name: *const gchar,
);
}
extern "C" {
pub fn gtk_status_icon_set_from_gicon(status_icon: *mut GtkStatusIcon, icon: *mut GIcon);
}
extern "C" {
pub fn gtk_status_icon_get_storage_type(status_icon: *mut GtkStatusIcon) -> GtkImageType;
}
extern "C" {
pub fn gtk_status_icon_get_pixbuf(status_icon: *mut GtkStatusIcon) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_status_icon_get_stock(status_icon: *mut GtkStatusIcon) -> *const gchar;
}
extern "C" {
pub fn gtk_status_icon_get_icon_name(status_icon: *mut GtkStatusIcon) -> *const gchar;
}
extern "C" {
pub fn gtk_status_icon_get_gicon(status_icon: *mut GtkStatusIcon) -> *mut GIcon;
}
extern "C" {
pub fn gtk_status_icon_get_size(status_icon: *mut GtkStatusIcon) -> gint;
}
extern "C" {
pub fn gtk_status_icon_set_screen(status_icon: *mut GtkStatusIcon, screen: *mut GdkScreen);
}
extern "C" {
pub fn gtk_status_icon_get_screen(status_icon: *mut GtkStatusIcon) -> *mut GdkScreen;
}
extern "C" {
pub fn gtk_status_icon_set_has_tooltip(status_icon: *mut GtkStatusIcon, has_tooltip: gboolean);
}
extern "C" {
pub fn gtk_status_icon_set_tooltip_text(status_icon: *mut GtkStatusIcon, text: *const gchar);
}
extern "C" {
pub fn gtk_status_icon_set_tooltip_markup(
status_icon: *mut GtkStatusIcon,
markup: *const gchar,
);
}
extern "C" {
pub fn gtk_status_icon_set_title(status_icon: *mut GtkStatusIcon, title: *const gchar);
}
extern "C" {
pub fn gtk_status_icon_get_title(status_icon: *mut GtkStatusIcon) -> *const gchar;
}
extern "C" {
pub fn gtk_status_icon_set_name(status_icon: *mut GtkStatusIcon, name: *const gchar);
}
extern "C" {
pub fn gtk_status_icon_set_visible(status_icon: *mut GtkStatusIcon, visible: gboolean);
}
extern "C" {
pub fn gtk_status_icon_get_visible(status_icon: *mut GtkStatusIcon) -> gboolean;
}
extern "C" {
pub fn gtk_status_icon_is_embedded(status_icon: *mut GtkStatusIcon) -> gboolean;
}
extern "C" {
pub fn gtk_status_icon_position_menu(
menu: *mut GtkMenu,
x: *mut gint,
y: *mut gint,
push_in: *mut gboolean,
user_data: gpointer,
);
}
extern "C" {
pub fn gtk_status_icon_get_geometry(
status_icon: *mut GtkStatusIcon,
screen: *mut *mut GdkScreen,
area: *mut GdkRectangle,
orientation: *mut GtkOrientation,
) -> gboolean;
}
extern "C" {
pub fn gtk_status_icon_get_has_tooltip(status_icon: *mut GtkStatusIcon) -> gboolean;
}
extern "C" {
pub fn gtk_status_icon_get_tooltip_text(status_icon: *mut GtkStatusIcon) -> *mut gchar;
}
extern "C" {
pub fn gtk_status_icon_get_tooltip_markup(status_icon: *mut GtkStatusIcon) -> *mut gchar;
}
extern "C" {
pub fn gtk_status_icon_get_x11_window_id(status_icon: *mut GtkStatusIcon) -> guint32;
}
pub const GtkExpanderStyle_GTK_EXPANDER_COLLAPSED: GtkExpanderStyle = 0;
pub const GtkExpanderStyle_GTK_EXPANDER_SEMI_COLLAPSED: GtkExpanderStyle = 1;
pub const GtkExpanderStyle_GTK_EXPANDER_SEMI_EXPANDED: GtkExpanderStyle = 2;
pub const GtkExpanderStyle_GTK_EXPANDER_EXPANDED: GtkExpanderStyle = 3;
#[doc = " GtkExpanderStyle:\n @GTK_EXPANDER_COLLAPSED: The style used for a collapsed subtree.\n @GTK_EXPANDER_SEMI_COLLAPSED: Intermediate style used during animation.\n @GTK_EXPANDER_SEMI_EXPANDED: Intermediate style used during animation.\n @GTK_EXPANDER_EXPANDED: The style used for an expanded subtree.\n\n Used to specify the style of the expanders drawn by a #GtkTreeView."]
pub type GtkExpanderStyle = ::std::os::raw::c_uint;
#[doc = " GtkStyle:\n @fg: Set of foreground #GdkColor\n @bg: Set of background #GdkColor\n @light: Set of light #GdkColor\n @dark: Set of dark #GdkColor\n @mid: Set of mid #GdkColor\n @text: Set of text #GdkColor\n @base: Set of base #GdkColor\n @text_aa: Color halfway between text/base\n @black: #GdkColor to use for black\n @white: #GdkColor to use for white\n @font_desc: #PangoFontDescription\n @xthickness: Thickness in X direction\n @ythickness: Thickness in Y direction\n @background: Set of background #cairo_pattern_t"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkStyle {
pub parent_instance: GObject,
pub fg: [GdkColor; 5usize],
pub bg: [GdkColor; 5usize],
pub light: [GdkColor; 5usize],
pub dark: [GdkColor; 5usize],
pub mid: [GdkColor; 5usize],
pub text: [GdkColor; 5usize],
pub base: [GdkColor; 5usize],
pub text_aa: [GdkColor; 5usize],
pub black: GdkColor,
pub white: GdkColor,
pub font_desc: *mut PangoFontDescription,
pub xthickness: gint,
pub ythickness: gint,
pub background: [*mut cairo_pattern_t; 5usize],
pub attach_count: gint,
pub visual: *mut GdkVisual,
pub private_font_desc: *mut PangoFontDescription,
pub rc_style: *mut GtkRcStyle,
pub styles: *mut GSList,
pub property_cache: *mut GArray,
pub icon_factories: *mut GSList,
}
#[test]
fn bindgen_test_layout__GtkStyle() {
const UNINIT: ::std::mem::MaybeUninit<_GtkStyle> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkStyle>(),
640usize,
concat!("Size of: ", stringify!(_GtkStyle))
);
assert_eq!(
::std::mem::align_of::<_GtkStyle>(),
8usize,
concat!("Alignment of ", stringify!(_GtkStyle))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_instance) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(parent_instance)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fg) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(fg)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg) as usize - ptr as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(bg)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).light) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(light)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dark) as usize - ptr as usize },
204usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(dark)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mid) as usize - ptr as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(mid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
324usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(text)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).base) as usize - ptr as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).text_aa) as usize - ptr as usize },
444usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(text_aa)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).black) as usize - ptr as usize },
504usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(black)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).white) as usize - ptr as usize },
516usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(white)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_desc) as usize - ptr as usize },
528usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(font_desc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xthickness) as usize - ptr as usize },
536usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(xthickness)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ythickness) as usize - ptr as usize },
540usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(ythickness)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).background) as usize - ptr as usize },
544usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(background)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attach_count) as usize - ptr as usize },
584usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(attach_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).visual) as usize - ptr as usize },
592usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(visual)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).private_font_desc) as usize - ptr as usize },
600usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(private_font_desc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rc_style) as usize - ptr as usize },
608usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(rc_style)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).styles) as usize - ptr as usize },
616usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(styles)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).property_cache) as usize - ptr as usize },
624usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(property_cache)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).icon_factories) as usize - ptr as usize },
632usize,
concat!(
"Offset of field: ",
stringify!(_GtkStyle),
"::",
stringify!(icon_factories)
)
);
}
impl Default for _GtkStyle {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_style_get_type() -> GType;
}
extern "C" {
pub fn gtk_style_new() -> *mut GtkStyle;
}
extern "C" {
pub fn gtk_style_copy(style: *mut GtkStyle) -> *mut GtkStyle;
}
extern "C" {
pub fn gtk_style_attach(style: *mut GtkStyle, window: *mut GdkWindow) -> *mut GtkStyle;
}
extern "C" {
pub fn gtk_style_detach(style: *mut GtkStyle);
}
extern "C" {
pub fn gtk_style_set_background(
style: *mut GtkStyle,
window: *mut GdkWindow,
state_type: GtkStateType,
);
}
extern "C" {
pub fn gtk_style_apply_default_background(
style: *mut GtkStyle,
cr: *mut cairo_t,
window: *mut GdkWindow,
state_type: GtkStateType,
x: gint,
y: gint,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_style_lookup_icon_set(
style: *mut GtkStyle,
stock_id: *const gchar,
) -> *mut GtkIconSet;
}
extern "C" {
pub fn gtk_style_lookup_color(
style: *mut GtkStyle,
color_name: *const gchar,
color: *mut GdkColor,
) -> gboolean;
}
extern "C" {
pub fn gtk_style_render_icon(
style: *mut GtkStyle,
source: *const GtkIconSource,
direction: GtkTextDirection,
state: GtkStateType,
size: GtkIconSize,
widget: *mut GtkWidget,
detail: *const gchar,
) -> *mut GdkPixbuf;
}
extern "C" {
pub fn gtk_paint_hline(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
widget: *mut GtkWidget,
detail: *const gchar,
x1: gint,
x2: gint,
y: gint,
);
}
extern "C" {
pub fn gtk_paint_vline(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
widget: *mut GtkWidget,
detail: *const gchar,
y1_: gint,
y2_: gint,
x: gint,
);
}
extern "C" {
pub fn gtk_paint_shadow(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
shadow_type: GtkShadowType,
widget: *mut GtkWidget,
detail: *const gchar,
x: gint,
y: gint,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_paint_arrow(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
shadow_type: GtkShadowType,
widget: *mut GtkWidget,
detail: *const gchar,
arrow_type: GtkArrowType,
fill: gboolean,
x: gint,
y: gint,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_paint_diamond(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
shadow_type: GtkShadowType,
widget: *mut GtkWidget,
detail: *const gchar,
x: gint,
y: gint,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_paint_box(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
shadow_type: GtkShadowType,
widget: *mut GtkWidget,
detail: *const gchar,
x: gint,
y: gint,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_paint_flat_box(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
shadow_type: GtkShadowType,
widget: *mut GtkWidget,
detail: *const gchar,
x: gint,
y: gint,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_paint_check(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
shadow_type: GtkShadowType,
widget: *mut GtkWidget,
detail: *const gchar,
x: gint,
y: gint,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_paint_option(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
shadow_type: GtkShadowType,
widget: *mut GtkWidget,
detail: *const gchar,
x: gint,
y: gint,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_paint_tab(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
shadow_type: GtkShadowType,
widget: *mut GtkWidget,
detail: *const gchar,
x: gint,
y: gint,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_paint_shadow_gap(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
shadow_type: GtkShadowType,
widget: *mut GtkWidget,
detail: *const gchar,
x: gint,
y: gint,
width: gint,
height: gint,
gap_side: GtkPositionType,
gap_x: gint,
gap_width: gint,
);
}
extern "C" {
pub fn gtk_paint_box_gap(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
shadow_type: GtkShadowType,
widget: *mut GtkWidget,
detail: *const gchar,
x: gint,
y: gint,
width: gint,
height: gint,
gap_side: GtkPositionType,
gap_x: gint,
gap_width: gint,
);
}
extern "C" {
pub fn gtk_paint_extension(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
shadow_type: GtkShadowType,
widget: *mut GtkWidget,
detail: *const gchar,
x: gint,
y: gint,
width: gint,
height: gint,
gap_side: GtkPositionType,
);
}
extern "C" {
pub fn gtk_paint_focus(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
widget: *mut GtkWidget,
detail: *const gchar,
x: gint,
y: gint,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_paint_slider(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
shadow_type: GtkShadowType,
widget: *mut GtkWidget,
detail: *const gchar,
x: gint,
y: gint,
width: gint,
height: gint,
orientation: GtkOrientation,
);
}
extern "C" {
pub fn gtk_paint_handle(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
shadow_type: GtkShadowType,
widget: *mut GtkWidget,
detail: *const gchar,
x: gint,
y: gint,
width: gint,
height: gint,
orientation: GtkOrientation,
);
}
extern "C" {
pub fn gtk_paint_expander(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
widget: *mut GtkWidget,
detail: *const gchar,
x: gint,
y: gint,
expander_style: GtkExpanderStyle,
);
}
extern "C" {
pub fn gtk_paint_layout(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
use_text: gboolean,
widget: *mut GtkWidget,
detail: *const gchar,
x: gint,
y: gint,
layout: *mut PangoLayout,
);
}
extern "C" {
pub fn gtk_paint_resize_grip(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
widget: *mut GtkWidget,
detail: *const gchar,
edge: GdkWindowEdge,
x: gint,
y: gint,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_paint_spinner(
style: *mut GtkStyle,
cr: *mut cairo_t,
state_type: GtkStateType,
widget: *mut GtkWidget,
detail: *const gchar,
step: guint,
x: gint,
y: gint,
width: gint,
height: gint,
);
}
extern "C" {
pub fn gtk_style_get_style_property(
style: *mut GtkStyle,
widget_type: GType,
property_name: *const gchar,
value: *mut GValue,
);
}
extern "C" {
pub fn gtk_style_get(
style: *mut GtkStyle,
widget_type: GType,
first_property_name: *const gchar,
...
);
}
extern "C" {
pub fn gtk_style_has_context(style: *mut GtkStyle) -> gboolean;
}
extern "C" {
pub fn gtk_widget_style_attach(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_has_rc_style(widget: *mut GtkWidget) -> gboolean;
}
extern "C" {
pub fn gtk_widget_set_style(widget: *mut GtkWidget, style: *mut GtkStyle);
}
extern "C" {
pub fn gtk_widget_ensure_style(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_get_style(widget: *mut GtkWidget) -> *mut GtkStyle;
}
extern "C" {
pub fn gtk_widget_modify_style(widget: *mut GtkWidget, style: *mut GtkRcStyle);
}
extern "C" {
pub fn gtk_widget_get_modifier_style(widget: *mut GtkWidget) -> *mut GtkRcStyle;
}
extern "C" {
pub fn gtk_widget_modify_fg(
widget: *mut GtkWidget,
state: GtkStateType,
color: *const GdkColor,
);
}
extern "C" {
pub fn gtk_widget_modify_bg(
widget: *mut GtkWidget,
state: GtkStateType,
color: *const GdkColor,
);
}
extern "C" {
pub fn gtk_widget_modify_text(
widget: *mut GtkWidget,
state: GtkStateType,
color: *const GdkColor,
);
}
extern "C" {
pub fn gtk_widget_modify_base(
widget: *mut GtkWidget,
state: GtkStateType,
color: *const GdkColor,
);
}
extern "C" {
pub fn gtk_widget_modify_cursor(
widget: *mut GtkWidget,
primary: *const GdkColor,
secondary: *const GdkColor,
);
}
extern "C" {
pub fn gtk_widget_modify_font(widget: *mut GtkWidget, font_desc: *mut PangoFontDescription);
}
extern "C" {
pub fn gtk_widget_reset_rc_styles(widget: *mut GtkWidget);
}
extern "C" {
pub fn gtk_widget_get_default_style() -> *mut GtkStyle;
}
extern "C" {
pub fn gtk_widget_path(
widget: *mut GtkWidget,
path_length: *mut guint,
path: *mut *mut gchar,
path_reversed: *mut *mut gchar,
);
}
extern "C" {
pub fn gtk_widget_class_path(
widget: *mut GtkWidget,
path_length: *mut guint,
path: *mut *mut gchar,
path_reversed: *mut *mut gchar,
);
}
extern "C" {
pub fn gtk_widget_render_icon(
widget: *mut GtkWidget,
stock_id: *const gchar,
size: GtkIconSize,
detail: *const gchar,
) -> *mut GdkPixbuf;
}
pub type GtkTable = _GtkTable;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTablePrivate {
_unused: [u8; 0],
}
pub type GtkTablePrivate = _GtkTablePrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkTable {
pub container: GtkContainer,
pub priv_: *mut GtkTablePrivate,
}
#[test]
fn bindgen_test_layout__GtkTable() {
const UNINIT: ::std::mem::MaybeUninit<_GtkTable> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkTable>(),
48usize,
concat!("Size of: ", stringify!(_GtkTable))
);
assert_eq!(
::std::mem::align_of::<_GtkTable>(),
8usize,
concat!("Alignment of ", stringify!(_GtkTable))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).container) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkTable),
"::",
stringify!(container)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_GtkTable),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkTable {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const GtkAttachOptions_GTK_EXPAND: GtkAttachOptions = 1;
pub const GtkAttachOptions_GTK_SHRINK: GtkAttachOptions = 2;
pub const GtkAttachOptions_GTK_FILL: GtkAttachOptions = 4;
#[doc = " GtkAttachOptions:\n @GTK_EXPAND: the widget should expand to take up any extra space in its\n container that has been allocated.\n @GTK_SHRINK: the widget should shrink as and when possible.\n @GTK_FILL: the widget should fill the space allocated to it.\n\n Denotes the expansion properties that a widget will have when it (or its\n parent) is resized."]
pub type GtkAttachOptions = ::std::os::raw::c_uint;
extern "C" {
pub fn gtk_table_get_type() -> GType;
}
extern "C" {
pub fn gtk_table_new(rows: guint, columns: guint, homogeneous: gboolean) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_table_resize(table: *mut GtkTable, rows: guint, columns: guint);
}
extern "C" {
pub fn gtk_table_attach(
table: *mut GtkTable,
child: *mut GtkWidget,
left_attach: guint,
right_attach: guint,
top_attach: guint,
bottom_attach: guint,
xoptions: GtkAttachOptions,
yoptions: GtkAttachOptions,
xpadding: guint,
ypadding: guint,
);
}
extern "C" {
pub fn gtk_table_attach_defaults(
table: *mut GtkTable,
widget: *mut GtkWidget,
left_attach: guint,
right_attach: guint,
top_attach: guint,
bottom_attach: guint,
);
}
extern "C" {
pub fn gtk_table_set_row_spacing(table: *mut GtkTable, row: guint, spacing: guint);
}
extern "C" {
pub fn gtk_table_get_row_spacing(table: *mut GtkTable, row: guint) -> guint;
}
extern "C" {
pub fn gtk_table_set_col_spacing(table: *mut GtkTable, column: guint, spacing: guint);
}
extern "C" {
pub fn gtk_table_get_col_spacing(table: *mut GtkTable, column: guint) -> guint;
}
extern "C" {
pub fn gtk_table_set_row_spacings(table: *mut GtkTable, spacing: guint);
}
extern "C" {
pub fn gtk_table_get_default_row_spacing(table: *mut GtkTable) -> guint;
}
extern "C" {
pub fn gtk_table_set_col_spacings(table: *mut GtkTable, spacing: guint);
}
extern "C" {
pub fn gtk_table_get_default_col_spacing(table: *mut GtkTable) -> guint;
}
extern "C" {
pub fn gtk_table_set_homogeneous(table: *mut GtkTable, homogeneous: gboolean);
}
extern "C" {
pub fn gtk_table_get_homogeneous(table: *mut GtkTable) -> gboolean;
}
extern "C" {
pub fn gtk_table_get_size(table: *mut GtkTable, rows: *mut guint, columns: *mut guint);
}
extern "C" {
pub fn gtk_tearoff_menu_item_get_type() -> GType;
}
extern "C" {
pub fn gtk_tearoff_menu_item_new() -> *mut GtkWidget;
}
pub type GtkThemingEngine = _GtkThemingEngine;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GtkThemingEnginePrivate {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkThemingEngine {
pub parent_object: GObject,
pub priv_: *mut GtkThemingEnginePrivate,
}
#[test]
fn bindgen_test_layout__GtkThemingEngine() {
const UNINIT: ::std::mem::MaybeUninit<_GtkThemingEngine> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkThemingEngine>(),
32usize,
concat!("Size of: ", stringify!(_GtkThemingEngine))
);
assert_eq!(
::std::mem::align_of::<_GtkThemingEngine>(),
8usize,
concat!("Alignment of ", stringify!(_GtkThemingEngine))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_object) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkThemingEngine),
"::",
stringify!(parent_object)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkThemingEngine),
"::",
stringify!(priv_)
)
);
}
impl Default for _GtkThemingEngine {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn gtk_theming_engine_get_type() -> GType;
}
extern "C" {
pub fn gtk_theming_engine_register_property(
name_space: *const gchar,
parse_func: GtkStylePropertyParser,
pspec: *mut GParamSpec,
);
}
extern "C" {
pub fn gtk_theming_engine_get_property(
engine: *mut GtkThemingEngine,
property: *const gchar,
state: GtkStateFlags,
value: *mut GValue,
);
}
extern "C" {
pub fn gtk_theming_engine_get(engine: *mut GtkThemingEngine, state: GtkStateFlags, ...);
}
extern "C" {
pub fn gtk_theming_engine_get_style_property(
engine: *mut GtkThemingEngine,
property_name: *const gchar,
value: *mut GValue,
);
}
extern "C" {
pub fn gtk_theming_engine_get_style(engine: *mut GtkThemingEngine, ...);
}
extern "C" {
pub fn gtk_theming_engine_lookup_color(
engine: *mut GtkThemingEngine,
color_name: *const gchar,
color: *mut GdkRGBA,
) -> gboolean;
}
extern "C" {
pub fn gtk_theming_engine_get_path(engine: *mut GtkThemingEngine) -> *const GtkWidgetPath;
}
extern "C" {
pub fn gtk_theming_engine_has_class(
engine: *mut GtkThemingEngine,
style_class: *const gchar,
) -> gboolean;
}
extern "C" {
pub fn gtk_theming_engine_has_region(
engine: *mut GtkThemingEngine,
style_region: *const gchar,
flags: *mut GtkRegionFlags,
) -> gboolean;
}
extern "C" {
pub fn gtk_theming_engine_get_state(engine: *mut GtkThemingEngine) -> GtkStateFlags;
}
extern "C" {
pub fn gtk_theming_engine_state_is_running(
engine: *mut GtkThemingEngine,
state: GtkStateType,
progress: *mut gdouble,
) -> gboolean;
}
extern "C" {
pub fn gtk_theming_engine_get_direction(engine: *mut GtkThemingEngine) -> GtkTextDirection;
}
extern "C" {
pub fn gtk_theming_engine_get_junction_sides(engine: *mut GtkThemingEngine)
-> GtkJunctionSides;
}
extern "C" {
pub fn gtk_theming_engine_get_color(
engine: *mut GtkThemingEngine,
state: GtkStateFlags,
color: *mut GdkRGBA,
);
}
extern "C" {
pub fn gtk_theming_engine_get_background_color(
engine: *mut GtkThemingEngine,
state: GtkStateFlags,
color: *mut GdkRGBA,
);
}
extern "C" {
pub fn gtk_theming_engine_get_border_color(
engine: *mut GtkThemingEngine,
state: GtkStateFlags,
color: *mut GdkRGBA,
);
}
extern "C" {
pub fn gtk_theming_engine_get_border(
engine: *mut GtkThemingEngine,
state: GtkStateFlags,
border: *mut GtkBorder,
);
}
extern "C" {
pub fn gtk_theming_engine_get_padding(
engine: *mut GtkThemingEngine,
state: GtkStateFlags,
padding: *mut GtkBorder,
);
}
extern "C" {
pub fn gtk_theming_engine_get_margin(
engine: *mut GtkThemingEngine,
state: GtkStateFlags,
margin: *mut GtkBorder,
);
}
extern "C" {
pub fn gtk_theming_engine_get_font(
engine: *mut GtkThemingEngine,
state: GtkStateFlags,
) -> *const PangoFontDescription;
}
extern "C" {
pub fn gtk_theming_engine_load(name: *const gchar) -> *mut GtkThemingEngine;
}
extern "C" {
pub fn gtk_theming_engine_get_screen(engine: *mut GtkThemingEngine) -> *mut GdkScreen;
}
pub type GtkUIManager = _GtkUIManager;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkUIManagerPrivate {
_unused: [u8; 0],
}
pub type GtkUIManagerPrivate = _GtkUIManagerPrivate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkUIManager {
pub parent: GObject,
pub private_data: *mut GtkUIManagerPrivate,
}
#[test]
fn bindgen_test_layout__GtkUIManager() {
const UNINIT: ::std::mem::MaybeUninit<_GtkUIManager> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_GtkUIManager>(),
32usize,
concat!("Size of: ", stringify!(_GtkUIManager))
);
assert_eq!(
::std::mem::align_of::<_GtkUIManager>(),
8usize,
concat!("Alignment of ", stringify!(_GtkUIManager))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GtkUIManager),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).private_data) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_GtkUIManager),
"::",
stringify!(private_data)
)
);
}
impl Default for _GtkUIManager {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const GtkUIManagerItemType_GTK_UI_MANAGER_AUTO: GtkUIManagerItemType = 0;
pub const GtkUIManagerItemType_GTK_UI_MANAGER_MENUBAR: GtkUIManagerItemType = 1;
pub const GtkUIManagerItemType_GTK_UI_MANAGER_MENU: GtkUIManagerItemType = 2;
pub const GtkUIManagerItemType_GTK_UI_MANAGER_TOOLBAR: GtkUIManagerItemType = 4;
pub const GtkUIManagerItemType_GTK_UI_MANAGER_PLACEHOLDER: GtkUIManagerItemType = 8;
pub const GtkUIManagerItemType_GTK_UI_MANAGER_POPUP: GtkUIManagerItemType = 16;
pub const GtkUIManagerItemType_GTK_UI_MANAGER_MENUITEM: GtkUIManagerItemType = 32;
pub const GtkUIManagerItemType_GTK_UI_MANAGER_TOOLITEM: GtkUIManagerItemType = 64;
pub const GtkUIManagerItemType_GTK_UI_MANAGER_SEPARATOR: GtkUIManagerItemType = 128;
pub const GtkUIManagerItemType_GTK_UI_MANAGER_ACCELERATOR: GtkUIManagerItemType = 256;
pub const GtkUIManagerItemType_GTK_UI_MANAGER_POPUP_WITH_ACCELS: GtkUIManagerItemType = 512;
#[doc = " GtkUIManagerItemType:\n @GTK_UI_MANAGER_AUTO: Pick the type of the UI element according to context.\n @GTK_UI_MANAGER_MENUBAR: Create a menubar.\n @GTK_UI_MANAGER_MENU: Create a menu.\n @GTK_UI_MANAGER_TOOLBAR: Create a toolbar.\n @GTK_UI_MANAGER_PLACEHOLDER: Insert a placeholder.\n @GTK_UI_MANAGER_POPUP: Create a popup menu.\n @GTK_UI_MANAGER_MENUITEM: Create a menuitem.\n @GTK_UI_MANAGER_TOOLITEM: Create a toolitem.\n @GTK_UI_MANAGER_SEPARATOR: Create a separator.\n @GTK_UI_MANAGER_ACCELERATOR: Install an accelerator.\n @GTK_UI_MANAGER_POPUP_WITH_ACCELS: Same as %GTK_UI_MANAGER_POPUP, but the\n actions’ accelerators are shown.\n\n These enumeration values are used by gtk_ui_manager_add_ui() to determine\n what UI element to create.\n\n Deprecated: 3.10"]
pub type GtkUIManagerItemType = ::std::os::raw::c_uint;
extern "C" {
pub fn gtk_ui_manager_get_type() -> GType;
}
extern "C" {
pub fn gtk_ui_manager_new() -> *mut GtkUIManager;
}
extern "C" {
pub fn gtk_ui_manager_set_add_tearoffs(manager: *mut GtkUIManager, add_tearoffs: gboolean);
}
extern "C" {
pub fn gtk_ui_manager_get_add_tearoffs(manager: *mut GtkUIManager) -> gboolean;
}
extern "C" {
pub fn gtk_ui_manager_insert_action_group(
manager: *mut GtkUIManager,
action_group: *mut GtkActionGroup,
pos: gint,
);
}
extern "C" {
pub fn gtk_ui_manager_remove_action_group(
manager: *mut GtkUIManager,
action_group: *mut GtkActionGroup,
);
}
extern "C" {
pub fn gtk_ui_manager_get_action_groups(manager: *mut GtkUIManager) -> *mut GList;
}
extern "C" {
pub fn gtk_ui_manager_get_accel_group(manager: *mut GtkUIManager) -> *mut GtkAccelGroup;
}
extern "C" {
pub fn gtk_ui_manager_get_widget(
manager: *mut GtkUIManager,
path: *const gchar,
) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_ui_manager_get_toplevels(
manager: *mut GtkUIManager,
types: GtkUIManagerItemType,
) -> *mut GSList;
}
extern "C" {
pub fn gtk_ui_manager_get_action(
manager: *mut GtkUIManager,
path: *const gchar,
) -> *mut GtkAction;
}
extern "C" {
pub fn gtk_ui_manager_add_ui_from_string(
manager: *mut GtkUIManager,
buffer: *const gchar,
length: gssize,
error: *mut *mut GError,
) -> guint;
}
extern "C" {
pub fn gtk_ui_manager_add_ui_from_file(
manager: *mut GtkUIManager,
filename: *const gchar,
error: *mut *mut GError,
) -> guint;
}
extern "C" {
pub fn gtk_ui_manager_add_ui_from_resource(
manager: *mut GtkUIManager,
resource_path: *const gchar,
error: *mut *mut GError,
) -> guint;
}
extern "C" {
pub fn gtk_ui_manager_add_ui(
manager: *mut GtkUIManager,
merge_id: guint,
path: *const gchar,
name: *const gchar,
action: *const gchar,
type_: GtkUIManagerItemType,
top: gboolean,
);
}
extern "C" {
pub fn gtk_ui_manager_remove_ui(manager: *mut GtkUIManager, merge_id: guint);
}
extern "C" {
pub fn gtk_ui_manager_get_ui(manager: *mut GtkUIManager) -> *mut gchar;
}
extern "C" {
pub fn gtk_ui_manager_ensure_update(manager: *mut GtkUIManager);
}
extern "C" {
pub fn gtk_ui_manager_new_merge_id(manager: *mut GtkUIManager) -> guint;
}
extern "C" {
pub fn gtk_vbutton_box_get_type() -> GType;
}
extern "C" {
pub fn gtk_vbutton_box_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_vbox_get_type() -> GType;
}
extern "C" {
pub fn gtk_vbox_new(homogeneous: gboolean, spacing: gint) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_vpaned_get_type() -> GType;
}
extern "C" {
pub fn gtk_vpaned_new() -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_vscale_get_type() -> GType;
}
extern "C" {
pub fn gtk_vscale_new(adjustment: *mut GtkAdjustment) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_vscale_new_with_range(min: gdouble, max: gdouble, step: gdouble) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_vscrollbar_get_type() -> GType;
}
extern "C" {
pub fn gtk_vscrollbar_new(adjustment: *mut GtkAdjustment) -> *mut GtkWidget;
}
extern "C" {
pub fn gtk_vseparator_get_type() -> GType;
}
extern "C" {
pub fn gtk_vseparator_new() -> *mut GtkWidget;
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
pub gp_offset: ::std::os::raw::c_uint,
pub fp_offset: ::std::os::raw::c_uint,
pub overflow_arg_area: *mut ::std::os::raw::c_void,
pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
const UNINIT: ::std::mem::MaybeUninit<__va_list_tag> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__va_list_tag>(),
24usize,
concat!("Size of: ", stringify!(__va_list_tag))
);
assert_eq!(
::std::mem::align_of::<__va_list_tag>(),
8usize,
concat!("Alignment of ", stringify!(__va_list_tag))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gp_offset) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(gp_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fp_offset) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(fp_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).overflow_arg_area) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(overflow_arg_area)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reg_save_area) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(reg_save_area)
)
);
}
impl Default for __va_list_tag {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}