#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
clippy::approx_constant,
clippy::type_complexity,
clippy::unreadable_literal,
clippy::upper_case_acronyms
)]
#![cfg_attr(feature = "dox", feature(doc_cfg))]
#[allow(unused_imports)]
use libc::{
c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
intptr_t, size_t, ssize_t, uintptr_t, FILE,
};
#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};
pub type AdwAnimationState = c_int;
pub const ADW_ANIMATION_IDLE: AdwAnimationState = 0;
pub const ADW_ANIMATION_PAUSED: AdwAnimationState = 1;
pub const ADW_ANIMATION_PLAYING: AdwAnimationState = 2;
pub const ADW_ANIMATION_FINISHED: AdwAnimationState = 3;
pub type AdwCenteringPolicy = c_int;
pub const ADW_CENTERING_POLICY_LOOSE: AdwCenteringPolicy = 0;
pub const ADW_CENTERING_POLICY_STRICT: AdwCenteringPolicy = 1;
pub type AdwColorScheme = c_int;
pub const ADW_COLOR_SCHEME_DEFAULT: AdwColorScheme = 0;
pub const ADW_COLOR_SCHEME_FORCE_LIGHT: AdwColorScheme = 1;
pub const ADW_COLOR_SCHEME_PREFER_LIGHT: AdwColorScheme = 2;
pub const ADW_COLOR_SCHEME_PREFER_DARK: AdwColorScheme = 3;
pub const ADW_COLOR_SCHEME_FORCE_DARK: AdwColorScheme = 4;
pub type AdwEasing = c_int;
pub const ADW_LINEAR: AdwEasing = 0;
pub const ADW_EASE_IN_QUAD: AdwEasing = 1;
pub const ADW_EASE_OUT_QUAD: AdwEasing = 2;
pub const ADW_EASE_IN_OUT_QUAD: AdwEasing = 3;
pub const ADW_EASE_IN_CUBIC: AdwEasing = 4;
pub const ADW_EASE_OUT_CUBIC: AdwEasing = 5;
pub const ADW_EASE_IN_OUT_CUBIC: AdwEasing = 6;
pub const ADW_EASE_IN_QUART: AdwEasing = 7;
pub const ADW_EASE_OUT_QUART: AdwEasing = 8;
pub const ADW_EASE_IN_OUT_QUART: AdwEasing = 9;
pub const ADW_EASE_IN_QUINT: AdwEasing = 10;
pub const ADW_EASE_OUT_QUINT: AdwEasing = 11;
pub const ADW_EASE_IN_OUT_QUINT: AdwEasing = 12;
pub const ADW_EASE_IN_SINE: AdwEasing = 13;
pub const ADW_EASE_OUT_SINE: AdwEasing = 14;
pub const ADW_EASE_IN_OUT_SINE: AdwEasing = 15;
pub const ADW_EASE_IN_EXPO: AdwEasing = 16;
pub const ADW_EASE_OUT_EXPO: AdwEasing = 17;
pub const ADW_EASE_IN_OUT_EXPO: AdwEasing = 18;
pub const ADW_EASE_IN_CIRC: AdwEasing = 19;
pub const ADW_EASE_OUT_CIRC: AdwEasing = 20;
pub const ADW_EASE_IN_OUT_CIRC: AdwEasing = 21;
pub const ADW_EASE_IN_ELASTIC: AdwEasing = 22;
pub const ADW_EASE_OUT_ELASTIC: AdwEasing = 23;
pub const ADW_EASE_IN_OUT_ELASTIC: AdwEasing = 24;
pub const ADW_EASE_IN_BACK: AdwEasing = 25;
pub const ADW_EASE_OUT_BACK: AdwEasing = 26;
pub const ADW_EASE_IN_OUT_BACK: AdwEasing = 27;
pub const ADW_EASE_IN_BOUNCE: AdwEasing = 28;
pub const ADW_EASE_OUT_BOUNCE: AdwEasing = 29;
pub const ADW_EASE_IN_OUT_BOUNCE: AdwEasing = 30;
pub type AdwFlapFoldPolicy = c_int;
pub const ADW_FLAP_FOLD_POLICY_NEVER: AdwFlapFoldPolicy = 0;
pub const ADW_FLAP_FOLD_POLICY_ALWAYS: AdwFlapFoldPolicy = 1;
pub const ADW_FLAP_FOLD_POLICY_AUTO: AdwFlapFoldPolicy = 2;
pub type AdwFlapTransitionType = c_int;
pub const ADW_FLAP_TRANSITION_TYPE_OVER: AdwFlapTransitionType = 0;
pub const ADW_FLAP_TRANSITION_TYPE_UNDER: AdwFlapTransitionType = 1;
pub const ADW_FLAP_TRANSITION_TYPE_SLIDE: AdwFlapTransitionType = 2;
pub type AdwFoldThresholdPolicy = c_int;
pub const ADW_FOLD_THRESHOLD_POLICY_MINIMUM: AdwFoldThresholdPolicy = 0;
pub const ADW_FOLD_THRESHOLD_POLICY_NATURAL: AdwFoldThresholdPolicy = 1;
pub type AdwLeafletTransitionType = c_int;
pub const ADW_LEAFLET_TRANSITION_TYPE_OVER: AdwLeafletTransitionType = 0;
pub const ADW_LEAFLET_TRANSITION_TYPE_UNDER: AdwLeafletTransitionType = 1;
pub const ADW_LEAFLET_TRANSITION_TYPE_SLIDE: AdwLeafletTransitionType = 2;
pub type AdwNavigationDirection = c_int;
pub const ADW_NAVIGATION_DIRECTION_BACK: AdwNavigationDirection = 0;
pub const ADW_NAVIGATION_DIRECTION_FORWARD: AdwNavigationDirection = 1;
pub type AdwResponseAppearance = c_int;
pub const ADW_RESPONSE_DEFAULT: AdwResponseAppearance = 0;
pub const ADW_RESPONSE_SUGGESTED: AdwResponseAppearance = 1;
pub const ADW_RESPONSE_DESTRUCTIVE: AdwResponseAppearance = 2;
pub type AdwSqueezerTransitionType = c_int;
pub const ADW_SQUEEZER_TRANSITION_TYPE_NONE: AdwSqueezerTransitionType = 0;
pub const ADW_SQUEEZER_TRANSITION_TYPE_CROSSFADE: AdwSqueezerTransitionType = 1;
pub type AdwToastPriority = c_int;
pub const ADW_TOAST_PRIORITY_NORMAL: AdwToastPriority = 0;
pub const ADW_TOAST_PRIORITY_HIGH: AdwToastPriority = 1;
pub type AdwViewSwitcherPolicy = c_int;
pub const ADW_VIEW_SWITCHER_POLICY_NARROW: AdwViewSwitcherPolicy = 0;
pub const ADW_VIEW_SWITCHER_POLICY_WIDE: AdwViewSwitcherPolicy = 1;
pub const ADW_DURATION_INFINITE: c_uint = 4294967295;
pub type AdwTabViewShortcuts = c_uint;
pub const ADW_TAB_VIEW_SHORTCUT_NONE: AdwTabViewShortcuts = 0;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_TAB: AdwTabViewShortcuts = 1;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_SHIFT_TAB: AdwTabViewShortcuts = 2;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_PAGE_UP: AdwTabViewShortcuts = 4;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_PAGE_DOWN: AdwTabViewShortcuts = 8;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_HOME: AdwTabViewShortcuts = 16;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_END: AdwTabViewShortcuts = 32;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_SHIFT_PAGE_UP: AdwTabViewShortcuts = 64;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_SHIFT_PAGE_DOWN: AdwTabViewShortcuts = 128;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_SHIFT_HOME: AdwTabViewShortcuts = 256;
pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_SHIFT_END: AdwTabViewShortcuts = 512;
pub const ADW_TAB_VIEW_SHORTCUT_ALT_DIGITS: AdwTabViewShortcuts = 1024;
pub const ADW_TAB_VIEW_SHORTCUT_ALT_ZERO: AdwTabViewShortcuts = 2048;
pub const ADW_TAB_VIEW_SHORTCUT_ALL_SHORTCUTS: AdwTabViewShortcuts = 4095;
pub type AdwAnimationTargetFunc = Option<unsafe extern "C" fn(c_double, gpointer)>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwAboutWindowClass {
pub parent_class: AdwWindowClass,
}
impl ::std::fmt::Debug for AdwAboutWindowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwAboutWindowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwActionRowClass {
pub parent_class: AdwPreferencesRowClass,
pub activate: Option<unsafe extern "C" fn(*mut AdwActionRow)>,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwActionRowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwActionRowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("activate", &self.activate)
.finish()
}
}
#[repr(C)]
pub struct _AdwAnimationClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type AdwAnimationClass = *mut _AdwAnimationClass;
#[repr(C)]
pub struct _AdwAnimationTargetClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type AdwAnimationTargetClass = *mut _AdwAnimationTargetClass;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwApplicationClass {
pub parent_class: gtk::GtkApplicationClass,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwApplicationClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwApplicationClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwApplicationWindowClass {
pub parent_class: gtk::GtkApplicationWindowClass,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwApplicationWindowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwApplicationWindowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwAvatarClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwAvatarClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwAvatarClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwBinClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwBinClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwBinClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwButtonContentClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwButtonContentClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwButtonContentClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _AdwCallbackAnimationTargetClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type AdwCallbackAnimationTargetClass = *mut _AdwCallbackAnimationTargetClass;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwCarouselClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwCarouselClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwCarouselClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwCarouselIndicatorDotsClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwCarouselIndicatorDotsClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwCarouselIndicatorDotsClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwCarouselIndicatorLinesClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwCarouselIndicatorLinesClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwCarouselIndicatorLinesClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwClampClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwClampClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwClampClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwClampLayoutClass {
pub parent_class: gtk::GtkLayoutManagerClass,
}
impl ::std::fmt::Debug for AdwClampLayoutClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwClampLayoutClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwClampScrollableClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwClampScrollableClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwClampScrollableClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwComboRowClass {
pub parent_class: AdwActionRowClass,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwComboRowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwComboRowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwEntryRowClass {
pub parent_class: AdwPreferencesRowClass,
}
impl ::std::fmt::Debug for AdwEntryRowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwEntryRowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwEnumListItemClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for AdwEnumListItemClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwEnumListItemClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwEnumListModelClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for AdwEnumListModelClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwEnumListModelClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwExpanderRowClass {
pub parent_class: AdwPreferencesRowClass,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwExpanderRowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwExpanderRowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwFlapClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwFlapClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwFlapClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwHeaderBarClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwHeaderBarClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwHeaderBarClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwLeafletClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwLeafletClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwLeafletClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwLeafletPageClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for AdwLeafletPageClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwLeafletPageClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwMessageDialogClass {
pub parent_class: gtk::GtkWindowClass,
pub response: Option<unsafe extern "C" fn(*mut AdwMessageDialog, *const c_char)>,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwMessageDialogClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwMessageDialogClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("response", &self.response)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPasswordEntryRowClass {
pub parent_class: AdwEntryRowClass,
}
impl ::std::fmt::Debug for AdwPasswordEntryRowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwPasswordEntryRowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPreferencesGroupClass {
pub parent_class: gtk::GtkWidgetClass,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwPreferencesGroupClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwPreferencesGroupClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPreferencesPageClass {
pub parent_class: gtk::GtkWidgetClass,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwPreferencesPageClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwPreferencesPageClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPreferencesRowClass {
pub parent_class: gtk::GtkListBoxRowClass,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwPreferencesRowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwPreferencesRowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPreferencesWindowClass {
pub parent_class: AdwWindowClass,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwPreferencesWindowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwPreferencesWindowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _AdwPropertyAnimationTargetClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type AdwPropertyAnimationTargetClass = *mut _AdwPropertyAnimationTargetClass;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwSplitButtonClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwSplitButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSplitButtonClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _AdwSpringAnimationClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type AdwSpringAnimationClass = *mut _AdwSpringAnimationClass;
#[repr(C)]
pub struct AdwSpringParams {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwSpringParams {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSpringParams @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwSqueezerClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwSqueezerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSqueezerClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwSqueezerPageClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for AdwSqueezerPageClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSqueezerPageClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwStatusPageClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwStatusPageClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwStatusPageClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwStyleManagerClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for AdwStyleManagerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwStyleManagerClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwSwipeTrackerClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for AdwSwipeTrackerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSwipeTrackerClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwSwipeableInterface {
pub parent: gobject::GTypeInterface,
pub get_distance: Option<unsafe extern "C" fn(*mut AdwSwipeable) -> c_double>,
pub get_snap_points:
Option<unsafe extern "C" fn(*mut AdwSwipeable, *mut c_int) -> *mut c_double>,
pub get_progress: Option<unsafe extern "C" fn(*mut AdwSwipeable) -> c_double>,
pub get_cancel_progress: Option<unsafe extern "C" fn(*mut AdwSwipeable) -> c_double>,
pub get_swipe_area: Option<
unsafe extern "C" fn(
*mut AdwSwipeable,
AdwNavigationDirection,
gboolean,
*mut gdk::GdkRectangle,
),
>,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwSwipeableInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSwipeableInterface @ {:p}", self))
.field("parent", &self.parent)
.field("get_distance", &self.get_distance)
.field("get_snap_points", &self.get_snap_points)
.field("get_progress", &self.get_progress)
.field("get_cancel_progress", &self.get_cancel_progress)
.field("get_swipe_area", &self.get_swipe_area)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwTabBarClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwTabBarClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwTabBarClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwTabButtonClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwTabButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwTabButtonClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwTabOverviewClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwTabOverviewClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwTabOverviewClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwTabPageClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for AdwTabPageClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwTabPageClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwTabViewClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwTabViewClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwTabViewClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _AdwTimedAnimationClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type AdwTimedAnimationClass = *mut _AdwTimedAnimationClass;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwToastClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for AdwToastClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwToastClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwToastOverlayClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwToastOverlayClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwToastOverlayClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwViewStackClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwViewStackClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwViewStackClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwViewStackPageClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for AdwViewStackPageClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwViewStackPageClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwViewSwitcherBarClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwViewSwitcherBarClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwViewSwitcherBarClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwViewSwitcherClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwViewSwitcherClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwViewSwitcherClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwViewSwitcherTitleClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwViewSwitcherTitleClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwViewSwitcherTitleClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwWindowClass {
pub parent_class: gtk::GtkWindowClass,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwWindowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwWindowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwWindowTitleClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwWindowTitleClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwWindowTitleClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct AdwAboutWindow {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwAboutWindow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwAboutWindow @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwActionRow {
pub parent_instance: AdwPreferencesRow,
}
impl ::std::fmt::Debug for AdwActionRow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwActionRow @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwAnimation {
pub parent_instance: gobject::GObject,
}
impl ::std::fmt::Debug for AdwAnimation {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwAnimation @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct AdwAnimationTarget {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwAnimationTarget {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwAnimationTarget @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwApplication {
pub parent_instance: gtk::GtkApplication,
}
impl ::std::fmt::Debug for AdwApplication {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwApplication @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwApplicationWindow {
pub parent_instance: gtk::GtkApplicationWindow,
}
impl ::std::fmt::Debug for AdwApplicationWindow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwApplicationWindow @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct AdwAvatar {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwAvatar {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwAvatar @ {:p}", self)).finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwBin {
pub parent_instance: gtk::GtkWidget,
}
impl ::std::fmt::Debug for AdwBin {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwBin @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct AdwButtonContent {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwButtonContent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwButtonContent @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwCallbackAnimationTarget {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwCallbackAnimationTarget {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwCallbackAnimationTarget @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwCarousel {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwCarousel {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwCarousel @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwCarouselIndicatorDots {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwCarouselIndicatorDots {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwCarouselIndicatorDots @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwCarouselIndicatorLines {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwCarouselIndicatorLines {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwCarouselIndicatorLines @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwClamp {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwClamp {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwClamp @ {:p}", self)).finish()
}
}
#[repr(C)]
pub struct AdwClampLayout {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwClampLayout {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwClampLayout @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwClampScrollable {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwClampScrollable {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwClampScrollable @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwComboRow {
pub parent_instance: AdwActionRow,
}
impl ::std::fmt::Debug for AdwComboRow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwComboRow @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwEntryRow {
pub parent_instance: AdwPreferencesRow,
}
impl ::std::fmt::Debug for AdwEntryRow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwEntryRow @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct AdwEnumListItem {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwEnumListItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwEnumListItem @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwEnumListModel {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwEnumListModel {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwEnumListModel @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwExpanderRow {
pub parent_instance: AdwPreferencesRow,
}
impl ::std::fmt::Debug for AdwExpanderRow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwExpanderRow @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct AdwFlap {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwFlap {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwFlap @ {:p}", self)).finish()
}
}
#[repr(C)]
pub struct AdwHeaderBar {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwHeaderBar {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwHeaderBar @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwLeaflet {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwLeaflet {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwLeaflet @ {:p}", self)).finish()
}
}
#[repr(C)]
pub struct AdwLeafletPage {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwLeafletPage {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwLeafletPage @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwMessageDialog {
pub parent_instance: gtk::GtkWindow,
}
impl ::std::fmt::Debug for AdwMessageDialog {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwMessageDialog @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct AdwPasswordEntryRow {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwPasswordEntryRow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwPasswordEntryRow @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPreferencesGroup {
pub parent_instance: gtk::GtkWidget,
}
impl ::std::fmt::Debug for AdwPreferencesGroup {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwPreferencesGroup @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPreferencesPage {
pub parent_instance: gtk::GtkWidget,
}
impl ::std::fmt::Debug for AdwPreferencesPage {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwPreferencesPage @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPreferencesRow {
pub parent_instance: gtk::GtkListBoxRow,
}
impl ::std::fmt::Debug for AdwPreferencesRow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwPreferencesRow @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPreferencesWindow {
pub parent_instance: AdwWindow,
}
impl ::std::fmt::Debug for AdwPreferencesWindow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwPreferencesWindow @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct AdwPropertyAnimationTarget {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwPropertyAnimationTarget {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwPropertyAnimationTarget @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwSplitButton {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwSplitButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSplitButton @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwSpringAnimation {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwSpringAnimation {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSpringAnimation @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwSqueezer {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwSqueezer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSqueezer @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwSqueezerPage {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwSqueezerPage {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSqueezerPage @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwStatusPage {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwStatusPage {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwStatusPage @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwStyleManager {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwStyleManager {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwStyleManager @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwSwipeTracker {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwSwipeTracker {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSwipeTracker @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwTabBar {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwTabBar {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwTabBar @ {:p}", self)).finish()
}
}
#[repr(C)]
pub struct AdwTabButton {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwTabButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwTabButton @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwTabOverview {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwTabOverview {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwTabOverview @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwTabPage {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwTabPage {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwTabPage @ {:p}", self)).finish()
}
}
#[repr(C)]
pub struct AdwTabView {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwTabView {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwTabView @ {:p}", self)).finish()
}
}
#[repr(C)]
pub struct AdwTimedAnimation {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwTimedAnimation {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwTimedAnimation @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwToast {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwToast {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwToast @ {:p}", self)).finish()
}
}
#[repr(C)]
pub struct AdwToastOverlay {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwToastOverlay {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwToastOverlay @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwViewStack {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwViewStack {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwViewStack @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwViewStackPage {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwViewStackPage {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwViewStackPage @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwViewSwitcher {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwViewSwitcher {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwViewSwitcher @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwViewSwitcherBar {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwViewSwitcherBar {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwViewSwitcherBar @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwViewSwitcherTitle {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwViewSwitcherTitle {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwViewSwitcherTitle @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwWindow {
pub parent_instance: gtk::GtkWindow,
}
impl ::std::fmt::Debug for AdwWindow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwWindow @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct AdwWindowTitle {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwWindowTitle {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwWindowTitle @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct AdwSwipeable {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwSwipeable {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "AdwSwipeable @ {:p}", self)
}
}
#[link(name = "adwaita-1")]
extern "C" {
pub fn adw_animation_state_get_type() -> GType;
pub fn adw_centering_policy_get_type() -> GType;
pub fn adw_color_scheme_get_type() -> GType;
pub fn adw_easing_get_type() -> GType;
pub fn adw_easing_ease(self_: AdwEasing, value: c_double) -> c_double;
pub fn adw_flap_fold_policy_get_type() -> GType;
pub fn adw_flap_transition_type_get_type() -> GType;
pub fn adw_fold_threshold_policy_get_type() -> GType;
pub fn adw_leaflet_transition_type_get_type() -> GType;
pub fn adw_navigation_direction_get_type() -> GType;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_response_appearance_get_type() -> GType;
pub fn adw_squeezer_transition_type_get_type() -> GType;
pub fn adw_toast_priority_get_type() -> GType;
pub fn adw_view_switcher_policy_get_type() -> GType;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_tab_view_shortcuts_get_type() -> GType;
pub fn adw_spring_params_get_type() -> GType;
pub fn adw_spring_params_new(
damping_ratio: c_double,
mass: c_double,
stiffness: c_double,
) -> *mut AdwSpringParams;
pub fn adw_spring_params_new_full(
damping: c_double,
mass: c_double,
stiffness: c_double,
) -> *mut AdwSpringParams;
pub fn adw_spring_params_get_damping(self_: *mut AdwSpringParams) -> c_double;
pub fn adw_spring_params_get_damping_ratio(self_: *mut AdwSpringParams) -> c_double;
pub fn adw_spring_params_get_mass(self_: *mut AdwSpringParams) -> c_double;
pub fn adw_spring_params_get_stiffness(self_: *mut AdwSpringParams) -> c_double;
pub fn adw_spring_params_ref(self_: *mut AdwSpringParams) -> *mut AdwSpringParams;
pub fn adw_spring_params_unref(self_: *mut AdwSpringParams);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_type() -> GType;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_new() -> *mut gtk::GtkWidget;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_add_acknowledgement_section(
self_: *mut AdwAboutWindow,
name: *const c_char,
people: *mut *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_add_credit_section(
self_: *mut AdwAboutWindow,
name: *const c_char,
people: *mut *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_add_legal_section(
self_: *mut AdwAboutWindow,
title: *const c_char,
copyright: *const c_char,
license_type: gtk::GtkLicense,
license: *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_add_link(
self_: *mut AdwAboutWindow,
title: *const c_char,
url: *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_application_icon(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_application_name(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_artists(self_: *mut AdwAboutWindow) -> *const *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_comments(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_copyright(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_debug_info(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_debug_info_filename(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_designers(self_: *mut AdwAboutWindow) -> *const *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_developer_name(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_developers(self_: *mut AdwAboutWindow) -> *const *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_documenters(self_: *mut AdwAboutWindow) -> *const *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_issue_url(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_license(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_license_type(self_: *mut AdwAboutWindow) -> gtk::GtkLicense;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_release_notes(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_release_notes_version(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_support_url(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_translator_credits(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_version(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_website(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_application_icon(
self_: *mut AdwAboutWindow,
application_icon: *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_application_name(
self_: *mut AdwAboutWindow,
application_name: *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_artists(self_: *mut AdwAboutWindow, artists: *mut *const c_char);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_comments(self_: *mut AdwAboutWindow, comments: *const c_char);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_copyright(self_: *mut AdwAboutWindow, copyright: *const c_char);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_debug_info(self_: *mut AdwAboutWindow, debug_info: *const c_char);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_debug_info_filename(
self_: *mut AdwAboutWindow,
filename: *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_designers(
self_: *mut AdwAboutWindow,
designers: *mut *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_developer_name(
self_: *mut AdwAboutWindow,
developer_name: *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_developers(
self_: *mut AdwAboutWindow,
developers: *mut *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_documenters(
self_: *mut AdwAboutWindow,
documenters: *mut *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_issue_url(self_: *mut AdwAboutWindow, issue_url: *const c_char);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_license(self_: *mut AdwAboutWindow, license: *const c_char);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_license_type(
self_: *mut AdwAboutWindow,
license_type: gtk::GtkLicense,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_release_notes(
self_: *mut AdwAboutWindow,
release_notes: *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_release_notes_version(
self_: *mut AdwAboutWindow,
version: *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_support_url(self_: *mut AdwAboutWindow, support_url: *const c_char);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_translator_credits(
self_: *mut AdwAboutWindow,
translator_credits: *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_version(self_: *mut AdwAboutWindow, version: *const c_char);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_website(self_: *mut AdwAboutWindow, website: *const c_char);
pub fn adw_action_row_get_type() -> GType;
pub fn adw_action_row_new() -> *mut gtk::GtkWidget;
pub fn adw_action_row_activate(self_: *mut AdwActionRow);
pub fn adw_action_row_add_prefix(self_: *mut AdwActionRow, widget: *mut gtk::GtkWidget);
pub fn adw_action_row_add_suffix(self_: *mut AdwActionRow, widget: *mut gtk::GtkWidget);
pub fn adw_action_row_get_activatable_widget(self_: *mut AdwActionRow) -> *mut gtk::GtkWidget;
pub fn adw_action_row_get_icon_name(self_: *mut AdwActionRow) -> *const c_char;
pub fn adw_action_row_get_subtitle(self_: *mut AdwActionRow) -> *const c_char;
pub fn adw_action_row_get_subtitle_lines(self_: *mut AdwActionRow) -> c_int;
pub fn adw_action_row_get_title_lines(self_: *mut AdwActionRow) -> c_int;
pub fn adw_action_row_remove(self_: *mut AdwActionRow, widget: *mut gtk::GtkWidget);
pub fn adw_action_row_set_activatable_widget(
self_: *mut AdwActionRow,
widget: *mut gtk::GtkWidget,
);
pub fn adw_action_row_set_icon_name(self_: *mut AdwActionRow, icon_name: *const c_char);
pub fn adw_action_row_set_subtitle(self_: *mut AdwActionRow, subtitle: *const c_char);
pub fn adw_action_row_set_subtitle_lines(self_: *mut AdwActionRow, subtitle_lines: c_int);
pub fn adw_action_row_set_title_lines(self_: *mut AdwActionRow, title_lines: c_int);
pub fn adw_animation_get_type() -> GType;
pub fn adw_animation_get_state(self_: *mut AdwAnimation) -> AdwAnimationState;
pub fn adw_animation_get_target(self_: *mut AdwAnimation) -> *mut AdwAnimationTarget;
pub fn adw_animation_get_value(self_: *mut AdwAnimation) -> c_double;
pub fn adw_animation_get_widget(self_: *mut AdwAnimation) -> *mut gtk::GtkWidget;
pub fn adw_animation_pause(self_: *mut AdwAnimation);
pub fn adw_animation_play(self_: *mut AdwAnimation);
pub fn adw_animation_reset(self_: *mut AdwAnimation);
pub fn adw_animation_resume(self_: *mut AdwAnimation);
pub fn adw_animation_set_target(self_: *mut AdwAnimation, target: *mut AdwAnimationTarget);
pub fn adw_animation_skip(self_: *mut AdwAnimation);
pub fn adw_animation_target_get_type() -> GType;
pub fn adw_application_get_type() -> GType;
pub fn adw_application_new(
application_id: *const c_char,
flags: gio::GApplicationFlags,
) -> *mut AdwApplication;
pub fn adw_application_get_style_manager(self_: *mut AdwApplication) -> *mut AdwStyleManager;
pub fn adw_application_window_get_type() -> GType;
pub fn adw_application_window_new(app: *mut gtk::GtkApplication) -> *mut gtk::GtkWidget;
pub fn adw_application_window_get_content(
self_: *mut AdwApplicationWindow,
) -> *mut gtk::GtkWidget;
pub fn adw_application_window_set_content(
self_: *mut AdwApplicationWindow,
content: *mut gtk::GtkWidget,
);
pub fn adw_avatar_get_type() -> GType;
pub fn adw_avatar_new(
size: c_int,
text: *const c_char,
show_initials: gboolean,
) -> *mut gtk::GtkWidget;
pub fn adw_avatar_draw_to_texture(
self_: *mut AdwAvatar,
scale_factor: c_int,
) -> *mut gdk::GdkTexture;
pub fn adw_avatar_get_custom_image(self_: *mut AdwAvatar) -> *mut gdk::GdkPaintable;
pub fn adw_avatar_get_icon_name(self_: *mut AdwAvatar) -> *const c_char;
pub fn adw_avatar_get_show_initials(self_: *mut AdwAvatar) -> gboolean;
pub fn adw_avatar_get_size(self_: *mut AdwAvatar) -> c_int;
pub fn adw_avatar_get_text(self_: *mut AdwAvatar) -> *const c_char;
pub fn adw_avatar_set_custom_image(self_: *mut AdwAvatar, custom_image: *mut gdk::GdkPaintable);
pub fn adw_avatar_set_icon_name(self_: *mut AdwAvatar, icon_name: *const c_char);
pub fn adw_avatar_set_show_initials(self_: *mut AdwAvatar, show_initials: gboolean);
pub fn adw_avatar_set_size(self_: *mut AdwAvatar, size: c_int);
pub fn adw_avatar_set_text(self_: *mut AdwAvatar, text: *const c_char);
pub fn adw_bin_get_type() -> GType;
pub fn adw_bin_new() -> *mut gtk::GtkWidget;
pub fn adw_bin_get_child(self_: *mut AdwBin) -> *mut gtk::GtkWidget;
pub fn adw_bin_set_child(self_: *mut AdwBin, child: *mut gtk::GtkWidget);
pub fn adw_button_content_get_type() -> GType;
pub fn adw_button_content_new() -> *mut gtk::GtkWidget;
pub fn adw_button_content_get_icon_name(self_: *mut AdwButtonContent) -> *const c_char;
pub fn adw_button_content_get_label(self_: *mut AdwButtonContent) -> *const c_char;
pub fn adw_button_content_get_use_underline(self_: *mut AdwButtonContent) -> gboolean;
pub fn adw_button_content_set_icon_name(self_: *mut AdwButtonContent, icon_name: *const c_char);
pub fn adw_button_content_set_label(self_: *mut AdwButtonContent, label: *const c_char);
pub fn adw_button_content_set_use_underline(
self_: *mut AdwButtonContent,
use_underline: gboolean,
);
pub fn adw_callback_animation_target_get_type() -> GType;
pub fn adw_callback_animation_target_new(
callback: AdwAnimationTargetFunc,
user_data: gpointer,
destroy: glib::GDestroyNotify,
) -> *mut AdwAnimationTarget;
pub fn adw_carousel_get_type() -> GType;
pub fn adw_carousel_new() -> *mut gtk::GtkWidget;
pub fn adw_carousel_append(self_: *mut AdwCarousel, child: *mut gtk::GtkWidget);
pub fn adw_carousel_get_allow_long_swipes(self_: *mut AdwCarousel) -> gboolean;
pub fn adw_carousel_get_allow_mouse_drag(self_: *mut AdwCarousel) -> gboolean;
pub fn adw_carousel_get_allow_scroll_wheel(self_: *mut AdwCarousel) -> gboolean;
pub fn adw_carousel_get_interactive(self_: *mut AdwCarousel) -> gboolean;
pub fn adw_carousel_get_n_pages(self_: *mut AdwCarousel) -> c_uint;
pub fn adw_carousel_get_nth_page(self_: *mut AdwCarousel, n: c_uint) -> *mut gtk::GtkWidget;
pub fn adw_carousel_get_position(self_: *mut AdwCarousel) -> c_double;
pub fn adw_carousel_get_reveal_duration(self_: *mut AdwCarousel) -> c_uint;
pub fn adw_carousel_get_scroll_params(self_: *mut AdwCarousel) -> *mut AdwSpringParams;
pub fn adw_carousel_get_spacing(self_: *mut AdwCarousel) -> c_uint;
pub fn adw_carousel_insert(
self_: *mut AdwCarousel,
child: *mut gtk::GtkWidget,
position: c_int,
);
pub fn adw_carousel_prepend(self_: *mut AdwCarousel, child: *mut gtk::GtkWidget);
pub fn adw_carousel_remove(self_: *mut AdwCarousel, child: *mut gtk::GtkWidget);
pub fn adw_carousel_reorder(
self_: *mut AdwCarousel,
child: *mut gtk::GtkWidget,
position: c_int,
);
pub fn adw_carousel_scroll_to(
self_: *mut AdwCarousel,
widget: *mut gtk::GtkWidget,
animate: gboolean,
);
pub fn adw_carousel_set_allow_long_swipes(self_: *mut AdwCarousel, allow_long_swipes: gboolean);
pub fn adw_carousel_set_allow_mouse_drag(self_: *mut AdwCarousel, allow_mouse_drag: gboolean);
pub fn adw_carousel_set_allow_scroll_wheel(
self_: *mut AdwCarousel,
allow_scroll_wheel: gboolean,
);
pub fn adw_carousel_set_interactive(self_: *mut AdwCarousel, interactive: gboolean);
pub fn adw_carousel_set_reveal_duration(self_: *mut AdwCarousel, reveal_duration: c_uint);
pub fn adw_carousel_set_scroll_params(self_: *mut AdwCarousel, params: *mut AdwSpringParams);
pub fn adw_carousel_set_spacing(self_: *mut AdwCarousel, spacing: c_uint);
pub fn adw_carousel_indicator_dots_get_type() -> GType;
pub fn adw_carousel_indicator_dots_new() -> *mut gtk::GtkWidget;
pub fn adw_carousel_indicator_dots_get_carousel(
self_: *mut AdwCarouselIndicatorDots,
) -> *mut AdwCarousel;
pub fn adw_carousel_indicator_dots_set_carousel(
self_: *mut AdwCarouselIndicatorDots,
carousel: *mut AdwCarousel,
);
pub fn adw_carousel_indicator_lines_get_type() -> GType;
pub fn adw_carousel_indicator_lines_new() -> *mut gtk::GtkWidget;
pub fn adw_carousel_indicator_lines_get_carousel(
self_: *mut AdwCarouselIndicatorLines,
) -> *mut AdwCarousel;
pub fn adw_carousel_indicator_lines_set_carousel(
self_: *mut AdwCarouselIndicatorLines,
carousel: *mut AdwCarousel,
);
pub fn adw_clamp_get_type() -> GType;
pub fn adw_clamp_new() -> *mut gtk::GtkWidget;
pub fn adw_clamp_get_child(self_: *mut AdwClamp) -> *mut gtk::GtkWidget;
pub fn adw_clamp_get_maximum_size(self_: *mut AdwClamp) -> c_int;
pub fn adw_clamp_get_tightening_threshold(self_: *mut AdwClamp) -> c_int;
pub fn adw_clamp_set_child(self_: *mut AdwClamp, child: *mut gtk::GtkWidget);
pub fn adw_clamp_set_maximum_size(self_: *mut AdwClamp, maximum_size: c_int);
pub fn adw_clamp_set_tightening_threshold(self_: *mut AdwClamp, tightening_threshold: c_int);
pub fn adw_clamp_layout_get_type() -> GType;
pub fn adw_clamp_layout_new() -> *mut gtk::GtkLayoutManager;
pub fn adw_clamp_layout_get_maximum_size(self_: *mut AdwClampLayout) -> c_int;
pub fn adw_clamp_layout_get_tightening_threshold(self_: *mut AdwClampLayout) -> c_int;
pub fn adw_clamp_layout_set_maximum_size(self_: *mut AdwClampLayout, maximum_size: c_int);
pub fn adw_clamp_layout_set_tightening_threshold(
self_: *mut AdwClampLayout,
tightening_threshold: c_int,
);
pub fn adw_clamp_scrollable_get_type() -> GType;
pub fn adw_clamp_scrollable_new() -> *mut gtk::GtkWidget;
pub fn adw_clamp_scrollable_get_child(self_: *mut AdwClampScrollable) -> *mut gtk::GtkWidget;
pub fn adw_clamp_scrollable_get_maximum_size(self_: *mut AdwClampScrollable) -> c_int;
pub fn adw_clamp_scrollable_get_tightening_threshold(self_: *mut AdwClampScrollable) -> c_int;
pub fn adw_clamp_scrollable_set_child(
self_: *mut AdwClampScrollable,
child: *mut gtk::GtkWidget,
);
pub fn adw_clamp_scrollable_set_maximum_size(
self_: *mut AdwClampScrollable,
maximum_size: c_int,
);
pub fn adw_clamp_scrollable_set_tightening_threshold(
self_: *mut AdwClampScrollable,
tightening_threshold: c_int,
);
pub fn adw_combo_row_get_type() -> GType;
pub fn adw_combo_row_new() -> *mut gtk::GtkWidget;
pub fn adw_combo_row_get_expression(self_: *mut AdwComboRow) -> *mut gtk::GtkExpression;
pub fn adw_combo_row_get_factory(self_: *mut AdwComboRow) -> *mut gtk::GtkListItemFactory;
pub fn adw_combo_row_get_list_factory(self_: *mut AdwComboRow) -> *mut gtk::GtkListItemFactory;
pub fn adw_combo_row_get_model(self_: *mut AdwComboRow) -> *mut gio::GListModel;
pub fn adw_combo_row_get_selected(self_: *mut AdwComboRow) -> c_uint;
pub fn adw_combo_row_get_selected_item(self_: *mut AdwComboRow) -> *mut gobject::GObject;
pub fn adw_combo_row_get_use_subtitle(self_: *mut AdwComboRow) -> gboolean;
pub fn adw_combo_row_set_expression(
self_: *mut AdwComboRow,
expression: *mut gtk::GtkExpression,
);
pub fn adw_combo_row_set_factory(
self_: *mut AdwComboRow,
factory: *mut gtk::GtkListItemFactory,
);
pub fn adw_combo_row_set_list_factory(
self_: *mut AdwComboRow,
factory: *mut gtk::GtkListItemFactory,
);
pub fn adw_combo_row_set_model(self_: *mut AdwComboRow, model: *mut gio::GListModel);
pub fn adw_combo_row_set_selected(self_: *mut AdwComboRow, position: c_uint);
pub fn adw_combo_row_set_use_subtitle(self_: *mut AdwComboRow, use_subtitle: gboolean);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_get_type() -> GType;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_new() -> *mut gtk::GtkWidget;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_add_prefix(self_: *mut AdwEntryRow, widget: *mut gtk::GtkWidget);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_add_suffix(self_: *mut AdwEntryRow, widget: *mut gtk::GtkWidget);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_get_activates_default(self_: *mut AdwEntryRow) -> gboolean;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_get_attributes(self_: *mut AdwEntryRow) -> *mut pango::PangoAttrList;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_get_enable_emoji_completion(self_: *mut AdwEntryRow) -> gboolean;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_get_input_hints(self_: *mut AdwEntryRow) -> gtk::GtkInputHints;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_get_input_purpose(self_: *mut AdwEntryRow) -> gtk::GtkInputPurpose;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_get_show_apply_button(self_: *mut AdwEntryRow) -> gboolean;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_remove(self_: *mut AdwEntryRow, widget: *mut gtk::GtkWidget);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_set_activates_default(self_: *mut AdwEntryRow, activates: gboolean);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_set_attributes(
self_: *mut AdwEntryRow,
attributes: *mut pango::PangoAttrList,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_set_enable_emoji_completion(
self_: *mut AdwEntryRow,
enable_emoji_completion: gboolean,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_set_input_hints(self_: *mut AdwEntryRow, hints: gtk::GtkInputHints);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_set_input_purpose(self_: *mut AdwEntryRow, purpose: gtk::GtkInputPurpose);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_set_show_apply_button(
self_: *mut AdwEntryRow,
show_apply_button: gboolean,
);
pub fn adw_enum_list_item_get_type() -> GType;
pub fn adw_enum_list_item_get_name(self_: *mut AdwEnumListItem) -> *const c_char;
pub fn adw_enum_list_item_get_nick(self_: *mut AdwEnumListItem) -> *const c_char;
pub fn adw_enum_list_item_get_value(self_: *mut AdwEnumListItem) -> c_int;
pub fn adw_enum_list_model_get_type() -> GType;
pub fn adw_enum_list_model_new(enum_type: GType) -> *mut AdwEnumListModel;
pub fn adw_enum_list_model_find_position(self_: *mut AdwEnumListModel, value: c_int) -> c_uint;
pub fn adw_enum_list_model_get_enum_type(self_: *mut AdwEnumListModel) -> GType;
pub fn adw_expander_row_get_type() -> GType;
pub fn adw_expander_row_new() -> *mut gtk::GtkWidget;
pub fn adw_expander_row_add_action(self_: *mut AdwExpanderRow, widget: *mut gtk::GtkWidget);
pub fn adw_expander_row_add_prefix(self_: *mut AdwExpanderRow, widget: *mut gtk::GtkWidget);
pub fn adw_expander_row_add_row(self_: *mut AdwExpanderRow, child: *mut gtk::GtkWidget);
pub fn adw_expander_row_get_enable_expansion(self_: *mut AdwExpanderRow) -> gboolean;
pub fn adw_expander_row_get_expanded(self_: *mut AdwExpanderRow) -> gboolean;
pub fn adw_expander_row_get_icon_name(self_: *mut AdwExpanderRow) -> *const c_char;
pub fn adw_expander_row_get_show_enable_switch(self_: *mut AdwExpanderRow) -> gboolean;
pub fn adw_expander_row_get_subtitle(self_: *mut AdwExpanderRow) -> *const c_char;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_expander_row_get_subtitle_lines(self_: *mut AdwExpanderRow) -> gboolean;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_expander_row_get_title_lines(self_: *mut AdwExpanderRow) -> gboolean;
pub fn adw_expander_row_remove(self_: *mut AdwExpanderRow, child: *mut gtk::GtkWidget);
pub fn adw_expander_row_set_enable_expansion(
self_: *mut AdwExpanderRow,
enable_expansion: gboolean,
);
pub fn adw_expander_row_set_expanded(self_: *mut AdwExpanderRow, expanded: gboolean);
pub fn adw_expander_row_set_icon_name(self_: *mut AdwExpanderRow, icon_name: *const c_char);
pub fn adw_expander_row_set_show_enable_switch(
self_: *mut AdwExpanderRow,
show_enable_switch: gboolean,
);
pub fn adw_expander_row_set_subtitle(self_: *mut AdwExpanderRow, subtitle: *const c_char);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_expander_row_set_subtitle_lines(self_: *mut AdwExpanderRow, subtitle_lines: c_int);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_expander_row_set_title_lines(self_: *mut AdwExpanderRow, title_lines: c_int);
pub fn adw_flap_get_type() -> GType;
pub fn adw_flap_new() -> *mut gtk::GtkWidget;
pub fn adw_flap_get_content(self_: *mut AdwFlap) -> *mut gtk::GtkWidget;
pub fn adw_flap_get_flap(self_: *mut AdwFlap) -> *mut gtk::GtkWidget;
pub fn adw_flap_get_flap_position(self_: *mut AdwFlap) -> gtk::GtkPackType;
pub fn adw_flap_get_fold_duration(self_: *mut AdwFlap) -> c_uint;
pub fn adw_flap_get_fold_policy(self_: *mut AdwFlap) -> AdwFlapFoldPolicy;
pub fn adw_flap_get_fold_threshold_policy(self_: *mut AdwFlap) -> AdwFoldThresholdPolicy;
pub fn adw_flap_get_folded(self_: *mut AdwFlap) -> gboolean;
pub fn adw_flap_get_locked(self_: *mut AdwFlap) -> gboolean;
pub fn adw_flap_get_modal(self_: *mut AdwFlap) -> gboolean;
pub fn adw_flap_get_reveal_flap(self_: *mut AdwFlap) -> gboolean;
pub fn adw_flap_get_reveal_params(self_: *mut AdwFlap) -> *mut AdwSpringParams;
pub fn adw_flap_get_reveal_progress(self_: *mut AdwFlap) -> c_double;
pub fn adw_flap_get_separator(self_: *mut AdwFlap) -> *mut gtk::GtkWidget;
pub fn adw_flap_get_swipe_to_close(self_: *mut AdwFlap) -> gboolean;
pub fn adw_flap_get_swipe_to_open(self_: *mut AdwFlap) -> gboolean;
pub fn adw_flap_get_transition_type(self_: *mut AdwFlap) -> AdwFlapTransitionType;
pub fn adw_flap_set_content(self_: *mut AdwFlap, content: *mut gtk::GtkWidget);
pub fn adw_flap_set_flap(self_: *mut AdwFlap, flap: *mut gtk::GtkWidget);
pub fn adw_flap_set_flap_position(self_: *mut AdwFlap, position: gtk::GtkPackType);
pub fn adw_flap_set_fold_duration(self_: *mut AdwFlap, duration: c_uint);
pub fn adw_flap_set_fold_policy(self_: *mut AdwFlap, policy: AdwFlapFoldPolicy);
pub fn adw_flap_set_fold_threshold_policy(self_: *mut AdwFlap, policy: AdwFoldThresholdPolicy);
pub fn adw_flap_set_locked(self_: *mut AdwFlap, locked: gboolean);
pub fn adw_flap_set_modal(self_: *mut AdwFlap, modal: gboolean);
pub fn adw_flap_set_reveal_flap(self_: *mut AdwFlap, reveal_flap: gboolean);
pub fn adw_flap_set_reveal_params(self_: *mut AdwFlap, params: *mut AdwSpringParams);
pub fn adw_flap_set_separator(self_: *mut AdwFlap, separator: *mut gtk::GtkWidget);
pub fn adw_flap_set_swipe_to_close(self_: *mut AdwFlap, swipe_to_close: gboolean);
pub fn adw_flap_set_swipe_to_open(self_: *mut AdwFlap, swipe_to_open: gboolean);
pub fn adw_flap_set_transition_type(
self_: *mut AdwFlap,
transition_type: AdwFlapTransitionType,
);
pub fn adw_header_bar_get_type() -> GType;
pub fn adw_header_bar_new() -> *mut gtk::GtkWidget;
pub fn adw_header_bar_get_centering_policy(self_: *mut AdwHeaderBar) -> AdwCenteringPolicy;
pub fn adw_header_bar_get_decoration_layout(self_: *mut AdwHeaderBar) -> *const c_char;
pub fn adw_header_bar_get_show_end_title_buttons(self_: *mut AdwHeaderBar) -> gboolean;
pub fn adw_header_bar_get_show_start_title_buttons(self_: *mut AdwHeaderBar) -> gboolean;
pub fn adw_header_bar_get_title_widget(self_: *mut AdwHeaderBar) -> *mut gtk::GtkWidget;
pub fn adw_header_bar_pack_end(self_: *mut AdwHeaderBar, child: *mut gtk::GtkWidget);
pub fn adw_header_bar_pack_start(self_: *mut AdwHeaderBar, child: *mut gtk::GtkWidget);
pub fn adw_header_bar_remove(self_: *mut AdwHeaderBar, child: *mut gtk::GtkWidget);
pub fn adw_header_bar_set_centering_policy(
self_: *mut AdwHeaderBar,
centering_policy: AdwCenteringPolicy,
);
pub fn adw_header_bar_set_decoration_layout(self_: *mut AdwHeaderBar, layout: *const c_char);
pub fn adw_header_bar_set_show_end_title_buttons(self_: *mut AdwHeaderBar, setting: gboolean);
pub fn adw_header_bar_set_show_start_title_buttons(self_: *mut AdwHeaderBar, setting: gboolean);
pub fn adw_header_bar_set_title_widget(
self_: *mut AdwHeaderBar,
title_widget: *mut gtk::GtkWidget,
);
pub fn adw_leaflet_get_type() -> GType;
pub fn adw_leaflet_new() -> *mut gtk::GtkWidget;
pub fn adw_leaflet_append(
self_: *mut AdwLeaflet,
child: *mut gtk::GtkWidget,
) -> *mut AdwLeafletPage;
pub fn adw_leaflet_get_adjacent_child(
self_: *mut AdwLeaflet,
direction: AdwNavigationDirection,
) -> *mut gtk::GtkWidget;
pub fn adw_leaflet_get_can_navigate_back(self_: *mut AdwLeaflet) -> gboolean;
pub fn adw_leaflet_get_can_navigate_forward(self_: *mut AdwLeaflet) -> gboolean;
pub fn adw_leaflet_get_can_unfold(self_: *mut AdwLeaflet) -> gboolean;
pub fn adw_leaflet_get_child_by_name(
self_: *mut AdwLeaflet,
name: *const c_char,
) -> *mut gtk::GtkWidget;
pub fn adw_leaflet_get_child_transition_params(self_: *mut AdwLeaflet) -> *mut AdwSpringParams;
pub fn adw_leaflet_get_child_transition_running(self_: *mut AdwLeaflet) -> gboolean;
pub fn adw_leaflet_get_fold_threshold_policy(self_: *mut AdwLeaflet) -> AdwFoldThresholdPolicy;
pub fn adw_leaflet_get_folded(self_: *mut AdwLeaflet) -> gboolean;
pub fn adw_leaflet_get_homogeneous(self_: *mut AdwLeaflet) -> gboolean;
pub fn adw_leaflet_get_mode_transition_duration(self_: *mut AdwLeaflet) -> c_uint;
pub fn adw_leaflet_get_page(
self_: *mut AdwLeaflet,
child: *mut gtk::GtkWidget,
) -> *mut AdwLeafletPage;
pub fn adw_leaflet_get_pages(self_: *mut AdwLeaflet) -> *mut gtk::GtkSelectionModel;
pub fn adw_leaflet_get_transition_type(self_: *mut AdwLeaflet) -> AdwLeafletTransitionType;
pub fn adw_leaflet_get_visible_child(self_: *mut AdwLeaflet) -> *mut gtk::GtkWidget;
pub fn adw_leaflet_get_visible_child_name(self_: *mut AdwLeaflet) -> *const c_char;
pub fn adw_leaflet_insert_child_after(
self_: *mut AdwLeaflet,
child: *mut gtk::GtkWidget,
sibling: *mut gtk::GtkWidget,
) -> *mut AdwLeafletPage;
pub fn adw_leaflet_navigate(
self_: *mut AdwLeaflet,
direction: AdwNavigationDirection,
) -> gboolean;
pub fn adw_leaflet_prepend(
self_: *mut AdwLeaflet,
child: *mut gtk::GtkWidget,
) -> *mut AdwLeafletPage;
pub fn adw_leaflet_remove(self_: *mut AdwLeaflet, child: *mut gtk::GtkWidget);
pub fn adw_leaflet_reorder_child_after(
self_: *mut AdwLeaflet,
child: *mut gtk::GtkWidget,
sibling: *mut gtk::GtkWidget,
);
pub fn adw_leaflet_set_can_navigate_back(self_: *mut AdwLeaflet, can_navigate_back: gboolean);
pub fn adw_leaflet_set_can_navigate_forward(
self_: *mut AdwLeaflet,
can_navigate_forward: gboolean,
);
pub fn adw_leaflet_set_can_unfold(self_: *mut AdwLeaflet, can_unfold: gboolean);
pub fn adw_leaflet_set_child_transition_params(
self_: *mut AdwLeaflet,
params: *mut AdwSpringParams,
);
pub fn adw_leaflet_set_fold_threshold_policy(
self_: *mut AdwLeaflet,
policy: AdwFoldThresholdPolicy,
);
pub fn adw_leaflet_set_homogeneous(self_: *mut AdwLeaflet, homogeneous: gboolean);
pub fn adw_leaflet_set_mode_transition_duration(self_: *mut AdwLeaflet, duration: c_uint);
pub fn adw_leaflet_set_transition_type(
self_: *mut AdwLeaflet,
transition: AdwLeafletTransitionType,
);
pub fn adw_leaflet_set_visible_child(
self_: *mut AdwLeaflet,
visible_child: *mut gtk::GtkWidget,
);
pub fn adw_leaflet_set_visible_child_name(self_: *mut AdwLeaflet, name: *const c_char);
pub fn adw_leaflet_page_get_type() -> GType;
pub fn adw_leaflet_page_get_child(self_: *mut AdwLeafletPage) -> *mut gtk::GtkWidget;
pub fn adw_leaflet_page_get_name(self_: *mut AdwLeafletPage) -> *const c_char;
pub fn adw_leaflet_page_get_navigatable(self_: *mut AdwLeafletPage) -> gboolean;
pub fn adw_leaflet_page_set_name(self_: *mut AdwLeafletPage, name: *const c_char);
pub fn adw_leaflet_page_set_navigatable(self_: *mut AdwLeafletPage, navigatable: gboolean);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_type() -> GType;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_new(
parent: *mut gtk::GtkWindow,
heading: *const c_char,
body: *const c_char,
) -> *mut gtk::GtkWidget;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_add_response(
self_: *mut AdwMessageDialog,
id: *const c_char,
label: *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_add_responses(
self_: *mut AdwMessageDialog,
first_id: *const c_char,
...
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_format_body(self_: *mut AdwMessageDialog, format: *const c_char, ...);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_format_body_markup(
self_: *mut AdwMessageDialog,
format: *const c_char,
...
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_format_heading(
self_: *mut AdwMessageDialog,
format: *const c_char,
...
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_format_heading_markup(
self_: *mut AdwMessageDialog,
format: *const c_char,
...
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_body(self_: *mut AdwMessageDialog) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_body_use_markup(self_: *mut AdwMessageDialog) -> gboolean;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_close_response(self_: *mut AdwMessageDialog) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_default_response(self_: *mut AdwMessageDialog) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_extra_child(self_: *mut AdwMessageDialog) -> *mut gtk::GtkWidget;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_heading(self_: *mut AdwMessageDialog) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_heading_use_markup(self_: *mut AdwMessageDialog) -> gboolean;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_response_appearance(
self_: *mut AdwMessageDialog,
response: *const c_char,
) -> AdwResponseAppearance;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_response_enabled(
self_: *mut AdwMessageDialog,
response: *const c_char,
) -> gboolean;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_response_label(
self_: *mut AdwMessageDialog,
response: *const c_char,
) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_has_response(
self_: *mut AdwMessageDialog,
response: *const c_char,
) -> gboolean;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_response(self_: *mut AdwMessageDialog, response: *const c_char);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_body(self_: *mut AdwMessageDialog, body: *const c_char);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_body_use_markup(
self_: *mut AdwMessageDialog,
use_markup: gboolean,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_close_response(
self_: *mut AdwMessageDialog,
response: *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_default_response(
self_: *mut AdwMessageDialog,
response: *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_extra_child(
self_: *mut AdwMessageDialog,
child: *mut gtk::GtkWidget,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_heading(self_: *mut AdwMessageDialog, heading: *const c_char);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_heading_use_markup(
self_: *mut AdwMessageDialog,
use_markup: gboolean,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_response_appearance(
self_: *mut AdwMessageDialog,
response: *const c_char,
appearance: AdwResponseAppearance,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_response_enabled(
self_: *mut AdwMessageDialog,
response: *const c_char,
enabled: gboolean,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_response_label(
self_: *mut AdwMessageDialog,
response: *const c_char,
label: *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_password_entry_row_get_type() -> GType;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_password_entry_row_new() -> *mut gtk::GtkWidget;
pub fn adw_preferences_group_get_type() -> GType;
pub fn adw_preferences_group_new() -> *mut gtk::GtkWidget;
pub fn adw_preferences_group_add(self_: *mut AdwPreferencesGroup, child: *mut gtk::GtkWidget);
pub fn adw_preferences_group_get_description(self_: *mut AdwPreferencesGroup) -> *const c_char;
#[cfg(any(feature = "v1_1", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
pub fn adw_preferences_group_get_header_suffix(
self_: *mut AdwPreferencesGroup,
) -> *mut gtk::GtkWidget;
pub fn adw_preferences_group_get_title(self_: *mut AdwPreferencesGroup) -> *const c_char;
pub fn adw_preferences_group_remove(
self_: *mut AdwPreferencesGroup,
child: *mut gtk::GtkWidget,
);
pub fn adw_preferences_group_set_description(
self_: *mut AdwPreferencesGroup,
description: *const c_char,
);
#[cfg(any(feature = "v1_1", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
pub fn adw_preferences_group_set_header_suffix(
self_: *mut AdwPreferencesGroup,
suffix: *mut gtk::GtkWidget,
);
pub fn adw_preferences_group_set_title(self_: *mut AdwPreferencesGroup, title: *const c_char);
pub fn adw_preferences_page_get_type() -> GType;
pub fn adw_preferences_page_new() -> *mut gtk::GtkWidget;
pub fn adw_preferences_page_add(
self_: *mut AdwPreferencesPage,
group: *mut AdwPreferencesGroup,
);
pub fn adw_preferences_page_get_icon_name(self_: *mut AdwPreferencesPage) -> *const c_char;
pub fn adw_preferences_page_get_name(self_: *mut AdwPreferencesPage) -> *const c_char;
pub fn adw_preferences_page_get_title(self_: *mut AdwPreferencesPage) -> *const c_char;
pub fn adw_preferences_page_get_use_underline(self_: *mut AdwPreferencesPage) -> gboolean;
pub fn adw_preferences_page_remove(
self_: *mut AdwPreferencesPage,
group: *mut AdwPreferencesGroup,
);
pub fn adw_preferences_page_set_icon_name(
self_: *mut AdwPreferencesPage,
icon_name: *const c_char,
);
pub fn adw_preferences_page_set_name(self_: *mut AdwPreferencesPage, name: *const c_char);
pub fn adw_preferences_page_set_title(self_: *mut AdwPreferencesPage, title: *const c_char);
pub fn adw_preferences_page_set_use_underline(
self_: *mut AdwPreferencesPage,
use_underline: gboolean,
);
pub fn adw_preferences_row_get_type() -> GType;
pub fn adw_preferences_row_new() -> *mut gtk::GtkWidget;
pub fn adw_preferences_row_get_title(self_: *mut AdwPreferencesRow) -> *const c_char;
#[cfg(any(feature = "v1_1", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
pub fn adw_preferences_row_get_title_selectable(self_: *mut AdwPreferencesRow) -> gboolean;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_preferences_row_get_use_markup(self_: *mut AdwPreferencesRow) -> gboolean;
pub fn adw_preferences_row_get_use_underline(self_: *mut AdwPreferencesRow) -> gboolean;
pub fn adw_preferences_row_set_title(self_: *mut AdwPreferencesRow, title: *const c_char);
#[cfg(any(feature = "v1_1", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
pub fn adw_preferences_row_set_title_selectable(
self_: *mut AdwPreferencesRow,
title_selectable: gboolean,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_preferences_row_set_use_markup(self_: *mut AdwPreferencesRow, use_markup: gboolean);
pub fn adw_preferences_row_set_use_underline(
self_: *mut AdwPreferencesRow,
use_underline: gboolean,
);
pub fn adw_preferences_window_get_type() -> GType;
pub fn adw_preferences_window_new() -> *mut gtk::GtkWidget;
pub fn adw_preferences_window_add(
self_: *mut AdwPreferencesWindow,
page: *mut AdwPreferencesPage,
);
pub fn adw_preferences_window_add_toast(self_: *mut AdwPreferencesWindow, toast: *mut AdwToast);
pub fn adw_preferences_window_close_subpage(self_: *mut AdwPreferencesWindow);
pub fn adw_preferences_window_get_can_navigate_back(
self_: *mut AdwPreferencesWindow,
) -> gboolean;
pub fn adw_preferences_window_get_search_enabled(self_: *mut AdwPreferencesWindow) -> gboolean;
pub fn adw_preferences_window_get_visible_page(
self_: *mut AdwPreferencesWindow,
) -> *mut AdwPreferencesPage;
pub fn adw_preferences_window_get_visible_page_name(
self_: *mut AdwPreferencesWindow,
) -> *const c_char;
pub fn adw_preferences_window_present_subpage(
self_: *mut AdwPreferencesWindow,
subpage: *mut gtk::GtkWidget,
);
pub fn adw_preferences_window_remove(
self_: *mut AdwPreferencesWindow,
page: *mut AdwPreferencesPage,
);
pub fn adw_preferences_window_set_can_navigate_back(
self_: *mut AdwPreferencesWindow,
can_navigate_back: gboolean,
);
pub fn adw_preferences_window_set_search_enabled(
self_: *mut AdwPreferencesWindow,
search_enabled: gboolean,
);
pub fn adw_preferences_window_set_visible_page(
self_: *mut AdwPreferencesWindow,
page: *mut AdwPreferencesPage,
);
pub fn adw_preferences_window_set_visible_page_name(
self_: *mut AdwPreferencesWindow,
name: *const c_char,
);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_property_animation_target_get_type() -> GType;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_property_animation_target_new(
object: *mut gobject::GObject,
property_name: *const c_char,
) -> *mut AdwAnimationTarget;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_property_animation_target_new_for_pspec(
object: *mut gobject::GObject,
pspec: *mut gobject::GParamSpec,
) -> *mut AdwAnimationTarget;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_property_animation_target_get_object(
self_: *mut AdwPropertyAnimationTarget,
) -> *mut gobject::GObject;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_property_animation_target_get_pspec(
self_: *mut AdwPropertyAnimationTarget,
) -> *mut gobject::GParamSpec;
pub fn adw_split_button_get_type() -> GType;
pub fn adw_split_button_new() -> *mut gtk::GtkWidget;
pub fn adw_split_button_get_child(self_: *mut AdwSplitButton) -> *mut gtk::GtkWidget;
pub fn adw_split_button_get_direction(self_: *mut AdwSplitButton) -> gtk::GtkArrowType;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_split_button_get_dropdown_tooltip(self_: *mut AdwSplitButton) -> *const c_char;
pub fn adw_split_button_get_icon_name(self_: *mut AdwSplitButton) -> *const c_char;
pub fn adw_split_button_get_label(self_: *mut AdwSplitButton) -> *const c_char;
pub fn adw_split_button_get_menu_model(self_: *mut AdwSplitButton) -> *mut gio::GMenuModel;
pub fn adw_split_button_get_popover(self_: *mut AdwSplitButton) -> *mut gtk::GtkPopover;
pub fn adw_split_button_get_use_underline(self_: *mut AdwSplitButton) -> gboolean;
pub fn adw_split_button_popdown(self_: *mut AdwSplitButton);
pub fn adw_split_button_popup(self_: *mut AdwSplitButton);
pub fn adw_split_button_set_child(self_: *mut AdwSplitButton, child: *mut gtk::GtkWidget);
pub fn adw_split_button_set_direction(self_: *mut AdwSplitButton, direction: gtk::GtkArrowType);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_split_button_set_dropdown_tooltip(
self_: *mut AdwSplitButton,
tooltip: *const c_char,
);
pub fn adw_split_button_set_icon_name(self_: *mut AdwSplitButton, icon_name: *const c_char);
pub fn adw_split_button_set_label(self_: *mut AdwSplitButton, label: *const c_char);
pub fn adw_split_button_set_menu_model(
self_: *mut AdwSplitButton,
menu_model: *mut gio::GMenuModel,
);
pub fn adw_split_button_set_popover(self_: *mut AdwSplitButton, popover: *mut gtk::GtkPopover);
pub fn adw_split_button_set_use_underline(self_: *mut AdwSplitButton, use_underline: gboolean);
pub fn adw_spring_animation_get_type() -> GType;
pub fn adw_spring_animation_new(
widget: *mut gtk::GtkWidget,
from: c_double,
to: c_double,
spring_params: *mut AdwSpringParams,
target: *mut AdwAnimationTarget,
) -> *mut AdwAnimation;
pub fn adw_spring_animation_get_clamp(self_: *mut AdwSpringAnimation) -> gboolean;
pub fn adw_spring_animation_get_epsilon(self_: *mut AdwSpringAnimation) -> c_double;
pub fn adw_spring_animation_get_estimated_duration(self_: *mut AdwSpringAnimation) -> c_uint;
pub fn adw_spring_animation_get_initial_velocity(self_: *mut AdwSpringAnimation) -> c_double;
pub fn adw_spring_animation_get_spring_params(
self_: *mut AdwSpringAnimation,
) -> *mut AdwSpringParams;
pub fn adw_spring_animation_get_value_from(self_: *mut AdwSpringAnimation) -> c_double;
pub fn adw_spring_animation_get_value_to(self_: *mut AdwSpringAnimation) -> c_double;
pub fn adw_spring_animation_get_velocity(self_: *mut AdwSpringAnimation) -> c_double;
pub fn adw_spring_animation_set_clamp(self_: *mut AdwSpringAnimation, clamp: gboolean);
pub fn adw_spring_animation_set_epsilon(self_: *mut AdwSpringAnimation, epsilon: c_double);
pub fn adw_spring_animation_set_initial_velocity(
self_: *mut AdwSpringAnimation,
velocity: c_double,
);
pub fn adw_spring_animation_set_spring_params(
self_: *mut AdwSpringAnimation,
spring_params: *mut AdwSpringParams,
);
pub fn adw_spring_animation_set_value_from(self_: *mut AdwSpringAnimation, value: c_double);
pub fn adw_spring_animation_set_value_to(self_: *mut AdwSpringAnimation, value: c_double);
pub fn adw_squeezer_get_type() -> GType;
pub fn adw_squeezer_new() -> *mut gtk::GtkWidget;
pub fn adw_squeezer_add(
self_: *mut AdwSqueezer,
child: *mut gtk::GtkWidget,
) -> *mut AdwSqueezerPage;
pub fn adw_squeezer_get_allow_none(self_: *mut AdwSqueezer) -> gboolean;
pub fn adw_squeezer_get_homogeneous(self_: *mut AdwSqueezer) -> gboolean;
pub fn adw_squeezer_get_interpolate_size(self_: *mut AdwSqueezer) -> gboolean;
pub fn adw_squeezer_get_page(
self_: *mut AdwSqueezer,
child: *mut gtk::GtkWidget,
) -> *mut AdwSqueezerPage;
pub fn adw_squeezer_get_pages(self_: *mut AdwSqueezer) -> *mut gtk::GtkSelectionModel;
pub fn adw_squeezer_get_switch_threshold_policy(
self_: *mut AdwSqueezer,
) -> AdwFoldThresholdPolicy;
pub fn adw_squeezer_get_transition_duration(self_: *mut AdwSqueezer) -> c_uint;
pub fn adw_squeezer_get_transition_running(self_: *mut AdwSqueezer) -> gboolean;
pub fn adw_squeezer_get_transition_type(self_: *mut AdwSqueezer) -> AdwSqueezerTransitionType;
pub fn adw_squeezer_get_visible_child(self_: *mut AdwSqueezer) -> *mut gtk::GtkWidget;
pub fn adw_squeezer_get_xalign(self_: *mut AdwSqueezer) -> c_float;
pub fn adw_squeezer_get_yalign(self_: *mut AdwSqueezer) -> c_float;
pub fn adw_squeezer_remove(self_: *mut AdwSqueezer, child: *mut gtk::GtkWidget);
pub fn adw_squeezer_set_allow_none(self_: *mut AdwSqueezer, allow_none: gboolean);
pub fn adw_squeezer_set_homogeneous(self_: *mut AdwSqueezer, homogeneous: gboolean);
pub fn adw_squeezer_set_interpolate_size(self_: *mut AdwSqueezer, interpolate_size: gboolean);
pub fn adw_squeezer_set_switch_threshold_policy(
self_: *mut AdwSqueezer,
policy: AdwFoldThresholdPolicy,
);
pub fn adw_squeezer_set_transition_duration(self_: *mut AdwSqueezer, duration: c_uint);
pub fn adw_squeezer_set_transition_type(
self_: *mut AdwSqueezer,
transition: AdwSqueezerTransitionType,
);
pub fn adw_squeezer_set_xalign(self_: *mut AdwSqueezer, xalign: c_float);
pub fn adw_squeezer_set_yalign(self_: *mut AdwSqueezer, yalign: c_float);
pub fn adw_squeezer_page_get_type() -> GType;
pub fn adw_squeezer_page_get_child(self_: *mut AdwSqueezerPage) -> *mut gtk::GtkWidget;
pub fn adw_squeezer_page_get_enabled(self_: *mut AdwSqueezerPage) -> gboolean;
pub fn adw_squeezer_page_set_enabled(self_: *mut AdwSqueezerPage, enabled: gboolean);
pub fn adw_status_page_get_type() -> GType;
pub fn adw_status_page_new() -> *mut gtk::GtkWidget;
pub fn adw_status_page_get_child(self_: *mut AdwStatusPage) -> *mut gtk::GtkWidget;
pub fn adw_status_page_get_description(self_: *mut AdwStatusPage) -> *const c_char;
pub fn adw_status_page_get_icon_name(self_: *mut AdwStatusPage) -> *const c_char;
pub fn adw_status_page_get_paintable(self_: *mut AdwStatusPage) -> *mut gdk::GdkPaintable;
pub fn adw_status_page_get_title(self_: *mut AdwStatusPage) -> *const c_char;
pub fn adw_status_page_set_child(self_: *mut AdwStatusPage, child: *mut gtk::GtkWidget);
pub fn adw_status_page_set_description(self_: *mut AdwStatusPage, description: *const c_char);
pub fn adw_status_page_set_icon_name(self_: *mut AdwStatusPage, icon_name: *const c_char);
pub fn adw_status_page_set_paintable(
self_: *mut AdwStatusPage,
paintable: *mut gdk::GdkPaintable,
);
pub fn adw_status_page_set_title(self_: *mut AdwStatusPage, title: *const c_char);
pub fn adw_style_manager_get_type() -> GType;
pub fn adw_style_manager_get_default() -> *mut AdwStyleManager;
pub fn adw_style_manager_get_for_display(display: *mut gdk::GdkDisplay)
-> *mut AdwStyleManager;
pub fn adw_style_manager_get_color_scheme(self_: *mut AdwStyleManager) -> AdwColorScheme;
pub fn adw_style_manager_get_dark(self_: *mut AdwStyleManager) -> gboolean;
pub fn adw_style_manager_get_display(self_: *mut AdwStyleManager) -> *mut gdk::GdkDisplay;
pub fn adw_style_manager_get_high_contrast(self_: *mut AdwStyleManager) -> gboolean;
pub fn adw_style_manager_get_system_supports_color_schemes(
self_: *mut AdwStyleManager,
) -> gboolean;
pub fn adw_style_manager_set_color_scheme(
self_: *mut AdwStyleManager,
color_scheme: AdwColorScheme,
);
pub fn adw_swipe_tracker_get_type() -> GType;
pub fn adw_swipe_tracker_new(swipeable: *mut AdwSwipeable) -> *mut AdwSwipeTracker;
pub fn adw_swipe_tracker_get_allow_long_swipes(self_: *mut AdwSwipeTracker) -> gboolean;
pub fn adw_swipe_tracker_get_allow_mouse_drag(self_: *mut AdwSwipeTracker) -> gboolean;
pub fn adw_swipe_tracker_get_enabled(self_: *mut AdwSwipeTracker) -> gboolean;
pub fn adw_swipe_tracker_get_reversed(self_: *mut AdwSwipeTracker) -> gboolean;
pub fn adw_swipe_tracker_get_swipeable(self_: *mut AdwSwipeTracker) -> *mut AdwSwipeable;
pub fn adw_swipe_tracker_set_allow_long_swipes(
self_: *mut AdwSwipeTracker,
allow_long_swipes: gboolean,
);
pub fn adw_swipe_tracker_set_allow_mouse_drag(
self_: *mut AdwSwipeTracker,
allow_mouse_drag: gboolean,
);
pub fn adw_swipe_tracker_set_enabled(self_: *mut AdwSwipeTracker, enabled: gboolean);
pub fn adw_swipe_tracker_set_reversed(self_: *mut AdwSwipeTracker, reversed: gboolean);
pub fn adw_swipe_tracker_shift_position(self_: *mut AdwSwipeTracker, delta: c_double);
pub fn adw_tab_bar_get_type() -> GType;
pub fn adw_tab_bar_new() -> *mut AdwTabBar;
pub fn adw_tab_bar_get_autohide(self_: *mut AdwTabBar) -> gboolean;
pub fn adw_tab_bar_get_end_action_widget(self_: *mut AdwTabBar) -> *mut gtk::GtkWidget;
pub fn adw_tab_bar_get_expand_tabs(self_: *mut AdwTabBar) -> gboolean;
pub fn adw_tab_bar_get_inverted(self_: *mut AdwTabBar) -> gboolean;
pub fn adw_tab_bar_get_is_overflowing(self_: *mut AdwTabBar) -> gboolean;
pub fn adw_tab_bar_get_start_action_widget(self_: *mut AdwTabBar) -> *mut gtk::GtkWidget;
pub fn adw_tab_bar_get_tabs_revealed(self_: *mut AdwTabBar) -> gboolean;
pub fn adw_tab_bar_get_view(self_: *mut AdwTabBar) -> *mut AdwTabView;
pub fn adw_tab_bar_set_autohide(self_: *mut AdwTabBar, autohide: gboolean);
pub fn adw_tab_bar_set_end_action_widget(self_: *mut AdwTabBar, widget: *mut gtk::GtkWidget);
pub fn adw_tab_bar_set_expand_tabs(self_: *mut AdwTabBar, expand_tabs: gboolean);
pub fn adw_tab_bar_set_inverted(self_: *mut AdwTabBar, inverted: gboolean);
pub fn adw_tab_bar_set_start_action_widget(self_: *mut AdwTabBar, widget: *mut gtk::GtkWidget);
pub fn adw_tab_bar_set_view(self_: *mut AdwTabBar, view: *mut AdwTabView);
pub fn adw_tab_bar_setup_extra_drop_target(
self_: *mut AdwTabBar,
actions: gdk::GdkDragAction,
types: *mut GType,
n_types: size_t,
);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_button_get_type() -> GType;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_button_new() -> *mut gtk::GtkWidget;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_button_get_view(self_: *mut AdwTabButton) -> *mut AdwTabView;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_button_set_view(self_: *mut AdwTabButton, view: *mut AdwTabView);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_type() -> GType;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_new() -> *mut gtk::GtkWidget;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_child(self_: *mut AdwTabOverview) -> *mut gtk::GtkWidget;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_enable_new_tab(self_: *mut AdwTabOverview) -> gboolean;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_enable_search(self_: *mut AdwTabOverview) -> gboolean;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_inverted(self_: *mut AdwTabOverview) -> gboolean;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_open(self_: *mut AdwTabOverview) -> gboolean;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_search_active(self_: *mut AdwTabOverview) -> gboolean;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_secondary_menu(self_: *mut AdwTabOverview) -> *mut gio::GMenuModel;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_show_end_title_buttons(self_: *mut AdwTabOverview) -> gboolean;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_show_start_title_buttons(self_: *mut AdwTabOverview) -> gboolean;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_view(self_: *mut AdwTabOverview) -> *mut AdwTabView;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_child(self_: *mut AdwTabOverview, child: *mut gtk::GtkWidget);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_enable_new_tab(
self_: *mut AdwTabOverview,
enable_new_tab: gboolean,
);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_enable_search(self_: *mut AdwTabOverview, enable_search: gboolean);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_inverted(self_: *mut AdwTabOverview, inverted: gboolean);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_open(self_: *mut AdwTabOverview, open: gboolean);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_secondary_menu(
self_: *mut AdwTabOverview,
secondary_menu: *mut gio::GMenuModel,
);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_show_end_title_buttons(
self_: *mut AdwTabOverview,
show_end_title_buttons: gboolean,
);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_show_start_title_buttons(
self_: *mut AdwTabOverview,
show_start_title_buttons: gboolean,
);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_view(self_: *mut AdwTabOverview, view: *mut AdwTabView);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_setup_extra_drop_target(
self_: *mut AdwTabOverview,
actions: gdk::GdkDragAction,
types: *mut GType,
n_types: size_t,
);
pub fn adw_tab_page_get_type() -> GType;
pub fn adw_tab_page_get_child(self_: *mut AdwTabPage) -> *mut gtk::GtkWidget;
pub fn adw_tab_page_get_icon(self_: *mut AdwTabPage) -> *mut gio::GIcon;
pub fn adw_tab_page_get_indicator_activatable(self_: *mut AdwTabPage) -> gboolean;
pub fn adw_tab_page_get_indicator_icon(self_: *mut AdwTabPage) -> *mut gio::GIcon;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_tab_page_get_indicator_tooltip(self_: *mut AdwTabPage) -> *const c_char;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_page_get_keyword(self_: *mut AdwTabPage) -> *const c_char;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_page_get_live_thumbnail(self_: *mut AdwTabPage) -> gboolean;
pub fn adw_tab_page_get_loading(self_: *mut AdwTabPage) -> gboolean;
pub fn adw_tab_page_get_needs_attention(self_: *mut AdwTabPage) -> gboolean;
pub fn adw_tab_page_get_parent(self_: *mut AdwTabPage) -> *mut AdwTabPage;
pub fn adw_tab_page_get_pinned(self_: *mut AdwTabPage) -> gboolean;
pub fn adw_tab_page_get_selected(self_: *mut AdwTabPage) -> gboolean;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_page_get_thumbnail_xalign(self_: *mut AdwTabPage) -> c_float;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_page_get_thumbnail_yalign(self_: *mut AdwTabPage) -> c_float;
pub fn adw_tab_page_get_title(self_: *mut AdwTabPage) -> *const c_char;
pub fn adw_tab_page_get_tooltip(self_: *mut AdwTabPage) -> *const c_char;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_page_invalidate_thumbnail(self_: *mut AdwTabPage);
pub fn adw_tab_page_set_icon(self_: *mut AdwTabPage, icon: *mut gio::GIcon);
pub fn adw_tab_page_set_indicator_activatable(self_: *mut AdwTabPage, activatable: gboolean);
pub fn adw_tab_page_set_indicator_icon(self_: *mut AdwTabPage, indicator_icon: *mut gio::GIcon);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_tab_page_set_indicator_tooltip(self_: *mut AdwTabPage, tooltip: *const c_char);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_page_set_keyword(self_: *mut AdwTabPage, keyword: *const c_char);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_page_set_live_thumbnail(self_: *mut AdwTabPage, live_thumbnail: gboolean);
pub fn adw_tab_page_set_loading(self_: *mut AdwTabPage, loading: gboolean);
pub fn adw_tab_page_set_needs_attention(self_: *mut AdwTabPage, needs_attention: gboolean);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_page_set_thumbnail_xalign(self_: *mut AdwTabPage, xalign: c_float);
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_page_set_thumbnail_yalign(self_: *mut AdwTabPage, yalign: c_float);
pub fn adw_tab_page_set_title(self_: *mut AdwTabPage, title: *const c_char);
pub fn adw_tab_page_set_tooltip(self_: *mut AdwTabPage, tooltip: *const c_char);
pub fn adw_tab_view_get_type() -> GType;
pub fn adw_tab_view_new() -> *mut AdwTabView;
pub fn adw_tab_view_add_page(
self_: *mut AdwTabView,
child: *mut gtk::GtkWidget,
parent: *mut AdwTabPage,
) -> *mut AdwTabPage;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_tab_view_add_shortcuts(self_: *mut AdwTabView, shortcuts: AdwTabViewShortcuts);
pub fn adw_tab_view_append(
self_: *mut AdwTabView,
child: *mut gtk::GtkWidget,
) -> *mut AdwTabPage;
pub fn adw_tab_view_append_pinned(
self_: *mut AdwTabView,
child: *mut gtk::GtkWidget,
) -> *mut AdwTabPage;
pub fn adw_tab_view_close_other_pages(self_: *mut AdwTabView, page: *mut AdwTabPage);
pub fn adw_tab_view_close_page(self_: *mut AdwTabView, page: *mut AdwTabPage);
pub fn adw_tab_view_close_page_finish(
self_: *mut AdwTabView,
page: *mut AdwTabPage,
confirm: gboolean,
);
pub fn adw_tab_view_close_pages_after(self_: *mut AdwTabView, page: *mut AdwTabPage);
pub fn adw_tab_view_close_pages_before(self_: *mut AdwTabView, page: *mut AdwTabPage);
pub fn adw_tab_view_get_default_icon(self_: *mut AdwTabView) -> *mut gio::GIcon;
pub fn adw_tab_view_get_is_transferring_page(self_: *mut AdwTabView) -> gboolean;
pub fn adw_tab_view_get_menu_model(self_: *mut AdwTabView) -> *mut gio::GMenuModel;
pub fn adw_tab_view_get_n_pages(self_: *mut AdwTabView) -> c_int;
pub fn adw_tab_view_get_n_pinned_pages(self_: *mut AdwTabView) -> c_int;
pub fn adw_tab_view_get_nth_page(self_: *mut AdwTabView, position: c_int) -> *mut AdwTabPage;
pub fn adw_tab_view_get_page(
self_: *mut AdwTabView,
child: *mut gtk::GtkWidget,
) -> *mut AdwTabPage;
pub fn adw_tab_view_get_page_position(self_: *mut AdwTabView, page: *mut AdwTabPage) -> c_int;
pub fn adw_tab_view_get_pages(self_: *mut AdwTabView) -> *mut gtk::GtkSelectionModel;
pub fn adw_tab_view_get_selected_page(self_: *mut AdwTabView) -> *mut AdwTabPage;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_tab_view_get_shortcuts(self_: *mut AdwTabView) -> AdwTabViewShortcuts;
pub fn adw_tab_view_insert(
self_: *mut AdwTabView,
child: *mut gtk::GtkWidget,
position: c_int,
) -> *mut AdwTabPage;
pub fn adw_tab_view_insert_pinned(
self_: *mut AdwTabView,
child: *mut gtk::GtkWidget,
position: c_int,
) -> *mut AdwTabPage;
#[cfg(any(feature = "v1_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3")))]
pub fn adw_tab_view_invalidate_thumbnails(self_: *mut AdwTabView);
pub fn adw_tab_view_prepend(
self_: *mut AdwTabView,
child: *mut gtk::GtkWidget,
) -> *mut AdwTabPage;
pub fn adw_tab_view_prepend_pinned(
self_: *mut AdwTabView,
child: *mut gtk::GtkWidget,
) -> *mut AdwTabPage;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_tab_view_remove_shortcuts(self_: *mut AdwTabView, shortcuts: AdwTabViewShortcuts);
pub fn adw_tab_view_reorder_backward(self_: *mut AdwTabView, page: *mut AdwTabPage)
-> gboolean;
pub fn adw_tab_view_reorder_first(self_: *mut AdwTabView, page: *mut AdwTabPage) -> gboolean;
pub fn adw_tab_view_reorder_forward(self_: *mut AdwTabView, page: *mut AdwTabPage) -> gboolean;
pub fn adw_tab_view_reorder_last(self_: *mut AdwTabView, page: *mut AdwTabPage) -> gboolean;
pub fn adw_tab_view_reorder_page(
self_: *mut AdwTabView,
page: *mut AdwTabPage,
position: c_int,
) -> gboolean;
pub fn adw_tab_view_select_next_page(self_: *mut AdwTabView) -> gboolean;
pub fn adw_tab_view_select_previous_page(self_: *mut AdwTabView) -> gboolean;
pub fn adw_tab_view_set_default_icon(self_: *mut AdwTabView, default_icon: *mut gio::GIcon);
pub fn adw_tab_view_set_menu_model(self_: *mut AdwTabView, menu_model: *mut gio::GMenuModel);
pub fn adw_tab_view_set_page_pinned(
self_: *mut AdwTabView,
page: *mut AdwTabPage,
pinned: gboolean,
);
pub fn adw_tab_view_set_selected_page(self_: *mut AdwTabView, selected_page: *mut AdwTabPage);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_tab_view_set_shortcuts(self_: *mut AdwTabView, shortcuts: AdwTabViewShortcuts);
pub fn adw_tab_view_transfer_page(
self_: *mut AdwTabView,
page: *mut AdwTabPage,
other_view: *mut AdwTabView,
position: c_int,
);
pub fn adw_timed_animation_get_type() -> GType;
pub fn adw_timed_animation_new(
widget: *mut gtk::GtkWidget,
from: c_double,
to: c_double,
duration: c_uint,
target: *mut AdwAnimationTarget,
) -> *mut AdwAnimation;
pub fn adw_timed_animation_get_alternate(self_: *mut AdwTimedAnimation) -> gboolean;
pub fn adw_timed_animation_get_duration(self_: *mut AdwTimedAnimation) -> c_uint;
pub fn adw_timed_animation_get_easing(self_: *mut AdwTimedAnimation) -> AdwEasing;
pub fn adw_timed_animation_get_repeat_count(self_: *mut AdwTimedAnimation) -> c_uint;
pub fn adw_timed_animation_get_reverse(self_: *mut AdwTimedAnimation) -> gboolean;
pub fn adw_timed_animation_get_value_from(self_: *mut AdwTimedAnimation) -> c_double;
pub fn adw_timed_animation_get_value_to(self_: *mut AdwTimedAnimation) -> c_double;
pub fn adw_timed_animation_set_alternate(self_: *mut AdwTimedAnimation, alternate: gboolean);
pub fn adw_timed_animation_set_duration(self_: *mut AdwTimedAnimation, duration: c_uint);
pub fn adw_timed_animation_set_easing(self_: *mut AdwTimedAnimation, easing: AdwEasing);
pub fn adw_timed_animation_set_repeat_count(
self_: *mut AdwTimedAnimation,
repeat_count: c_uint,
);
pub fn adw_timed_animation_set_reverse(self_: *mut AdwTimedAnimation, reverse: gboolean);
pub fn adw_timed_animation_set_value_from(self_: *mut AdwTimedAnimation, value: c_double);
pub fn adw_timed_animation_set_value_to(self_: *mut AdwTimedAnimation, value: c_double);
pub fn adw_toast_get_type() -> GType;
pub fn adw_toast_new(title: *const c_char) -> *mut AdwToast;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_toast_new_format(format: *const c_char, ...) -> *mut AdwToast;
pub fn adw_toast_dismiss(self_: *mut AdwToast);
pub fn adw_toast_get_action_name(self_: *mut AdwToast) -> *const c_char;
pub fn adw_toast_get_action_target_value(self_: *mut AdwToast) -> *mut glib::GVariant;
pub fn adw_toast_get_button_label(self_: *mut AdwToast) -> *const c_char;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_toast_get_custom_title(self_: *mut AdwToast) -> *mut gtk::GtkWidget;
pub fn adw_toast_get_priority(self_: *mut AdwToast) -> AdwToastPriority;
pub fn adw_toast_get_timeout(self_: *mut AdwToast) -> c_uint;
pub fn adw_toast_get_title(self_: *mut AdwToast) -> *const c_char;
pub fn adw_toast_set_action_name(self_: *mut AdwToast, action_name: *const c_char);
pub fn adw_toast_set_action_target(self_: *mut AdwToast, format_string: *const c_char, ...);
pub fn adw_toast_set_action_target_value(
self_: *mut AdwToast,
action_target: *mut glib::GVariant,
);
pub fn adw_toast_set_button_label(self_: *mut AdwToast, button_label: *const c_char);
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_toast_set_custom_title(self_: *mut AdwToast, widget: *mut gtk::GtkWidget);
pub fn adw_toast_set_detailed_action_name(
self_: *mut AdwToast,
detailed_action_name: *const c_char,
);
pub fn adw_toast_set_priority(self_: *mut AdwToast, priority: AdwToastPriority);
pub fn adw_toast_set_timeout(self_: *mut AdwToast, timeout: c_uint);
pub fn adw_toast_set_title(self_: *mut AdwToast, title: *const c_char);
pub fn adw_toast_overlay_get_type() -> GType;
pub fn adw_toast_overlay_new() -> *mut gtk::GtkWidget;
pub fn adw_toast_overlay_add_toast(self_: *mut AdwToastOverlay, toast: *mut AdwToast);
pub fn adw_toast_overlay_get_child(self_: *mut AdwToastOverlay) -> *mut gtk::GtkWidget;
pub fn adw_toast_overlay_set_child(self_: *mut AdwToastOverlay, child: *mut gtk::GtkWidget);
pub fn adw_view_stack_get_type() -> GType;
pub fn adw_view_stack_new() -> *mut gtk::GtkWidget;
pub fn adw_view_stack_add(
self_: *mut AdwViewStack,
child: *mut gtk::GtkWidget,
) -> *mut AdwViewStackPage;
pub fn adw_view_stack_add_named(
self_: *mut AdwViewStack,
child: *mut gtk::GtkWidget,
name: *const c_char,
) -> *mut AdwViewStackPage;
pub fn adw_view_stack_add_titled(
self_: *mut AdwViewStack,
child: *mut gtk::GtkWidget,
name: *const c_char,
title: *const c_char,
) -> *mut AdwViewStackPage;
#[cfg(any(feature = "v1_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_2")))]
pub fn adw_view_stack_add_titled_with_icon(
self_: *mut AdwViewStack,
child: *mut gtk::GtkWidget,
name: *const c_char,
title: *const c_char,
icon_name: *const c_char,
) -> *mut AdwViewStackPage;
pub fn adw_view_stack_get_child_by_name(
self_: *mut AdwViewStack,
name: *const c_char,
) -> *mut gtk::GtkWidget;
pub fn adw_view_stack_get_hhomogeneous(self_: *mut AdwViewStack) -> gboolean;
pub fn adw_view_stack_get_page(
self_: *mut AdwViewStack,
child: *mut gtk::GtkWidget,
) -> *mut AdwViewStackPage;
pub fn adw_view_stack_get_pages(self_: *mut AdwViewStack) -> *mut gtk::GtkSelectionModel;
pub fn adw_view_stack_get_vhomogeneous(self_: *mut AdwViewStack) -> gboolean;
pub fn adw_view_stack_get_visible_child(self_: *mut AdwViewStack) -> *mut gtk::GtkWidget;
pub fn adw_view_stack_get_visible_child_name(self_: *mut AdwViewStack) -> *const c_char;
pub fn adw_view_stack_remove(self_: *mut AdwViewStack, child: *mut gtk::GtkWidget);
pub fn adw_view_stack_set_hhomogeneous(self_: *mut AdwViewStack, hhomogeneous: gboolean);
pub fn adw_view_stack_set_vhomogeneous(self_: *mut AdwViewStack, vhomogeneous: gboolean);
pub fn adw_view_stack_set_visible_child(self_: *mut AdwViewStack, child: *mut gtk::GtkWidget);
pub fn adw_view_stack_set_visible_child_name(self_: *mut AdwViewStack, name: *const c_char);
pub fn adw_view_stack_page_get_type() -> GType;
pub fn adw_view_stack_page_get_badge_number(self_: *mut AdwViewStackPage) -> c_uint;
pub fn adw_view_stack_page_get_child(self_: *mut AdwViewStackPage) -> *mut gtk::GtkWidget;
pub fn adw_view_stack_page_get_icon_name(self_: *mut AdwViewStackPage) -> *const c_char;
pub fn adw_view_stack_page_get_name(self_: *mut AdwViewStackPage) -> *const c_char;
pub fn adw_view_stack_page_get_needs_attention(self_: *mut AdwViewStackPage) -> gboolean;
pub fn adw_view_stack_page_get_title(self_: *mut AdwViewStackPage) -> *const c_char;
pub fn adw_view_stack_page_get_use_underline(self_: *mut AdwViewStackPage) -> gboolean;
pub fn adw_view_stack_page_get_visible(self_: *mut AdwViewStackPage) -> gboolean;
pub fn adw_view_stack_page_set_badge_number(self_: *mut AdwViewStackPage, badge_number: c_uint);
pub fn adw_view_stack_page_set_icon_name(
self_: *mut AdwViewStackPage,
icon_name: *const c_char,
);
pub fn adw_view_stack_page_set_name(self_: *mut AdwViewStackPage, name: *const c_char);
pub fn adw_view_stack_page_set_needs_attention(
self_: *mut AdwViewStackPage,
needs_attention: gboolean,
);
pub fn adw_view_stack_page_set_title(self_: *mut AdwViewStackPage, title: *const c_char);
pub fn adw_view_stack_page_set_use_underline(
self_: *mut AdwViewStackPage,
use_underline: gboolean,
);
pub fn adw_view_stack_page_set_visible(self_: *mut AdwViewStackPage, visible: gboolean);
pub fn adw_view_switcher_get_type() -> GType;
pub fn adw_view_switcher_new() -> *mut gtk::GtkWidget;
pub fn adw_view_switcher_get_policy(self_: *mut AdwViewSwitcher) -> AdwViewSwitcherPolicy;
pub fn adw_view_switcher_get_stack(self_: *mut AdwViewSwitcher) -> *mut AdwViewStack;
pub fn adw_view_switcher_set_policy(self_: *mut AdwViewSwitcher, policy: AdwViewSwitcherPolicy);
pub fn adw_view_switcher_set_stack(self_: *mut AdwViewSwitcher, stack: *mut AdwViewStack);
pub fn adw_view_switcher_bar_get_type() -> GType;
pub fn adw_view_switcher_bar_new() -> *mut gtk::GtkWidget;
pub fn adw_view_switcher_bar_get_reveal(self_: *mut AdwViewSwitcherBar) -> gboolean;
pub fn adw_view_switcher_bar_get_stack(self_: *mut AdwViewSwitcherBar) -> *mut AdwViewStack;
pub fn adw_view_switcher_bar_set_reveal(self_: *mut AdwViewSwitcherBar, reveal: gboolean);
pub fn adw_view_switcher_bar_set_stack(
self_: *mut AdwViewSwitcherBar,
stack: *mut AdwViewStack,
);
pub fn adw_view_switcher_title_get_type() -> GType;
pub fn adw_view_switcher_title_new() -> *mut gtk::GtkWidget;
pub fn adw_view_switcher_title_get_stack(self_: *mut AdwViewSwitcherTitle)
-> *mut AdwViewStack;
pub fn adw_view_switcher_title_get_subtitle(self_: *mut AdwViewSwitcherTitle) -> *const c_char;
pub fn adw_view_switcher_title_get_title(self_: *mut AdwViewSwitcherTitle) -> *const c_char;
pub fn adw_view_switcher_title_get_title_visible(self_: *mut AdwViewSwitcherTitle) -> gboolean;
pub fn adw_view_switcher_title_get_view_switcher_enabled(
self_: *mut AdwViewSwitcherTitle,
) -> gboolean;
pub fn adw_view_switcher_title_set_stack(
self_: *mut AdwViewSwitcherTitle,
stack: *mut AdwViewStack,
);
pub fn adw_view_switcher_title_set_subtitle(
self_: *mut AdwViewSwitcherTitle,
subtitle: *const c_char,
);
pub fn adw_view_switcher_title_set_title(
self_: *mut AdwViewSwitcherTitle,
title: *const c_char,
);
pub fn adw_view_switcher_title_set_view_switcher_enabled(
self_: *mut AdwViewSwitcherTitle,
enabled: gboolean,
);
pub fn adw_window_get_type() -> GType;
pub fn adw_window_new() -> *mut gtk::GtkWidget;
pub fn adw_window_get_content(self_: *mut AdwWindow) -> *mut gtk::GtkWidget;
pub fn adw_window_set_content(self_: *mut AdwWindow, content: *mut gtk::GtkWidget);
pub fn adw_window_title_get_type() -> GType;
pub fn adw_window_title_new(
title: *const c_char,
subtitle: *const c_char,
) -> *mut gtk::GtkWidget;
pub fn adw_window_title_get_subtitle(self_: *mut AdwWindowTitle) -> *const c_char;
pub fn adw_window_title_get_title(self_: *mut AdwWindowTitle) -> *const c_char;
pub fn adw_window_title_set_subtitle(self_: *mut AdwWindowTitle, subtitle: *const c_char);
pub fn adw_window_title_set_title(self_: *mut AdwWindowTitle, title: *const c_char);
pub fn adw_swipeable_get_type() -> GType;
pub fn adw_swipeable_get_cancel_progress(self_: *mut AdwSwipeable) -> c_double;
pub fn adw_swipeable_get_distance(self_: *mut AdwSwipeable) -> c_double;
pub fn adw_swipeable_get_progress(self_: *mut AdwSwipeable) -> c_double;
pub fn adw_swipeable_get_snap_points(
self_: *mut AdwSwipeable,
n_snap_points: *mut c_int,
) -> *mut c_double;
pub fn adw_swipeable_get_swipe_area(
self_: *mut AdwSwipeable,
navigation_direction: AdwNavigationDirection,
is_drag: gboolean,
rect: *mut gdk::GdkRectangle,
);
pub fn adw_get_enable_animations(widget: *mut gtk::GtkWidget) -> gboolean;
pub fn adw_get_major_version() -> c_uint;
pub fn adw_get_micro_version() -> c_uint;
pub fn adw_get_minor_version() -> c_uint;
pub fn adw_init();
pub fn adw_is_initialized() -> gboolean;
pub fn adw_lerp(a: c_double, b: c_double, t: c_double) -> c_double;
pub fn adw_show_about_window(
parent: *mut gtk::GtkWindow,
first_property_name: *const c_char,
...
);
}