#![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(docsrs, feature(doc_cfg))]
use gdk_sys as gdk;
use gio_sys as gio;
use glib_sys as glib;
use gobject_sys as gobject;
use gtk_sys as gtk;
use pango_sys as pango;
#[cfg(unix)]
#[allow(unused_imports)]
use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
#[allow(unused_imports)]
use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
#[allow(unused_imports)]
use std::ffi::{
c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
};
#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};
pub type AdwAccentColor = c_int;
pub const ADW_ACCENT_COLOR_BLUE: AdwAccentColor = 0;
pub const ADW_ACCENT_COLOR_TEAL: AdwAccentColor = 1;
pub const ADW_ACCENT_COLOR_GREEN: AdwAccentColor = 2;
pub const ADW_ACCENT_COLOR_YELLOW: AdwAccentColor = 3;
pub const ADW_ACCENT_COLOR_ORANGE: AdwAccentColor = 4;
pub const ADW_ACCENT_COLOR_RED: AdwAccentColor = 5;
pub const ADW_ACCENT_COLOR_PINK: AdwAccentColor = 6;
pub const ADW_ACCENT_COLOR_PURPLE: AdwAccentColor = 7;
pub const ADW_ACCENT_COLOR_SLATE: AdwAccentColor = 8;
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 AdwBreakpointConditionLengthType = c_int;
pub const ADW_BREAKPOINT_CONDITION_MIN_WIDTH: AdwBreakpointConditionLengthType = 0;
pub const ADW_BREAKPOINT_CONDITION_MAX_WIDTH: AdwBreakpointConditionLengthType = 1;
pub const ADW_BREAKPOINT_CONDITION_MIN_HEIGHT: AdwBreakpointConditionLengthType = 2;
pub const ADW_BREAKPOINT_CONDITION_MAX_HEIGHT: AdwBreakpointConditionLengthType = 3;
pub type AdwBreakpointConditionRatioType = c_int;
pub const ADW_BREAKPOINT_CONDITION_MIN_ASPECT_RATIO: AdwBreakpointConditionRatioType = 0;
pub const ADW_BREAKPOINT_CONDITION_MAX_ASPECT_RATIO: AdwBreakpointConditionRatioType = 1;
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 AdwDialogPresentationMode = c_int;
pub const ADW_DIALOG_AUTO: AdwDialogPresentationMode = 0;
pub const ADW_DIALOG_FLOATING: AdwDialogPresentationMode = 1;
pub const ADW_DIALOG_BOTTOM_SHEET: AdwDialogPresentationMode = 2;
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;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub const ADW_EASE: AdwEasing = 31;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub const ADW_EASE_IN: AdwEasing = 32;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub const ADW_EASE_OUT: AdwEasing = 33;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub const ADW_EASE_IN_OUT: AdwEasing = 34;
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 AdwInlineViewSwitcherDisplayMode = c_int;
pub const ADW_INLINE_VIEW_SWITCHER_LABELS: AdwInlineViewSwitcherDisplayMode = 0;
pub const ADW_INLINE_VIEW_SWITCHER_ICONS: AdwInlineViewSwitcherDisplayMode = 1;
pub const ADW_INLINE_VIEW_SWITCHER_BOTH: AdwInlineViewSwitcherDisplayMode = 2;
pub type AdwJustifyMode = c_int;
pub const ADW_JUSTIFY_NONE: AdwJustifyMode = 0;
pub const ADW_JUSTIFY_FILL: AdwJustifyMode = 1;
pub const ADW_JUSTIFY_SPREAD: AdwJustifyMode = 2;
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 AdwLengthUnit = c_int;
pub const ADW_LENGTH_UNIT_PX: AdwLengthUnit = 0;
pub const ADW_LENGTH_UNIT_PT: AdwLengthUnit = 1;
pub const ADW_LENGTH_UNIT_SP: AdwLengthUnit = 2;
pub type AdwNavigationDirection = c_int;
pub const ADW_NAVIGATION_DIRECTION_BACK: AdwNavigationDirection = 0;
pub const ADW_NAVIGATION_DIRECTION_FORWARD: AdwNavigationDirection = 1;
pub type AdwPackDirection = c_int;
pub const ADW_PACK_START_TO_END: AdwPackDirection = 0;
pub const ADW_PACK_END_TO_START: AdwPackDirection = 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 AdwToolbarStyle = c_int;
pub const ADW_TOOLBAR_FLAT: AdwToolbarStyle = 0;
pub const ADW_TOOLBAR_RAISED: AdwToolbarStyle = 1;
pub const ADW_TOOLBAR_RAISED_BORDER: AdwToolbarStyle = 2;
pub type AdwViewSwitcherPolicy = c_int;
pub const ADW_VIEW_SWITCHER_POLICY_NARROW: AdwViewSwitcherPolicy = 0;
pub const ADW_VIEW_SWITCHER_POLICY_WIDE: AdwViewSwitcherPolicy = 1;
pub type AdwWrapPolicy = c_int;
pub const ADW_WRAP_MINIMUM: AdwWrapPolicy = 0;
pub const ADW_WRAP_NATURAL: AdwWrapPolicy = 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 AdwAboutDialogClass {
pub parent_class: AdwDialogClass,
}
impl ::std::fmt::Debug for AdwAboutDialogClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwAboutDialogClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_class", &self.parent_class)
.field("activate", &self.activate)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwAlertDialogClass {
pub parent_class: AdwDialogClass,
pub response: Option<unsafe extern "C" fn(*mut AdwAlertDialog, *const c_char)>,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwAlertDialogClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwAlertDialogClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.field("response", &self.response)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct _AdwAnimationClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type AdwAnimationClass = _AdwAnimationClass;
#[repr(C)]
#[allow(dead_code)]
pub struct _AdwAnimationTargetClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type AdwAnimationTargetClass = _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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwBannerClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwBannerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwBannerClass @ {self:p}"))
.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 @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwBottomSheetClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwBottomSheetClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwBottomSheetClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwBreakpointBinClass {
pub parent_class: gtk::GtkWidgetClass,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwBreakpointBinClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwBreakpointBinClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwBreakpointClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for AdwBreakpointClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwBreakpointClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwBreakpointCondition {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwBreakpointCondition {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwBreakpointCondition @ {self:p}"))
.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 @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwButtonRowClass {
pub parent_class: AdwPreferencesRowClass,
}
impl ::std::fmt::Debug for AdwButtonRowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwButtonRowClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct _AdwCallbackAnimationTargetClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type AdwCallbackAnimationTargetClass = _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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwDialogClass {
pub parent_class: gtk::GtkWidgetClass,
pub close_attempt: Option<unsafe extern "C" fn(*mut AdwDialog)>,
pub closed: Option<unsafe extern "C" fn(*mut AdwDialog)>,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwDialogClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwDialogClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.field("close_attempt", &self.close_attempt)
.field("closed", &self.closed)
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwInlineViewSwitcherClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwInlineViewSwitcherClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwInlineViewSwitcherClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwLayoutClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for AdwLayoutClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwLayoutClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwLayoutSlotClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwLayoutSlotClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwLayoutSlotClass @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_class", &self.parent_class)
.field("response", &self.response)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwMultiLayoutViewClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwMultiLayoutViewClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwMultiLayoutViewClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwNavigationPageClass {
pub parent_class: gtk::GtkWidgetClass,
pub showing: Option<unsafe extern "C" fn(*mut AdwNavigationPage)>,
pub shown: Option<unsafe extern "C" fn(*mut AdwNavigationPage)>,
pub hiding: Option<unsafe extern "C" fn(*mut AdwNavigationPage)>,
pub hidden: Option<unsafe extern "C" fn(*mut AdwNavigationPage)>,
pub padding: [gpointer; 8],
}
impl ::std::fmt::Debug for AdwNavigationPageClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwNavigationPageClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.field("showing", &self.showing)
.field("shown", &self.shown)
.field("hiding", &self.hiding)
.field("hidden", &self.hidden)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwNavigationSplitViewClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwNavigationSplitViewClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwNavigationSplitViewClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwNavigationViewClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwNavigationViewClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwNavigationViewClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwOverlaySplitViewClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwOverlaySplitViewClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwOverlaySplitViewClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.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 @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPreferencesDialogClass {
pub parent_class: AdwDialogClass,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for AdwPreferencesDialogClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwPreferencesDialogClass @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct _AdwPropertyAnimationTargetClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type AdwPropertyAnimationTargetClass = _AdwPropertyAnimationTargetClass;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwSpinRowClass {
pub parent_class: AdwActionRowClass,
}
impl ::std::fmt::Debug for AdwSpinRowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSpinRowClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwSpinnerClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwSpinnerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSpinnerClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwSpinnerPaintableClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for AdwSpinnerPaintableClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSpinnerPaintableClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[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 @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct _AdwSpringAnimationClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type AdwSpringAnimationClass = _AdwSpringAnimationClass;
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 AdwSwitchRowClass {
pub parent_class: AdwActionRowClass,
}
impl ::std::fmt::Debug for AdwSwitchRowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSwitchRowClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct _AdwTimedAnimationClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type AdwTimedAnimationClass = _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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwToggleClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for AdwToggleClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwToggleClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwToggleGroupClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwToggleGroupClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwToggleGroupClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwToolbarViewClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwToolbarViewClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwToolbarViewClass @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwViewStackPagesClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for AdwViewStackPagesClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwViewStackPagesClass @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwWrapBoxClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for AdwWrapBoxClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwWrapBoxClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwWrapLayoutClass {
pub parent_class: gtk::GtkLayoutManagerClass,
}
impl ::std::fmt::Debug for AdwWrapLayoutClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwWrapLayoutClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwAboutDialog {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwAboutDialog {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwAboutDialog @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwAlertDialog {
pub parent_instance: AdwDialog,
}
impl ::std::fmt::Debug for AdwAlertDialog {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwAlertDialog @ {self:p}"))
.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 @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwBanner {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwBanner {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwBanner @ {self:p}")).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 @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwBottomSheet {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwBottomSheet {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwBottomSheet @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwBreakpoint {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwBreakpoint {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwBreakpoint @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwBreakpointBin {
pub parent_instance: gtk::GtkWidget,
}
impl ::std::fmt::Debug for AdwBreakpointBin {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwBreakpointBin @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwButtonRow {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwButtonRow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwButtonRow @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwDialog {
pub parent_instance: gtk::GtkWidget,
}
impl ::std::fmt::Debug for AdwDialog {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwDialog @ {self:p}"))
.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 @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwInlineViewSwitcher {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwInlineViewSwitcher {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwInlineViewSwitcher @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwLayout {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwLayout {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwLayout @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwLayoutSlot {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwLayoutSlot {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwLayoutSlot @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwMultiLayoutView {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwMultiLayoutView {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwMultiLayoutView @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwNavigationPage {
pub parent_instance: gtk::GtkWidget,
}
impl ::std::fmt::Debug for AdwNavigationPage {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwNavigationPage @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwNavigationSplitView {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwNavigationSplitView {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwNavigationSplitView @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwNavigationView {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwNavigationView {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwNavigationView @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwOverlaySplitView {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwOverlaySplitView {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwOverlaySplitView @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AdwPreferencesDialog {
pub parent_instance: AdwDialog,
}
impl ::std::fmt::Debug for AdwPreferencesDialog {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwPreferencesDialog @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwSpinRow {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwSpinRow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSpinRow @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwSpinner {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwSpinner {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSpinner @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwSpinnerPaintable {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwSpinnerPaintable {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSpinnerPaintable @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwSwitchRow {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwSwitchRow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwSwitchRow @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwToggle {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwToggle {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwToggle @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwToggleGroup {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwToggleGroup {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwToggleGroup @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwToolbarView {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwToolbarView {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwToolbarView @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwViewStackPages {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwViewStackPages {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwViewStackPages @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.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 @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwWrapBox {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwWrapBox {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwWrapBox @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct AdwWrapLayout {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for AdwWrapLayout {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("AdwWrapLayout @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
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 @ {self:p}")
}
}
extern "C" {
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_accent_color_get_type() -> GType;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_accent_color_to_rgba(self_: AdwAccentColor, rgba: *mut gdk::GdkRGBA);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_accent_color_to_standalone_rgba(
self_: AdwAccentColor,
dark: gboolean,
rgba: *mut gdk::GdkRGBA,
);
pub fn adw_animation_state_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_condition_length_type_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_condition_ratio_type_get_type() -> GType;
pub fn adw_centering_policy_get_type() -> GType;
pub fn adw_color_scheme_get_type() -> GType;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_presentation_mode_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;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_inline_view_switcher_display_mode_get_type() -> GType;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_justify_mode_get_type() -> GType;
pub fn adw_leaflet_transition_type_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_length_unit_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_length_unit_from_px(
unit: AdwLengthUnit,
value: c_double,
settings: *mut gtk::GtkSettings,
) -> c_double;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_length_unit_to_px(
unit: AdwLengthUnit,
value: c_double,
settings: *mut gtk::GtkSettings,
) -> c_double;
pub fn adw_navigation_direction_get_type() -> GType;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_pack_direction_get_type() -> GType;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, 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;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_style_get_type() -> GType;
pub fn adw_view_switcher_policy_get_type() -> GType;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_policy_get_type() -> GType;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_tab_view_shortcuts_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_condition_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_condition_new_and(
condition_1: *mut AdwBreakpointCondition,
condition_2: *mut AdwBreakpointCondition,
) -> *mut AdwBreakpointCondition;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_condition_new_length(
type_: AdwBreakpointConditionLengthType,
value: c_double,
unit: AdwLengthUnit,
) -> *mut AdwBreakpointCondition;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_condition_new_or(
condition_1: *mut AdwBreakpointCondition,
condition_2: *mut AdwBreakpointCondition,
) -> *mut AdwBreakpointCondition;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_condition_new_ratio(
type_: AdwBreakpointConditionRatioType,
width: c_int,
height: c_int,
) -> *mut AdwBreakpointCondition;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_condition_copy(
self_: *mut AdwBreakpointCondition,
) -> *mut AdwBreakpointCondition;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_condition_free(self_: *mut AdwBreakpointCondition);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_condition_to_string(self_: *mut AdwBreakpointCondition) -> *mut c_char;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_condition_parse(str: *const c_char) -> *mut AdwBreakpointCondition;
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(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_type() -> GType;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_new() -> *mut AdwDialog;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
#[cfg(not(target_env = "msvc"))]
#[cfg_attr(docsrs, doc(cfg(not(target_env = "msvc"))))]
pub fn adw_about_dialog_new_from_appdata(
resource_path: *const c_char,
release_notes_version: *const c_char,
) -> *mut AdwDialog;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_add_acknowledgement_section(
self_: *mut AdwAboutDialog,
name: *const c_char,
people: *mut *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_add_credit_section(
self_: *mut AdwAboutDialog,
name: *const c_char,
people: *mut *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_add_legal_section(
self_: *mut AdwAboutDialog,
title: *const c_char,
copyright: *const c_char,
license_type: gtk::GtkLicense,
license: *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_add_link(
self_: *mut AdwAboutDialog,
title: *const c_char,
url: *const c_char,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_about_dialog_add_other_app(
self_: *mut AdwAboutDialog,
appid: *const c_char,
name: *const c_char,
summary: *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_application_icon(self_: *mut AdwAboutDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_application_name(self_: *mut AdwAboutDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_artists(self_: *mut AdwAboutDialog) -> *const *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_comments(self_: *mut AdwAboutDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_copyright(self_: *mut AdwAboutDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_debug_info(self_: *mut AdwAboutDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_debug_info_filename(self_: *mut AdwAboutDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_designers(self_: *mut AdwAboutDialog) -> *const *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_developer_name(self_: *mut AdwAboutDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_developers(self_: *mut AdwAboutDialog) -> *const *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_documenters(self_: *mut AdwAboutDialog) -> *const *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_issue_url(self_: *mut AdwAboutDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_license(self_: *mut AdwAboutDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_license_type(self_: *mut AdwAboutDialog) -> gtk::GtkLicense;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_release_notes(self_: *mut AdwAboutDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_release_notes_version(self_: *mut AdwAboutDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_support_url(self_: *mut AdwAboutDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_translator_credits(self_: *mut AdwAboutDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_version(self_: *mut AdwAboutDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_get_website(self_: *mut AdwAboutDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_application_icon(
self_: *mut AdwAboutDialog,
application_icon: *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_application_name(
self_: *mut AdwAboutDialog,
application_name: *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_artists(self_: *mut AdwAboutDialog, artists: *mut *const c_char);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_comments(self_: *mut AdwAboutDialog, comments: *const c_char);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_copyright(self_: *mut AdwAboutDialog, copyright: *const c_char);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_debug_info(self_: *mut AdwAboutDialog, debug_info: *const c_char);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_debug_info_filename(
self_: *mut AdwAboutDialog,
filename: *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_designers(
self_: *mut AdwAboutDialog,
designers: *mut *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_developer_name(
self_: *mut AdwAboutDialog,
developer_name: *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_developers(
self_: *mut AdwAboutDialog,
developers: *mut *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_documenters(
self_: *mut AdwAboutDialog,
documenters: *mut *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_issue_url(self_: *mut AdwAboutDialog, issue_url: *const c_char);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_license(self_: *mut AdwAboutDialog, license: *const c_char);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_license_type(
self_: *mut AdwAboutDialog,
license_type: gtk::GtkLicense,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_release_notes(
self_: *mut AdwAboutDialog,
release_notes: *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_release_notes_version(
self_: *mut AdwAboutDialog,
version: *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_support_url(self_: *mut AdwAboutDialog, support_url: *const c_char);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_translator_credits(
self_: *mut AdwAboutDialog,
translator_credits: *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_version(self_: *mut AdwAboutDialog, version: *const c_char);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_about_dialog_set_website(self_: *mut AdwAboutDialog, website: *const c_char);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_type() -> GType;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
#[cfg(not(target_env = "msvc"))]
#[cfg_attr(docsrs, doc(cfg(not(target_env = "msvc"))))]
pub fn adw_about_window_new_from_appdata(
resource_path: *const c_char,
release_notes_version: *const c_char,
) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, 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(feature = "v1_2")]
#[cfg_attr(docsrs, 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(feature = "v1_2")]
#[cfg_attr(docsrs, 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(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_add_link(
self_: *mut AdwAboutWindow,
title: *const c_char,
url: *const c_char,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_application_icon(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_application_name(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_artists(self_: *mut AdwAboutWindow) -> *const *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_comments(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_copyright(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_debug_info(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_debug_info_filename(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_designers(self_: *mut AdwAboutWindow) -> *const *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_developer_name(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_developers(self_: *mut AdwAboutWindow) -> *const *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_documenters(self_: *mut AdwAboutWindow) -> *const *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_issue_url(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_license(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_license_type(self_: *mut AdwAboutWindow) -> gtk::GtkLicense;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_release_notes(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_release_notes_version(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_support_url(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_translator_credits(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_version(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_get_website(self_: *mut AdwAboutWindow) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_application_icon(
self_: *mut AdwAboutWindow,
application_icon: *const c_char,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_application_name(
self_: *mut AdwAboutWindow,
application_name: *const c_char,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_artists(self_: *mut AdwAboutWindow, artists: *mut *const c_char);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_comments(self_: *mut AdwAboutWindow, comments: *const c_char);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_copyright(self_: *mut AdwAboutWindow, copyright: *const c_char);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_debug_info(self_: *mut AdwAboutWindow, debug_info: *const c_char);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_debug_info_filename(
self_: *mut AdwAboutWindow,
filename: *const c_char,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_designers(
self_: *mut AdwAboutWindow,
designers: *mut *const c_char,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_developer_name(
self_: *mut AdwAboutWindow,
developer_name: *const c_char,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_developers(
self_: *mut AdwAboutWindow,
developers: *mut *const c_char,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_documenters(
self_: *mut AdwAboutWindow,
documenters: *mut *const c_char,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_issue_url(self_: *mut AdwAboutWindow, issue_url: *const c_char);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_license(self_: *mut AdwAboutWindow, license: *const c_char);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_license_type(
self_: *mut AdwAboutWindow,
license_type: gtk::GtkLicense,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_release_notes(
self_: *mut AdwAboutWindow,
release_notes: *const c_char,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_release_notes_version(
self_: *mut AdwAboutWindow,
version: *const c_char,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_support_url(self_: *mut AdwAboutWindow, support_url: *const c_char);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_translator_credits(
self_: *mut AdwAboutWindow,
translator_credits: *const c_char,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_about_window_set_version(self_: *mut AdwAboutWindow, version: *const c_char);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, 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;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_action_row_get_subtitle_selectable(self_: *mut AdwActionRow) -> gboolean;
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);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_action_row_set_subtitle_selectable(
self_: *mut AdwActionRow,
subtitle_selectable: gboolean,
);
pub fn adw_action_row_set_title_lines(self_: *mut AdwActionRow, title_lines: c_int);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_get_type() -> GType;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_new(heading: *const c_char, body: *const c_char) -> *mut AdwDialog;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_add_response(
self_: *mut AdwAlertDialog,
id: *const c_char,
label: *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_add_responses(self_: *mut AdwAlertDialog, first_id: *const c_char, ...);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_choose(
self_: *mut AdwAlertDialog,
parent: *mut gtk::GtkWidget,
cancellable: *mut gio::GCancellable,
callback: gio::GAsyncReadyCallback,
user_data: gpointer,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_choose_finish(
self_: *mut AdwAlertDialog,
result: *mut gio::GAsyncResult,
) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_format_body(self_: *mut AdwAlertDialog, format: *const c_char, ...);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_format_body_markup(
self_: *mut AdwAlertDialog,
format: *const c_char,
...
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_format_heading(self_: *mut AdwAlertDialog, format: *const c_char, ...);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_format_heading_markup(
self_: *mut AdwAlertDialog,
format: *const c_char,
...
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_get_body(self_: *mut AdwAlertDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_get_body_use_markup(self_: *mut AdwAlertDialog) -> gboolean;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_get_close_response(self_: *mut AdwAlertDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_get_default_response(self_: *mut AdwAlertDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_get_extra_child(self_: *mut AdwAlertDialog) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_get_heading(self_: *mut AdwAlertDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_get_heading_use_markup(self_: *mut AdwAlertDialog) -> gboolean;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_get_prefer_wide_layout(self_: *mut AdwAlertDialog) -> gboolean;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_get_response_appearance(
self_: *mut AdwAlertDialog,
response: *const c_char,
) -> AdwResponseAppearance;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_get_response_enabled(
self_: *mut AdwAlertDialog,
response: *const c_char,
) -> gboolean;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_get_response_label(
self_: *mut AdwAlertDialog,
response: *const c_char,
) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_has_response(
self_: *mut AdwAlertDialog,
response: *const c_char,
) -> gboolean;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_remove_response(self_: *mut AdwAlertDialog, id: *const c_char);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_set_body(self_: *mut AdwAlertDialog, body: *const c_char);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_set_body_use_markup(self_: *mut AdwAlertDialog, use_markup: gboolean);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_set_close_response(self_: *mut AdwAlertDialog, response: *const c_char);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_set_default_response(
self_: *mut AdwAlertDialog,
response: *const c_char,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_set_extra_child(self_: *mut AdwAlertDialog, child: *mut gtk::GtkWidget);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_set_heading(self_: *mut AdwAlertDialog, heading: *const c_char);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_set_heading_use_markup(
self_: *mut AdwAlertDialog,
use_markup: gboolean,
);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_alert_dialog_set_prefer_wide_layout(
self_: *mut AdwAlertDialog,
prefer_wide_layout: gboolean,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_set_response_appearance(
self_: *mut AdwAlertDialog,
response: *const c_char,
appearance: AdwResponseAppearance,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_set_response_enabled(
self_: *mut AdwAlertDialog,
response: *const c_char,
enabled: gboolean,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_alert_dialog_set_response_label(
self_: *mut AdwAlertDialog,
response: *const c_char,
label: *const c_char,
);
pub fn adw_animation_get_type() -> GType;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_animation_get_follow_enable_animations_setting(self_: *mut AdwAnimation)
-> gboolean;
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);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_animation_set_follow_enable_animations_setting(
self_: *mut AdwAnimation,
setting: gboolean,
);
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;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_application_window_add_breakpoint(
self_: *mut AdwApplicationWindow,
breakpoint: *mut AdwBreakpoint,
);
pub fn adw_application_window_get_content(
self_: *mut AdwApplicationWindow,
) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_application_window_get_current_breakpoint(
self_: *mut AdwApplicationWindow,
) -> *mut AdwBreakpoint;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_application_window_get_dialogs(
self_: *mut AdwApplicationWindow,
) -> *mut gio::GListModel;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_application_window_get_visible_dialog(
self_: *mut AdwApplicationWindow,
) -> *mut AdwDialog;
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);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_banner_get_type() -> GType;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_banner_new(title: *const c_char) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_banner_get_button_label(self_: *mut AdwBanner) -> *const c_char;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_banner_get_revealed(self_: *mut AdwBanner) -> gboolean;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_banner_get_title(self_: *mut AdwBanner) -> *const c_char;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_banner_get_use_markup(self_: *mut AdwBanner) -> gboolean;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_banner_set_button_label(self_: *mut AdwBanner, label: *const c_char);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_banner_set_revealed(self_: *mut AdwBanner, revealed: gboolean);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_banner_set_title(self_: *mut AdwBanner, title: *const c_char);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_banner_set_use_markup(self_: *mut AdwBanner, use_markup: gboolean);
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);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_get_type() -> GType;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_get_align(self_: *mut AdwBottomSheet) -> c_float;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_get_bottom_bar(self_: *mut AdwBottomSheet) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_get_bottom_bar_height(self_: *mut AdwBottomSheet) -> c_int;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_get_can_close(self_: *mut AdwBottomSheet) -> gboolean;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_get_can_open(self_: *mut AdwBottomSheet) -> gboolean;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_get_content(self_: *mut AdwBottomSheet) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_get_full_width(self_: *mut AdwBottomSheet) -> gboolean;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_get_modal(self_: *mut AdwBottomSheet) -> gboolean;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_get_open(self_: *mut AdwBottomSheet) -> gboolean;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_bottom_sheet_get_reveal_bottom_bar(self_: *mut AdwBottomSheet) -> gboolean;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_get_sheet(self_: *mut AdwBottomSheet) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_get_sheet_height(self_: *mut AdwBottomSheet) -> c_int;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_get_show_drag_handle(self_: *mut AdwBottomSheet) -> gboolean;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_set_align(self_: *mut AdwBottomSheet, align: c_float);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_set_bottom_bar(
self_: *mut AdwBottomSheet,
bottom_bar: *mut gtk::GtkWidget,
);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_set_can_close(self_: *mut AdwBottomSheet, can_close: gboolean);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_set_can_open(self_: *mut AdwBottomSheet, can_open: gboolean);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_set_content(self_: *mut AdwBottomSheet, content: *mut gtk::GtkWidget);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_set_full_width(self_: *mut AdwBottomSheet, full_width: gboolean);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_set_modal(self_: *mut AdwBottomSheet, modal: gboolean);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_set_open(self_: *mut AdwBottomSheet, open: gboolean);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_bottom_sheet_set_reveal_bottom_bar(self_: *mut AdwBottomSheet, reveal: gboolean);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_set_sheet(self_: *mut AdwBottomSheet, sheet: *mut gtk::GtkWidget);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_bottom_sheet_set_show_drag_handle(
self_: *mut AdwBottomSheet,
show_drag_handle: gboolean,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_new(condition: *mut AdwBreakpointCondition) -> *mut AdwBreakpoint;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_add_setter(
self_: *mut AdwBreakpoint,
object: *mut gobject::GObject,
property: *const c_char,
value: *const gobject::GValue,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_add_setters(
self_: *mut AdwBreakpoint,
first_object: *mut gobject::GObject,
first_property: *const c_char,
...
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_add_settersv(
self_: *mut AdwBreakpoint,
n_setters: c_int,
objects: *mut *mut gobject::GObject,
names: *mut *const c_char,
values: *mut *const gobject::GValue,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_get_condition(self_: *mut AdwBreakpoint) -> *mut AdwBreakpointCondition;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_set_condition(
self_: *mut AdwBreakpoint,
condition: *mut AdwBreakpointCondition,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_bin_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_bin_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_bin_add_breakpoint(
self_: *mut AdwBreakpointBin,
breakpoint: *mut AdwBreakpoint,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_bin_get_child(self_: *mut AdwBreakpointBin) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_bin_get_current_breakpoint(
self_: *mut AdwBreakpointBin,
) -> *mut AdwBreakpoint;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_breakpoint_bin_remove_breakpoint(
self_: *mut AdwBreakpointBin,
breakpoint: *mut AdwBreakpoint,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_breakpoint_bin_set_child(self_: *mut AdwBreakpointBin, child: *mut gtk::GtkWidget);
pub fn adw_button_content_get_type() -> GType;
pub fn adw_button_content_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_button_content_get_can_shrink(self_: *mut AdwButtonContent) -> gboolean;
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;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_button_content_set_can_shrink(self_: *mut AdwButtonContent, can_shrink: 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,
);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_button_row_get_type() -> GType;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_button_row_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_button_row_get_end_icon_name(self_: *mut AdwButtonRow) -> *const c_char;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_button_row_get_start_icon_name(self_: *mut AdwButtonRow) -> *const c_char;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_button_row_set_end_icon_name(self_: *mut AdwButtonRow, icon_name: *const c_char);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_button_row_set_start_icon_name(self_: *mut AdwButtonRow, icon_name: *const c_char);
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;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_clamp_get_unit(self_: *mut AdwClamp) -> AdwLengthUnit;
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);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_clamp_set_unit(self_: *mut AdwClamp, unit: AdwLengthUnit);
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;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_clamp_layout_get_unit(self_: *mut AdwClampLayout) -> AdwLengthUnit;
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,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_clamp_layout_set_unit(self_: *mut AdwClampLayout, unit: AdwLengthUnit);
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;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_clamp_scrollable_get_unit(self_: *mut AdwClampScrollable) -> AdwLengthUnit;
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,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_clamp_scrollable_set_unit(self_: *mut AdwClampScrollable, unit: AdwLengthUnit);
pub fn adw_combo_row_get_type() -> GType;
pub fn adw_combo_row_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_combo_row_get_enable_search(self_: *mut AdwComboRow) -> gboolean;
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;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_combo_row_get_header_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;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_combo_row_get_search_match_mode(
self_: *mut AdwComboRow,
) -> gtk::GtkStringFilterMatchMode;
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;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_combo_row_set_enable_search(self_: *mut AdwComboRow, enable_search: 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,
);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_combo_row_set_header_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);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_combo_row_set_search_match_mode(
self_: *mut AdwComboRow,
search_match_mode: gtk::GtkStringFilterMatchMode,
);
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(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_get_type() -> GType;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_new() -> *mut AdwDialog;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_add_breakpoint(self_: *mut AdwDialog, breakpoint: *mut AdwBreakpoint);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_close(self_: *mut AdwDialog) -> gboolean;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_force_close(self_: *mut AdwDialog);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_get_can_close(self_: *mut AdwDialog) -> gboolean;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_get_child(self_: *mut AdwDialog) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_get_content_height(self_: *mut AdwDialog) -> c_int;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_get_content_width(self_: *mut AdwDialog) -> c_int;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_get_current_breakpoint(self_: *mut AdwDialog) -> *mut AdwBreakpoint;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_get_default_widget(self_: *mut AdwDialog) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_get_focus(self_: *mut AdwDialog) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_get_follows_content_size(self_: *mut AdwDialog) -> gboolean;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_get_presentation_mode(self_: *mut AdwDialog) -> AdwDialogPresentationMode;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_get_title(self_: *mut AdwDialog) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_present(self_: *mut AdwDialog, parent: *mut gtk::GtkWidget);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_set_can_close(self_: *mut AdwDialog, can_close: gboolean);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_set_child(self_: *mut AdwDialog, child: *mut gtk::GtkWidget);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_set_content_height(self_: *mut AdwDialog, content_height: c_int);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_set_content_width(self_: *mut AdwDialog, content_width: c_int);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_set_default_widget(
self_: *mut AdwDialog,
default_widget: *mut gtk::GtkWidget,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_set_focus(self_: *mut AdwDialog, focus: *mut gtk::GtkWidget);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_set_follows_content_size(
self_: *mut AdwDialog,
follows_content_size: gboolean,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_set_presentation_mode(
self_: *mut AdwDialog,
presentation_mode: AdwDialogPresentationMode,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_dialog_set_title(self_: *mut AdwDialog, title: *const c_char);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_get_type() -> GType;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_add_prefix(self_: *mut AdwEntryRow, widget: *mut gtk::GtkWidget);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_add_suffix(self_: *mut AdwEntryRow, widget: *mut gtk::GtkWidget);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_get_activates_default(self_: *mut AdwEntryRow) -> gboolean;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_get_attributes(self_: *mut AdwEntryRow) -> *mut pango::PangoAttrList;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_get_enable_emoji_completion(self_: *mut AdwEntryRow) -> gboolean;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_get_input_hints(self_: *mut AdwEntryRow) -> gtk::GtkInputHints;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_get_input_purpose(self_: *mut AdwEntryRow) -> gtk::GtkInputPurpose;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_entry_row_get_max_length(self_: *mut AdwEntryRow) -> c_int;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_get_show_apply_button(self_: *mut AdwEntryRow) -> gboolean;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_entry_row_get_text_length(self_: *mut AdwEntryRow) -> c_uint;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_entry_row_grab_focus_without_selecting(self_: *mut AdwEntryRow) -> gboolean;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_remove(self_: *mut AdwEntryRow, widget: *mut gtk::GtkWidget);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_set_activates_default(self_: *mut AdwEntryRow, activates: gboolean);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_set_attributes(
self_: *mut AdwEntryRow,
attributes: *mut pango::PangoAttrList,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_set_enable_emoji_completion(
self_: *mut AdwEntryRow,
enable_emoji_completion: gboolean,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_set_input_hints(self_: *mut AdwEntryRow, hints: gtk::GtkInputHints);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_entry_row_set_input_purpose(self_: *mut AdwEntryRow, purpose: gtk::GtkInputPurpose);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_entry_row_set_max_length(self_: *mut AdwEntryRow, max_length: c_int);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, 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);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_expander_row_add_suffix(self_: *mut AdwExpanderRow, widget: *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(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_expander_row_get_subtitle_lines(self_: *mut AdwExpanderRow) -> c_int;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_expander_row_get_title_lines(self_: *mut AdwExpanderRow) -> c_int;
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(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_expander_row_set_subtitle_lines(self_: *mut AdwExpanderRow, subtitle_lines: c_int);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, 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;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_header_bar_get_show_back_button(self_: *mut AdwHeaderBar) -> gboolean;
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;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_header_bar_get_show_title(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);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_header_bar_set_show_back_button(
self_: *mut AdwHeaderBar,
show_back_button: gboolean,
);
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);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_header_bar_set_show_title(self_: *mut AdwHeaderBar, show_title: gboolean);
pub fn adw_header_bar_set_title_widget(
self_: *mut AdwHeaderBar,
title_widget: *mut gtk::GtkWidget,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_inline_view_switcher_get_type() -> GType;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_inline_view_switcher_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_inline_view_switcher_get_can_shrink(self_: *mut AdwInlineViewSwitcher) -> gboolean;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_inline_view_switcher_get_display_mode(
self_: *mut AdwInlineViewSwitcher,
) -> AdwInlineViewSwitcherDisplayMode;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_inline_view_switcher_get_homogeneous(self_: *mut AdwInlineViewSwitcher) -> gboolean;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_inline_view_switcher_get_stack(
self_: *mut AdwInlineViewSwitcher,
) -> *mut AdwViewStack;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_inline_view_switcher_set_can_shrink(
self_: *mut AdwInlineViewSwitcher,
can_shrink: gboolean,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_inline_view_switcher_set_display_mode(
self_: *mut AdwInlineViewSwitcher,
mode: AdwInlineViewSwitcherDisplayMode,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_inline_view_switcher_set_homogeneous(
self_: *mut AdwInlineViewSwitcher,
homogeneous: gboolean,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_inline_view_switcher_set_stack(
self_: *mut AdwInlineViewSwitcher,
stack: *mut AdwViewStack,
);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_layout_get_type() -> GType;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_layout_new(content: *mut gtk::GtkWidget) -> *mut AdwLayout;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_layout_get_content(self_: *mut AdwLayout) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_layout_get_name(self_: *mut AdwLayout) -> *const c_char;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_layout_set_name(self_: *mut AdwLayout, name: *const c_char);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_layout_slot_get_type() -> GType;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_layout_slot_new(id: *const c_char) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_layout_slot_get_slot_id(self_: *mut AdwLayoutSlot) -> *const c_char;
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(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_type() -> GType;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, 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(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_add_response(
self_: *mut AdwMessageDialog,
id: *const c_char,
label: *const c_char,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_add_responses(
self_: *mut AdwMessageDialog,
first_id: *const c_char,
...
);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_message_dialog_choose(
self_: *mut AdwMessageDialog,
cancellable: *mut gio::GCancellable,
callback: gio::GAsyncReadyCallback,
user_data: gpointer,
);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_message_dialog_choose_finish(
self_: *mut AdwMessageDialog,
result: *mut gio::GAsyncResult,
) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_format_body(self_: *mut AdwMessageDialog, format: *const c_char, ...);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_format_body_markup(
self_: *mut AdwMessageDialog,
format: *const c_char,
...
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_format_heading(
self_: *mut AdwMessageDialog,
format: *const c_char,
...
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_format_heading_markup(
self_: *mut AdwMessageDialog,
format: *const c_char,
...
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_body(self_: *mut AdwMessageDialog) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_body_use_markup(self_: *mut AdwMessageDialog) -> gboolean;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_close_response(self_: *mut AdwMessageDialog) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_default_response(self_: *mut AdwMessageDialog) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_extra_child(self_: *mut AdwMessageDialog) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_heading(self_: *mut AdwMessageDialog) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_heading_use_markup(self_: *mut AdwMessageDialog) -> gboolean;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_response_appearance(
self_: *mut AdwMessageDialog,
response: *const c_char,
) -> AdwResponseAppearance;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_response_enabled(
self_: *mut AdwMessageDialog,
response: *const c_char,
) -> gboolean;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_get_response_label(
self_: *mut AdwMessageDialog,
response: *const c_char,
) -> *const c_char;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_has_response(
self_: *mut AdwMessageDialog,
response: *const c_char,
) -> gboolean;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_message_dialog_remove_response(self_: *mut AdwMessageDialog, id: *const c_char);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_response(self_: *mut AdwMessageDialog, response: *const c_char);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_body(self_: *mut AdwMessageDialog, body: *const c_char);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_body_use_markup(
self_: *mut AdwMessageDialog,
use_markup: gboolean,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_close_response(
self_: *mut AdwMessageDialog,
response: *const c_char,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_default_response(
self_: *mut AdwMessageDialog,
response: *const c_char,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_extra_child(
self_: *mut AdwMessageDialog,
child: *mut gtk::GtkWidget,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_heading(self_: *mut AdwMessageDialog, heading: *const c_char);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_heading_use_markup(
self_: *mut AdwMessageDialog,
use_markup: gboolean,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_response_appearance(
self_: *mut AdwMessageDialog,
response: *const c_char,
appearance: AdwResponseAppearance,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_message_dialog_set_response_enabled(
self_: *mut AdwMessageDialog,
response: *const c_char,
enabled: gboolean,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, 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(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_multi_layout_view_get_type() -> GType;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_multi_layout_view_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_multi_layout_view_add_layout(self_: *mut AdwMultiLayoutView, layout: *mut AdwLayout);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_multi_layout_view_get_child(
self_: *mut AdwMultiLayoutView,
id: *const c_char,
) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_multi_layout_view_get_layout(self_: *mut AdwMultiLayoutView) -> *mut AdwLayout;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_multi_layout_view_get_layout_by_name(
self_: *mut AdwMultiLayoutView,
name: *const c_char,
) -> *mut AdwLayout;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_multi_layout_view_get_layout_name(self_: *mut AdwMultiLayoutView) -> *const c_char;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_multi_layout_view_remove_layout(
self_: *mut AdwMultiLayoutView,
layout: *mut AdwLayout,
);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_multi_layout_view_set_child(
self_: *mut AdwMultiLayoutView,
id: *const c_char,
child: *mut gtk::GtkWidget,
);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_multi_layout_view_set_layout(self_: *mut AdwMultiLayoutView, layout: *mut AdwLayout);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_multi_layout_view_set_layout_name(
self_: *mut AdwMultiLayoutView,
name: *const c_char,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_page_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_page_new(
child: *mut gtk::GtkWidget,
title: *const c_char,
) -> *mut AdwNavigationPage;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_page_new_with_tag(
child: *mut gtk::GtkWidget,
title: *const c_char,
tag: *const c_char,
) -> *mut AdwNavigationPage;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_page_get_can_pop(self_: *mut AdwNavigationPage) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_page_get_child(self_: *mut AdwNavigationPage) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_page_get_tag(self_: *mut AdwNavigationPage) -> *const c_char;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_page_get_title(self_: *mut AdwNavigationPage) -> *const c_char;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_page_set_can_pop(self_: *mut AdwNavigationPage, can_pop: gboolean);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_page_set_child(self_: *mut AdwNavigationPage, child: *mut gtk::GtkWidget);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_page_set_tag(self_: *mut AdwNavigationPage, tag: *const c_char);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_page_set_title(self_: *mut AdwNavigationPage, title: *const c_char);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_get_collapsed(self_: *mut AdwNavigationSplitView) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_get_content(
self_: *mut AdwNavigationSplitView,
) -> *mut AdwNavigationPage;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_get_max_sidebar_width(
self_: *mut AdwNavigationSplitView,
) -> c_double;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_get_min_sidebar_width(
self_: *mut AdwNavigationSplitView,
) -> c_double;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_get_show_content(
self_: *mut AdwNavigationSplitView,
) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_get_sidebar(
self_: *mut AdwNavigationSplitView,
) -> *mut AdwNavigationPage;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_navigation_split_view_get_sidebar_position(
self_: *mut AdwNavigationSplitView,
) -> gtk::GtkPackType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_get_sidebar_width_fraction(
self_: *mut AdwNavigationSplitView,
) -> c_double;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_get_sidebar_width_unit(
self_: *mut AdwNavigationSplitView,
) -> AdwLengthUnit;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_set_collapsed(
self_: *mut AdwNavigationSplitView,
collapsed: gboolean,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_set_content(
self_: *mut AdwNavigationSplitView,
content: *mut AdwNavigationPage,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_set_max_sidebar_width(
self_: *mut AdwNavigationSplitView,
width: c_double,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_set_min_sidebar_width(
self_: *mut AdwNavigationSplitView,
width: c_double,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_set_show_content(
self_: *mut AdwNavigationSplitView,
show_content: gboolean,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_set_sidebar(
self_: *mut AdwNavigationSplitView,
sidebar: *mut AdwNavigationPage,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_navigation_split_view_set_sidebar_position(
self_: *mut AdwNavigationSplitView,
position: gtk::GtkPackType,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_set_sidebar_width_fraction(
self_: *mut AdwNavigationSplitView,
fraction: c_double,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_split_view_set_sidebar_width_unit(
self_: *mut AdwNavigationSplitView,
unit: AdwLengthUnit,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_add(self_: *mut AdwNavigationView, page: *mut AdwNavigationPage);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_find_page(
self_: *mut AdwNavigationView,
tag: *const c_char,
) -> *mut AdwNavigationPage;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_get_animate_transitions(self_: *mut AdwNavigationView) -> gboolean;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_navigation_view_get_hhomogeneous(self_: *mut AdwNavigationView) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_get_navigation_stack(
self_: *mut AdwNavigationView,
) -> *mut gio::GListModel;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_get_pop_on_escape(self_: *mut AdwNavigationView) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_get_previous_page(
self_: *mut AdwNavigationView,
page: *mut AdwNavigationPage,
) -> *mut AdwNavigationPage;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_navigation_view_get_vhomogeneous(self_: *mut AdwNavigationView) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_get_visible_page(
self_: *mut AdwNavigationView,
) -> *mut AdwNavigationPage;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_pop(self_: *mut AdwNavigationView) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_pop_to_page(
self_: *mut AdwNavigationView,
page: *mut AdwNavigationPage,
) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_pop_to_tag(
self_: *mut AdwNavigationView,
tag: *const c_char,
) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_push(self_: *mut AdwNavigationView, page: *mut AdwNavigationPage);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_push_by_tag(self_: *mut AdwNavigationView, tag: *const c_char);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_remove(self_: *mut AdwNavigationView, page: *mut AdwNavigationPage);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_replace(
self_: *mut AdwNavigationView,
pages: *mut *mut AdwNavigationPage,
n_pages: c_int,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_replace_with_tags(
self_: *mut AdwNavigationView,
tags: *const *const c_char,
n_tags: c_int,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_set_animate_transitions(
self_: *mut AdwNavigationView,
animate_transitions: gboolean,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_navigation_view_set_hhomogeneous(
self_: *mut AdwNavigationView,
hhomogeneous: gboolean,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_navigation_view_set_pop_on_escape(
self_: *mut AdwNavigationView,
pop_on_escape: gboolean,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_navigation_view_set_vhomogeneous(
self_: *mut AdwNavigationView,
vhomogeneous: gboolean,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_get_collapsed(self_: *mut AdwOverlaySplitView) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_get_content(
self_: *mut AdwOverlaySplitView,
) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_get_enable_hide_gesture(
self_: *mut AdwOverlaySplitView,
) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_get_enable_show_gesture(
self_: *mut AdwOverlaySplitView,
) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_get_max_sidebar_width(
self_: *mut AdwOverlaySplitView,
) -> c_double;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_get_min_sidebar_width(
self_: *mut AdwOverlaySplitView,
) -> c_double;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_get_pin_sidebar(self_: *mut AdwOverlaySplitView) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_get_show_sidebar(self_: *mut AdwOverlaySplitView) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_get_sidebar(
self_: *mut AdwOverlaySplitView,
) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_get_sidebar_position(
self_: *mut AdwOverlaySplitView,
) -> gtk::GtkPackType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_get_sidebar_width_fraction(
self_: *mut AdwOverlaySplitView,
) -> c_double;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_get_sidebar_width_unit(
self_: *mut AdwOverlaySplitView,
) -> AdwLengthUnit;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_set_collapsed(
self_: *mut AdwOverlaySplitView,
collapsed: gboolean,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_set_content(
self_: *mut AdwOverlaySplitView,
content: *mut gtk::GtkWidget,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_set_enable_hide_gesture(
self_: *mut AdwOverlaySplitView,
enable_hide_gesture: gboolean,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_set_enable_show_gesture(
self_: *mut AdwOverlaySplitView,
enable_show_gesture: gboolean,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_set_max_sidebar_width(
self_: *mut AdwOverlaySplitView,
width: c_double,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_set_min_sidebar_width(
self_: *mut AdwOverlaySplitView,
width: c_double,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_set_pin_sidebar(
self_: *mut AdwOverlaySplitView,
pin_sidebar: gboolean,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_set_show_sidebar(
self_: *mut AdwOverlaySplitView,
show_sidebar: gboolean,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_set_sidebar(
self_: *mut AdwOverlaySplitView,
sidebar: *mut gtk::GtkWidget,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_set_sidebar_position(
self_: *mut AdwOverlaySplitView,
position: gtk::GtkPackType,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_set_sidebar_width_fraction(
self_: *mut AdwOverlaySplitView,
fraction: c_double,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_overlay_split_view_set_sidebar_width_unit(
self_: *mut AdwOverlaySplitView,
unit: AdwLengthUnit,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_password_entry_row_get_type() -> GType;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_password_entry_row_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_preferences_dialog_get_type() -> GType;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_preferences_dialog_new() -> *mut AdwDialog;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_preferences_dialog_add(
self_: *mut AdwPreferencesDialog,
page: *mut AdwPreferencesPage,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_preferences_dialog_add_toast(self_: *mut AdwPreferencesDialog, toast: *mut AdwToast);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_preferences_dialog_get_search_enabled(self_: *mut AdwPreferencesDialog) -> gboolean;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_preferences_dialog_get_visible_page(
self_: *mut AdwPreferencesDialog,
) -> *mut AdwPreferencesPage;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_preferences_dialog_get_visible_page_name(
self_: *mut AdwPreferencesDialog,
) -> *const c_char;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_preferences_dialog_pop_subpage(self_: *mut AdwPreferencesDialog) -> gboolean;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_preferences_dialog_push_subpage(
self_: *mut AdwPreferencesDialog,
page: *mut AdwNavigationPage,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_preferences_dialog_remove(
self_: *mut AdwPreferencesDialog,
page: *mut AdwPreferencesPage,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_preferences_dialog_set_search_enabled(
self_: *mut AdwPreferencesDialog,
search_enabled: gboolean,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_preferences_dialog_set_visible_page(
self_: *mut AdwPreferencesDialog,
page: *mut AdwPreferencesPage,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_preferences_dialog_set_visible_page_name(
self_: *mut AdwPreferencesDialog,
name: *const c_char,
);
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(feature = "v1_1")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
pub fn adw_preferences_group_get_header_suffix(
self_: *mut AdwPreferencesGroup,
) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_preferences_group_get_separate_rows(self_: *mut AdwPreferencesGroup) -> gboolean;
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(feature = "v1_1")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
pub fn adw_preferences_group_set_header_suffix(
self_: *mut AdwPreferencesGroup,
suffix: *mut gtk::GtkWidget,
);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_preferences_group_set_separate_rows(
self_: *mut AdwPreferencesGroup,
separate_rows: gboolean,
);
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,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_preferences_page_get_banner(self_: *mut AdwPreferencesPage) -> *mut AdwBanner;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_preferences_page_get_description(self_: *mut AdwPreferencesPage) -> *const c_char;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_preferences_page_get_description_centered(
self_: *mut AdwPreferencesPage,
) -> gboolean;
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,
);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_preferences_page_scroll_to_top(self_: *mut AdwPreferencesPage);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_preferences_page_set_banner(self_: *mut AdwPreferencesPage, banner: *mut AdwBanner);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_preferences_page_set_description(
self_: *mut AdwPreferencesPage,
description: *const c_char,
);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_preferences_page_set_description_centered(
self_: *mut AdwPreferencesPage,
centered: gboolean,
);
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(feature = "v1_1")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
pub fn adw_preferences_row_get_title_selectable(self_: *mut AdwPreferencesRow) -> gboolean;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, 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(feature = "v1_1")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
pub fn adw_preferences_row_set_title_selectable(
self_: *mut AdwPreferencesRow,
title_selectable: gboolean,
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, 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;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_preferences_window_pop_subpage(self_: *mut AdwPreferencesWindow) -> gboolean;
pub fn adw_preferences_window_present_subpage(
self_: *mut AdwPreferencesWindow,
subpage: *mut gtk::GtkWidget,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_preferences_window_push_subpage(
self_: *mut AdwPreferencesWindow,
page: *mut AdwNavigationPage,
);
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(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_property_animation_target_get_type() -> GType;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_property_animation_target_new(
object: *mut gobject::GObject,
property_name: *const c_char,
) -> *mut AdwAnimationTarget;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, 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(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_property_animation_target_get_object(
self_: *mut AdwPropertyAnimationTarget,
) -> *mut gobject::GObject;
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_property_animation_target_get_pspec(
self_: *mut AdwPropertyAnimationTarget,
) -> *mut gobject::GParamSpec;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_new(
adjustment: *mut gtk::GtkAdjustment,
climb_rate: c_double,
digits: c_uint,
) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_new_with_range(
min: c_double,
max: c_double,
step: c_double,
) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_configure(
self_: *mut AdwSpinRow,
adjustment: *mut gtk::GtkAdjustment,
climb_rate: c_double,
digits: c_uint,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_get_adjustment(self_: *mut AdwSpinRow) -> *mut gtk::GtkAdjustment;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_get_climb_rate(self_: *mut AdwSpinRow) -> c_double;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_get_digits(self_: *mut AdwSpinRow) -> c_uint;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_get_numeric(self_: *mut AdwSpinRow) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_get_snap_to_ticks(self_: *mut AdwSpinRow) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_get_update_policy(self_: *mut AdwSpinRow)
-> gtk::GtkSpinButtonUpdatePolicy;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_get_value(self_: *mut AdwSpinRow) -> c_double;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_get_wrap(self_: *mut AdwSpinRow) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_set_adjustment(self_: *mut AdwSpinRow, adjustment: *mut gtk::GtkAdjustment);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_set_climb_rate(self_: *mut AdwSpinRow, climb_rate: c_double);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_set_digits(self_: *mut AdwSpinRow, digits: c_uint);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_set_numeric(self_: *mut AdwSpinRow, numeric: gboolean);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_set_range(self_: *mut AdwSpinRow, min: c_double, max: c_double);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_set_snap_to_ticks(self_: *mut AdwSpinRow, snap_to_ticks: gboolean);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_set_update_policy(
self_: *mut AdwSpinRow,
policy: gtk::GtkSpinButtonUpdatePolicy,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_set_value(self_: *mut AdwSpinRow, value: c_double);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_set_wrap(self_: *mut AdwSpinRow, wrap: gboolean);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_spin_row_update(self_: *mut AdwSpinRow);
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_spinner_get_type() -> GType;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_spinner_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_spinner_paintable_get_type() -> GType;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_spinner_paintable_new(widget: *mut gtk::GtkWidget) -> *mut AdwSpinnerPaintable;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_spinner_paintable_get_widget(self_: *mut AdwSpinnerPaintable)
-> *mut gtk::GtkWidget;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_spinner_paintable_set_widget(
self_: *mut AdwSpinnerPaintable,
widget: *mut gtk::GtkWidget,
);
pub fn adw_split_button_get_type() -> GType;
pub fn adw_split_button_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_split_button_get_can_shrink(self_: *mut AdwSplitButton) -> gboolean;
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(feature = "v1_2")]
#[cfg_attr(docsrs, 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);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_split_button_set_can_shrink(self_: *mut AdwSplitButton, can_shrink: gboolean);
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(feature = "v1_2")]
#[cfg_attr(docsrs, 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;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_spring_animation_calculate_value(
self_: *mut AdwSpringAnimation,
time: c_uint,
) -> c_double;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_spring_animation_calculate_velocity(
self_: *mut AdwSpringAnimation,
time: c_uint,
) -> c_double;
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;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_style_manager_get_accent_color(self_: *mut AdwStyleManager) -> AdwAccentColor;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_style_manager_get_accent_color_rgba(
self_: *mut AdwStyleManager,
) -> *mut gdk::GdkRGBA;
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;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_style_manager_get_system_supports_accent_colors(
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;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_swipe_tracker_get_allow_window_handle(self_: *mut AdwSwipeTracker) -> gboolean;
pub fn adw_swipe_tracker_get_enabled(self_: *mut AdwSwipeTracker) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_swipe_tracker_get_lower_overshoot(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;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_swipe_tracker_get_upper_overshoot(self_: *mut AdwSwipeTracker) -> gboolean;
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,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_swipe_tracker_set_allow_window_handle(
self_: *mut AdwSwipeTracker,
allow_window_handle: gboolean,
);
pub fn adw_swipe_tracker_set_enabled(self_: *mut AdwSwipeTracker, enabled: gboolean);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_swipe_tracker_set_lower_overshoot(self_: *mut AdwSwipeTracker, overshoot: gboolean);
pub fn adw_swipe_tracker_set_reversed(self_: *mut AdwSwipeTracker, reversed: gboolean);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_swipe_tracker_set_upper_overshoot(self_: *mut AdwSwipeTracker, overshoot: gboolean);
pub fn adw_swipe_tracker_shift_position(self_: *mut AdwSwipeTracker, delta: c_double);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_switch_row_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_switch_row_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_switch_row_get_active(self_: *mut AdwSwitchRow) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_switch_row_set_active(self_: *mut AdwSwitchRow, is_active: gboolean);
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;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_tab_bar_get_extra_drag_preferred_action(self_: *mut AdwTabBar)
-> gdk::GdkDragAction;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_bar_get_extra_drag_preload(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);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_bar_set_extra_drag_preload(self_: *mut AdwTabBar, preload: 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(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_button_get_type() -> GType;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_button_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_button_get_view(self_: *mut AdwTabButton) -> *mut AdwTabView;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_button_set_view(self_: *mut AdwTabButton, view: *mut AdwTabView);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_type() -> GType;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_child(self_: *mut AdwTabOverview) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_enable_new_tab(self_: *mut AdwTabOverview) -> gboolean;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_enable_search(self_: *mut AdwTabOverview) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_tab_overview_get_extra_drag_preferred_action(
self_: *mut AdwTabOverview,
) -> gdk::GdkDragAction;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_extra_drag_preload(self_: *mut AdwTabOverview) -> gboolean;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_inverted(self_: *mut AdwTabOverview) -> gboolean;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_open(self_: *mut AdwTabOverview) -> gboolean;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_search_active(self_: *mut AdwTabOverview) -> gboolean;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_secondary_menu(self_: *mut AdwTabOverview) -> *mut gio::GMenuModel;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_show_end_title_buttons(self_: *mut AdwTabOverview) -> gboolean;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_show_start_title_buttons(self_: *mut AdwTabOverview) -> gboolean;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_get_view(self_: *mut AdwTabOverview) -> *mut AdwTabView;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_child(self_: *mut AdwTabOverview, child: *mut gtk::GtkWidget);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_enable_new_tab(
self_: *mut AdwTabOverview,
enable_new_tab: gboolean,
);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_enable_search(self_: *mut AdwTabOverview, enable_search: gboolean);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_extra_drag_preload(self_: *mut AdwTabOverview, preload: gboolean);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_inverted(self_: *mut AdwTabOverview, inverted: gboolean);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_open(self_: *mut AdwTabOverview, open: gboolean);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_secondary_menu(
self_: *mut AdwTabOverview,
secondary_menu: *mut gio::GMenuModel,
);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_show_end_title_buttons(
self_: *mut AdwTabOverview,
show_end_title_buttons: gboolean,
);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_show_start_title_buttons(
self_: *mut AdwTabOverview,
show_start_title_buttons: gboolean,
);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_overview_set_view(self_: *mut AdwTabOverview, view: *mut AdwTabView);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, 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(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_tab_page_get_indicator_tooltip(self_: *mut AdwTabPage) -> *const c_char;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_page_get_keyword(self_: *mut AdwTabPage) -> *const c_char;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, 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(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_page_get_thumbnail_xalign(self_: *mut AdwTabPage) -> c_float;
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, 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(feature = "v1_3")]
#[cfg_attr(docsrs, 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(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_tab_page_set_indicator_tooltip(self_: *mut AdwTabPage, tooltip: *const c_char);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_page_set_keyword(self_: *mut AdwTabPage, keyword: *const c_char);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, 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(feature = "v1_3")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
pub fn adw_tab_page_set_thumbnail_xalign(self_: *mut AdwTabPage, xalign: c_float);
#[cfg(feature = "v1_3")]
#[cfg_attr(docsrs, 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(feature = "v1_2")]
#[cfg_attr(docsrs, 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(feature = "v1_2")]
#[cfg_attr(docsrs, 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(feature = "v1_3")]
#[cfg_attr(docsrs, 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(feature = "v1_2")]
#[cfg_attr(docsrs, 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(feature = "v1_2")]
#[cfg_attr(docsrs, 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(feature = "v1_2")]
#[cfg_attr(docsrs, 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(feature = "v1_2")]
#[cfg_attr(docsrs, 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;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toast_get_use_markup(self_: *mut AdwToast) -> gboolean;
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(feature = "v1_2")]
#[cfg_attr(docsrs, 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);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toast_set_use_markup(self_: *mut AdwToast, use_markup: gboolean);
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);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_get_type() -> GType;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_new() -> *mut AdwToggle;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_get_child(self_: *mut AdwToggle) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_get_enabled(self_: *mut AdwToggle) -> gboolean;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_get_icon_name(self_: *mut AdwToggle) -> *const c_char;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_get_index(self_: *mut AdwToggle) -> c_uint;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_get_label(self_: *mut AdwToggle) -> *const c_char;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_get_name(self_: *mut AdwToggle) -> *const c_char;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_get_tooltip(self_: *mut AdwToggle) -> *const c_char;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_get_use_underline(self_: *mut AdwToggle) -> gboolean;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_set_child(self_: *mut AdwToggle, child: *mut gtk::GtkWidget);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_set_enabled(self_: *mut AdwToggle, enabled: gboolean);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_set_icon_name(self_: *mut AdwToggle, icon_name: *const c_char);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_set_label(self_: *mut AdwToggle, label: *const c_char);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_set_name(self_: *mut AdwToggle, name: *const c_char);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_set_tooltip(self_: *mut AdwToggle, tooltip: *const c_char);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_set_use_underline(self_: *mut AdwToggle, use_underline: gboolean);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_get_type() -> GType;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_add(self_: *mut AdwToggleGroup, toggle: *mut AdwToggle);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_get_active(self_: *mut AdwToggleGroup) -> c_uint;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_get_active_name(self_: *mut AdwToggleGroup) -> *const c_char;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_get_can_shrink(self_: *mut AdwToggleGroup) -> gboolean;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_get_homogeneous(self_: *mut AdwToggleGroup) -> gboolean;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_get_n_toggles(self_: *mut AdwToggleGroup) -> c_uint;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_get_toggle(self_: *mut AdwToggleGroup, index: c_uint)
-> *mut AdwToggle;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_get_toggle_by_name(
self_: *mut AdwToggleGroup,
name: *const c_char,
) -> *mut AdwToggle;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_get_toggles(self_: *mut AdwToggleGroup) -> *mut gtk::GtkSelectionModel;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_remove(self_: *mut AdwToggleGroup, toggle: *mut AdwToggle);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_remove_all(self_: *mut AdwToggleGroup);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_set_active(self_: *mut AdwToggleGroup, active: c_uint);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_set_active_name(self_: *mut AdwToggleGroup, name: *const c_char);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_set_can_shrink(self_: *mut AdwToggleGroup, can_shrink: gboolean);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_toggle_group_set_homogeneous(self_: *mut AdwToggleGroup, homogeneous: gboolean);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_add_bottom_bar(self_: *mut AdwToolbarView, widget: *mut gtk::GtkWidget);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_add_top_bar(self_: *mut AdwToolbarView, widget: *mut gtk::GtkWidget);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_get_bottom_bar_height(self_: *mut AdwToolbarView) -> c_int;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_get_bottom_bar_style(self_: *mut AdwToolbarView) -> AdwToolbarStyle;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_get_content(self_: *mut AdwToolbarView) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_get_extend_content_to_bottom_edge(
self_: *mut AdwToolbarView,
) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_get_extend_content_to_top_edge(self_: *mut AdwToolbarView) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_get_reveal_bottom_bars(self_: *mut AdwToolbarView) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_get_reveal_top_bars(self_: *mut AdwToolbarView) -> gboolean;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_get_top_bar_height(self_: *mut AdwToolbarView) -> c_int;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_get_top_bar_style(self_: *mut AdwToolbarView) -> AdwToolbarStyle;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_remove(self_: *mut AdwToolbarView, widget: *mut gtk::GtkWidget);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_set_bottom_bar_style(
self_: *mut AdwToolbarView,
style: AdwToolbarStyle,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_set_content(self_: *mut AdwToolbarView, content: *mut gtk::GtkWidget);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_set_extend_content_to_bottom_edge(
self_: *mut AdwToolbarView,
extend: gboolean,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_set_extend_content_to_top_edge(
self_: *mut AdwToolbarView,
extend: gboolean,
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_set_reveal_bottom_bars(self_: *mut AdwToolbarView, reveal: gboolean);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_set_reveal_top_bars(self_: *mut AdwToolbarView, reveal: gboolean);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_toolbar_view_set_top_bar_style(self_: *mut AdwToolbarView, style: AdwToolbarStyle);
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(feature = "v1_2")]
#[cfg_attr(docsrs, 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;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_view_stack_get_enable_transitions(self_: *mut AdwViewStack) -> gboolean;
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;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_view_stack_get_transition_duration(self_: *mut AdwViewStack) -> c_uint;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_view_stack_get_transition_running(self_: *mut AdwViewStack) -> gboolean;
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);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_view_stack_set_enable_transitions(
self_: *mut AdwViewStack,
enable_transitions: gboolean,
);
pub fn adw_view_stack_set_hhomogeneous(self_: *mut AdwViewStack, hhomogeneous: gboolean);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_view_stack_set_transition_duration(self_: *mut AdwViewStack, duration: c_uint);
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);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_view_stack_pages_get_type() -> GType;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_view_stack_pages_get_selected_page(
self_: *mut AdwViewStackPages,
) -> *mut AdwViewStackPage;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_view_stack_pages_set_selected_page(
self_: *mut AdwViewStackPages,
page: *mut AdwViewStackPage,
);
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;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_window_add_breakpoint(self_: *mut AdwWindow, breakpoint: *mut AdwBreakpoint);
pub fn adw_window_get_content(self_: *mut AdwWindow) -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_window_get_current_breakpoint(self_: *mut AdwWindow) -> *mut AdwBreakpoint;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_window_get_dialogs(self_: *mut AdwWindow) -> *mut gio::GListModel;
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_window_get_visible_dialog(self_: *mut AdwWindow) -> *mut AdwDialog;
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);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_get_type() -> GType;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_new() -> *mut gtk::GtkWidget;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_append(self_: *mut AdwWrapBox, child: *mut gtk::GtkWidget);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_get_align(self_: *mut AdwWrapBox) -> c_float;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_get_child_spacing(self_: *mut AdwWrapBox) -> c_int;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_get_child_spacing_unit(self_: *mut AdwWrapBox) -> AdwLengthUnit;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_get_justify(self_: *mut AdwWrapBox) -> AdwJustifyMode;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_get_justify_last_line(self_: *mut AdwWrapBox) -> gboolean;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_get_line_homogeneous(self_: *mut AdwWrapBox) -> gboolean;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_get_line_spacing(self_: *mut AdwWrapBox) -> c_int;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_get_line_spacing_unit(self_: *mut AdwWrapBox) -> AdwLengthUnit;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_get_natural_line_length(self_: *mut AdwWrapBox) -> c_int;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_get_natural_line_length_unit(self_: *mut AdwWrapBox) -> AdwLengthUnit;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_get_pack_direction(self_: *mut AdwWrapBox) -> AdwPackDirection;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_get_wrap_policy(self_: *mut AdwWrapBox) -> AdwWrapPolicy;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_get_wrap_reverse(self_: *mut AdwWrapBox) -> gboolean;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_insert_child_after(
self_: *mut AdwWrapBox,
child: *mut gtk::GtkWidget,
sibling: *mut gtk::GtkWidget,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_prepend(self_: *mut AdwWrapBox, child: *mut gtk::GtkWidget);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_remove(self_: *mut AdwWrapBox, child: *mut gtk::GtkWidget);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_reorder_child_after(
self_: *mut AdwWrapBox,
child: *mut gtk::GtkWidget,
sibling: *mut gtk::GtkWidget,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_set_align(self_: *mut AdwWrapBox, align: c_float);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_set_child_spacing(self_: *mut AdwWrapBox, child_spacing: c_int);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_set_child_spacing_unit(self_: *mut AdwWrapBox, unit: AdwLengthUnit);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_set_justify(self_: *mut AdwWrapBox, justify: AdwJustifyMode);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_set_justify_last_line(self_: *mut AdwWrapBox, justify_last_line: gboolean);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_set_line_homogeneous(self_: *mut AdwWrapBox, homogeneous: gboolean);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_set_line_spacing(self_: *mut AdwWrapBox, line_spacing: c_int);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_set_line_spacing_unit(self_: *mut AdwWrapBox, unit: AdwLengthUnit);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_set_natural_line_length(self_: *mut AdwWrapBox, natural_line_length: c_int);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_set_natural_line_length_unit(self_: *mut AdwWrapBox, unit: AdwLengthUnit);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_set_pack_direction(
self_: *mut AdwWrapBox,
pack_direction: AdwPackDirection,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_set_wrap_policy(self_: *mut AdwWrapBox, wrap_policy: AdwWrapPolicy);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_box_set_wrap_reverse(self_: *mut AdwWrapBox, wrap_reverse: gboolean);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_get_type() -> GType;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_new() -> *mut gtk::GtkLayoutManager;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_get_align(self_: *mut AdwWrapLayout) -> c_float;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_get_child_spacing(self_: *mut AdwWrapLayout) -> c_int;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_get_child_spacing_unit(self_: *mut AdwWrapLayout) -> AdwLengthUnit;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_get_justify(self_: *mut AdwWrapLayout) -> AdwJustifyMode;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_get_justify_last_line(self_: *mut AdwWrapLayout) -> gboolean;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_get_line_homogeneous(self_: *mut AdwWrapLayout) -> gboolean;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_get_line_spacing(self_: *mut AdwWrapLayout) -> c_int;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_get_line_spacing_unit(self_: *mut AdwWrapLayout) -> AdwLengthUnit;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_get_natural_line_length(self_: *mut AdwWrapLayout) -> c_int;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_get_natural_line_length_unit(self_: *mut AdwWrapLayout)
-> AdwLengthUnit;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_get_pack_direction(self_: *mut AdwWrapLayout) -> AdwPackDirection;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_get_wrap_policy(self_: *mut AdwWrapLayout) -> AdwWrapPolicy;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_get_wrap_reverse(self_: *mut AdwWrapLayout) -> gboolean;
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_set_align(self_: *mut AdwWrapLayout, align: c_float);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_set_child_spacing(self_: *mut AdwWrapLayout, child_spacing: c_int);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_set_child_spacing_unit(self_: *mut AdwWrapLayout, unit: AdwLengthUnit);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_set_justify(self_: *mut AdwWrapLayout, justify: AdwJustifyMode);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_set_justify_last_line(
self_: *mut AdwWrapLayout,
justify_last_line: gboolean,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_set_line_homogeneous(self_: *mut AdwWrapLayout, homogeneous: gboolean);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_set_line_spacing(self_: *mut AdwWrapLayout, line_spacing: c_int);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_set_line_spacing_unit(self_: *mut AdwWrapLayout, unit: AdwLengthUnit);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_set_natural_line_length(
self_: *mut AdwWrapLayout,
natural_line_length: c_int,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_set_natural_line_length_unit(
self_: *mut AdwWrapLayout,
unit: AdwLengthUnit,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_set_pack_direction(
self_: *mut AdwWrapLayout,
pack_direction: AdwPackDirection,
);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_set_wrap_policy(self_: *mut AdwWrapLayout, wrap_policy: AdwWrapPolicy);
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
pub fn adw_wrap_layout_set_wrap_reverse(self_: *mut AdwWrapLayout, wrap_reverse: gboolean);
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;
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
pub fn adw_rgba_to_standalone(
rgba: *const gdk::GdkRGBA,
dark: gboolean,
standalone_rgba: *mut gdk::GdkRGBA,
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_show_about_dialog(
parent: *mut gtk::GtkWidget,
first_property_name: *const c_char,
...
);
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
pub fn adw_show_about_dialog_from_appdata(
parent: *mut gtk::GtkWidget,
resource_path: *const c_char,
release_notes_version: *const c_char,
first_property_name: *const c_char,
...
);
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
pub fn adw_show_about_window(
parent: *mut gtk::GtkWindow,
first_property_name: *const c_char,
...
);
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
pub fn adw_show_about_window_from_appdata(
parent: *mut gtk::GtkWindow,
resource_path: *const c_char,
release_notes_version: *const c_char,
first_property_name: *const c_char,
...
);
}