libadwaita_sys/
lib.rs

1// Generated by gir (https://github.com/gtk-rs/gir @ 36917718ae60)
2// from
3// from gir-files (https://github.com/gtk-rs/gir-files.git @ 6cef10cd64df)
4// DO NOT EDIT
5
6#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(
8    clippy::approx_constant,
9    clippy::type_complexity,
10    clippy::unreadable_literal,
11    clippy::upper_case_acronyms
12)]
13#![cfg_attr(docsrs, feature(doc_cfg))]
14
15use gdk_sys as gdk;
16use gio_sys as gio;
17use glib_sys as glib;
18use gobject_sys as gobject;
19use gtk_sys as gtk;
20use pango_sys as pango;
21
22#[allow(unused_imports)]
23use libc::{FILE, intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t};
24#[cfg(unix)]
25#[allow(unused_imports)]
26use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
27#[allow(unused_imports)]
28use std::ffi::{
29    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
30};
31
32#[allow(unused_imports)]
33use glib::{GType, gboolean, gconstpointer, gpointer};
34
35// Enums
36pub type AdwAccentColor = c_int;
37pub const ADW_ACCENT_COLOR_BLUE: AdwAccentColor = 0;
38pub const ADW_ACCENT_COLOR_TEAL: AdwAccentColor = 1;
39pub const ADW_ACCENT_COLOR_GREEN: AdwAccentColor = 2;
40pub const ADW_ACCENT_COLOR_YELLOW: AdwAccentColor = 3;
41pub const ADW_ACCENT_COLOR_ORANGE: AdwAccentColor = 4;
42pub const ADW_ACCENT_COLOR_RED: AdwAccentColor = 5;
43pub const ADW_ACCENT_COLOR_PINK: AdwAccentColor = 6;
44pub const ADW_ACCENT_COLOR_PURPLE: AdwAccentColor = 7;
45pub const ADW_ACCENT_COLOR_SLATE: AdwAccentColor = 8;
46
47pub type AdwAnimationState = c_int;
48pub const ADW_ANIMATION_IDLE: AdwAnimationState = 0;
49pub const ADW_ANIMATION_PAUSED: AdwAnimationState = 1;
50pub const ADW_ANIMATION_PLAYING: AdwAnimationState = 2;
51pub const ADW_ANIMATION_FINISHED: AdwAnimationState = 3;
52
53pub type AdwBannerButtonStyle = c_int;
54pub const ADW_BANNER_BUTTON_DEFAULT: AdwBannerButtonStyle = 0;
55pub const ADW_BANNER_BUTTON_SUGGESTED: AdwBannerButtonStyle = 1;
56
57pub type AdwBreakpointConditionLengthType = c_int;
58pub const ADW_BREAKPOINT_CONDITION_MIN_WIDTH: AdwBreakpointConditionLengthType = 0;
59pub const ADW_BREAKPOINT_CONDITION_MAX_WIDTH: AdwBreakpointConditionLengthType = 1;
60pub const ADW_BREAKPOINT_CONDITION_MIN_HEIGHT: AdwBreakpointConditionLengthType = 2;
61pub const ADW_BREAKPOINT_CONDITION_MAX_HEIGHT: AdwBreakpointConditionLengthType = 3;
62
63pub type AdwBreakpointConditionRatioType = c_int;
64pub const ADW_BREAKPOINT_CONDITION_MIN_ASPECT_RATIO: AdwBreakpointConditionRatioType = 0;
65pub const ADW_BREAKPOINT_CONDITION_MAX_ASPECT_RATIO: AdwBreakpointConditionRatioType = 1;
66
67pub type AdwCenteringPolicy = c_int;
68pub const ADW_CENTERING_POLICY_LOOSE: AdwCenteringPolicy = 0;
69pub const ADW_CENTERING_POLICY_STRICT: AdwCenteringPolicy = 1;
70
71pub type AdwColorScheme = c_int;
72pub const ADW_COLOR_SCHEME_DEFAULT: AdwColorScheme = 0;
73pub const ADW_COLOR_SCHEME_FORCE_LIGHT: AdwColorScheme = 1;
74pub const ADW_COLOR_SCHEME_PREFER_LIGHT: AdwColorScheme = 2;
75pub const ADW_COLOR_SCHEME_PREFER_DARK: AdwColorScheme = 3;
76pub const ADW_COLOR_SCHEME_FORCE_DARK: AdwColorScheme = 4;
77
78pub type AdwDialogPresentationMode = c_int;
79pub const ADW_DIALOG_AUTO: AdwDialogPresentationMode = 0;
80pub const ADW_DIALOG_FLOATING: AdwDialogPresentationMode = 1;
81pub const ADW_DIALOG_BOTTOM_SHEET: AdwDialogPresentationMode = 2;
82
83pub type AdwEasing = c_int;
84pub const ADW_LINEAR: AdwEasing = 0;
85pub const ADW_EASE_IN_QUAD: AdwEasing = 1;
86pub const ADW_EASE_OUT_QUAD: AdwEasing = 2;
87pub const ADW_EASE_IN_OUT_QUAD: AdwEasing = 3;
88pub const ADW_EASE_IN_CUBIC: AdwEasing = 4;
89pub const ADW_EASE_OUT_CUBIC: AdwEasing = 5;
90pub const ADW_EASE_IN_OUT_CUBIC: AdwEasing = 6;
91pub const ADW_EASE_IN_QUART: AdwEasing = 7;
92pub const ADW_EASE_OUT_QUART: AdwEasing = 8;
93pub const ADW_EASE_IN_OUT_QUART: AdwEasing = 9;
94pub const ADW_EASE_IN_QUINT: AdwEasing = 10;
95pub const ADW_EASE_OUT_QUINT: AdwEasing = 11;
96pub const ADW_EASE_IN_OUT_QUINT: AdwEasing = 12;
97pub const ADW_EASE_IN_SINE: AdwEasing = 13;
98pub const ADW_EASE_OUT_SINE: AdwEasing = 14;
99pub const ADW_EASE_IN_OUT_SINE: AdwEasing = 15;
100pub const ADW_EASE_IN_EXPO: AdwEasing = 16;
101pub const ADW_EASE_OUT_EXPO: AdwEasing = 17;
102pub const ADW_EASE_IN_OUT_EXPO: AdwEasing = 18;
103pub const ADW_EASE_IN_CIRC: AdwEasing = 19;
104pub const ADW_EASE_OUT_CIRC: AdwEasing = 20;
105pub const ADW_EASE_IN_OUT_CIRC: AdwEasing = 21;
106pub const ADW_EASE_IN_ELASTIC: AdwEasing = 22;
107pub const ADW_EASE_OUT_ELASTIC: AdwEasing = 23;
108pub const ADW_EASE_IN_OUT_ELASTIC: AdwEasing = 24;
109pub const ADW_EASE_IN_BACK: AdwEasing = 25;
110pub const ADW_EASE_OUT_BACK: AdwEasing = 26;
111pub const ADW_EASE_IN_OUT_BACK: AdwEasing = 27;
112pub const ADW_EASE_IN_BOUNCE: AdwEasing = 28;
113pub const ADW_EASE_OUT_BOUNCE: AdwEasing = 29;
114pub const ADW_EASE_IN_OUT_BOUNCE: AdwEasing = 30;
115#[cfg(feature = "v1_7")]
116#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
117pub const ADW_EASE: AdwEasing = 31;
118#[cfg(feature = "v1_7")]
119#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
120pub const ADW_EASE_IN: AdwEasing = 32;
121#[cfg(feature = "v1_7")]
122#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
123pub const ADW_EASE_OUT: AdwEasing = 33;
124#[cfg(feature = "v1_7")]
125#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
126pub const ADW_EASE_IN_OUT: AdwEasing = 34;
127
128pub type AdwFlapFoldPolicy = c_int;
129pub const ADW_FLAP_FOLD_POLICY_NEVER: AdwFlapFoldPolicy = 0;
130pub const ADW_FLAP_FOLD_POLICY_ALWAYS: AdwFlapFoldPolicy = 1;
131pub const ADW_FLAP_FOLD_POLICY_AUTO: AdwFlapFoldPolicy = 2;
132
133pub type AdwFlapTransitionType = c_int;
134pub const ADW_FLAP_TRANSITION_TYPE_OVER: AdwFlapTransitionType = 0;
135pub const ADW_FLAP_TRANSITION_TYPE_UNDER: AdwFlapTransitionType = 1;
136pub const ADW_FLAP_TRANSITION_TYPE_SLIDE: AdwFlapTransitionType = 2;
137
138pub type AdwFoldThresholdPolicy = c_int;
139pub const ADW_FOLD_THRESHOLD_POLICY_MINIMUM: AdwFoldThresholdPolicy = 0;
140pub const ADW_FOLD_THRESHOLD_POLICY_NATURAL: AdwFoldThresholdPolicy = 1;
141
142pub type AdwInlineViewSwitcherDisplayMode = c_int;
143pub const ADW_INLINE_VIEW_SWITCHER_LABELS: AdwInlineViewSwitcherDisplayMode = 0;
144pub const ADW_INLINE_VIEW_SWITCHER_ICONS: AdwInlineViewSwitcherDisplayMode = 1;
145pub const ADW_INLINE_VIEW_SWITCHER_BOTH: AdwInlineViewSwitcherDisplayMode = 2;
146
147pub type AdwJustifyMode = c_int;
148pub const ADW_JUSTIFY_NONE: AdwJustifyMode = 0;
149pub const ADW_JUSTIFY_FILL: AdwJustifyMode = 1;
150pub const ADW_JUSTIFY_SPREAD: AdwJustifyMode = 2;
151
152pub type AdwLeafletTransitionType = c_int;
153pub const ADW_LEAFLET_TRANSITION_TYPE_OVER: AdwLeafletTransitionType = 0;
154pub const ADW_LEAFLET_TRANSITION_TYPE_UNDER: AdwLeafletTransitionType = 1;
155pub const ADW_LEAFLET_TRANSITION_TYPE_SLIDE: AdwLeafletTransitionType = 2;
156
157pub type AdwLengthUnit = c_int;
158pub const ADW_LENGTH_UNIT_PX: AdwLengthUnit = 0;
159pub const ADW_LENGTH_UNIT_PT: AdwLengthUnit = 1;
160pub const ADW_LENGTH_UNIT_SP: AdwLengthUnit = 2;
161
162pub type AdwNavigationDirection = c_int;
163pub const ADW_NAVIGATION_DIRECTION_BACK: AdwNavigationDirection = 0;
164pub const ADW_NAVIGATION_DIRECTION_FORWARD: AdwNavigationDirection = 1;
165
166pub type AdwPackDirection = c_int;
167pub const ADW_PACK_START_TO_END: AdwPackDirection = 0;
168pub const ADW_PACK_END_TO_START: AdwPackDirection = 1;
169
170pub type AdwResponseAppearance = c_int;
171pub const ADW_RESPONSE_DEFAULT: AdwResponseAppearance = 0;
172pub const ADW_RESPONSE_SUGGESTED: AdwResponseAppearance = 1;
173pub const ADW_RESPONSE_DESTRUCTIVE: AdwResponseAppearance = 2;
174
175pub type AdwSidebarMode = c_int;
176pub const ADW_SIDEBAR_MODE_SIDEBAR: AdwSidebarMode = 0;
177pub const ADW_SIDEBAR_MODE_PAGE: AdwSidebarMode = 1;
178
179pub type AdwSqueezerTransitionType = c_int;
180pub const ADW_SQUEEZER_TRANSITION_TYPE_NONE: AdwSqueezerTransitionType = 0;
181pub const ADW_SQUEEZER_TRANSITION_TYPE_CROSSFADE: AdwSqueezerTransitionType = 1;
182
183pub type AdwToastPriority = c_int;
184pub const ADW_TOAST_PRIORITY_NORMAL: AdwToastPriority = 0;
185pub const ADW_TOAST_PRIORITY_HIGH: AdwToastPriority = 1;
186
187pub type AdwToolbarStyle = c_int;
188pub const ADW_TOOLBAR_FLAT: AdwToolbarStyle = 0;
189pub const ADW_TOOLBAR_RAISED: AdwToolbarStyle = 1;
190pub const ADW_TOOLBAR_RAISED_BORDER: AdwToolbarStyle = 2;
191
192pub type AdwViewSwitcherPolicy = c_int;
193pub const ADW_VIEW_SWITCHER_POLICY_NARROW: AdwViewSwitcherPolicy = 0;
194pub const ADW_VIEW_SWITCHER_POLICY_WIDE: AdwViewSwitcherPolicy = 1;
195
196pub type AdwWrapPolicy = c_int;
197pub const ADW_WRAP_MINIMUM: AdwWrapPolicy = 0;
198pub const ADW_WRAP_NATURAL: AdwWrapPolicy = 1;
199
200// Constants
201pub const ADW_DURATION_INFINITE: c_uint = 4294967295;
202
203// Flags
204pub type AdwTabViewShortcuts = c_uint;
205pub const ADW_TAB_VIEW_SHORTCUT_NONE: AdwTabViewShortcuts = 0;
206pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_TAB: AdwTabViewShortcuts = 1;
207pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_SHIFT_TAB: AdwTabViewShortcuts = 2;
208pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_PAGE_UP: AdwTabViewShortcuts = 4;
209pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_PAGE_DOWN: AdwTabViewShortcuts = 8;
210pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_HOME: AdwTabViewShortcuts = 16;
211pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_END: AdwTabViewShortcuts = 32;
212pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_SHIFT_PAGE_UP: AdwTabViewShortcuts = 64;
213pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_SHIFT_PAGE_DOWN: AdwTabViewShortcuts = 128;
214pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_SHIFT_HOME: AdwTabViewShortcuts = 256;
215pub const ADW_TAB_VIEW_SHORTCUT_CONTROL_SHIFT_END: AdwTabViewShortcuts = 512;
216pub const ADW_TAB_VIEW_SHORTCUT_ALT_DIGITS: AdwTabViewShortcuts = 1024;
217pub const ADW_TAB_VIEW_SHORTCUT_ALT_ZERO: AdwTabViewShortcuts = 2048;
218pub const ADW_TAB_VIEW_SHORTCUT_ALL_SHORTCUTS: AdwTabViewShortcuts = 4095;
219
220// Callbacks
221pub type AdwAnimationTargetFunc = Option<unsafe extern "C" fn(c_double, gpointer)>;
222pub type AdwSidebarSectionCreateItemFunc =
223    Option<unsafe extern "C" fn(*mut gobject::GObject, gpointer) -> *mut AdwSidebarItem>;
224
225// Records
226#[derive(Copy, Clone)]
227#[repr(C)]
228pub struct AdwAboutDialogClass {
229    pub parent_class: AdwDialogClass,
230}
231
232impl ::std::fmt::Debug for AdwAboutDialogClass {
233    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
234        f.debug_struct(&format!("AdwAboutDialogClass @ {self:p}"))
235            .field("parent_class", &self.parent_class)
236            .finish()
237    }
238}
239
240#[derive(Copy, Clone)]
241#[repr(C)]
242pub struct AdwAboutWindowClass {
243    pub parent_class: AdwWindowClass,
244}
245
246impl ::std::fmt::Debug for AdwAboutWindowClass {
247    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
248        f.debug_struct(&format!("AdwAboutWindowClass @ {self:p}"))
249            .field("parent_class", &self.parent_class)
250            .finish()
251    }
252}
253
254#[derive(Copy, Clone)]
255#[repr(C)]
256pub struct AdwActionRowClass {
257    pub parent_class: AdwPreferencesRowClass,
258    pub activate: Option<unsafe extern "C" fn(*mut AdwActionRow)>,
259    pub padding: [gpointer; 4],
260}
261
262impl ::std::fmt::Debug for AdwActionRowClass {
263    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
264        f.debug_struct(&format!("AdwActionRowClass @ {self:p}"))
265            .field("parent_class", &self.parent_class)
266            .field("activate", &self.activate)
267            .finish()
268    }
269}
270
271#[derive(Copy, Clone)]
272#[repr(C)]
273pub struct AdwAlertDialogClass {
274    pub parent_class: AdwDialogClass,
275    pub response: Option<unsafe extern "C" fn(*mut AdwAlertDialog, *const c_char)>,
276    pub padding: [gpointer; 4],
277}
278
279impl ::std::fmt::Debug for AdwAlertDialogClass {
280    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
281        f.debug_struct(&format!("AdwAlertDialogClass @ {self:p}"))
282            .field("parent_class", &self.parent_class)
283            .field("response", &self.response)
284            .finish()
285    }
286}
287
288#[repr(C)]
289#[allow(dead_code)]
290pub struct _AdwAnimationClass {
291    _data: [u8; 0],
292    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
293}
294
295pub type AdwAnimationClass = _AdwAnimationClass;
296
297#[repr(C)]
298#[allow(dead_code)]
299pub struct _AdwAnimationTargetClass {
300    _data: [u8; 0],
301    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
302}
303
304pub type AdwAnimationTargetClass = _AdwAnimationTargetClass;
305
306#[derive(Copy, Clone)]
307#[repr(C)]
308pub struct AdwApplicationClass {
309    pub parent_class: gtk::GtkApplicationClass,
310    pub padding: [gpointer; 4],
311}
312
313impl ::std::fmt::Debug for AdwApplicationClass {
314    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
315        f.debug_struct(&format!("AdwApplicationClass @ {self:p}"))
316            .field("parent_class", &self.parent_class)
317            .finish()
318    }
319}
320
321#[derive(Copy, Clone)]
322#[repr(C)]
323pub struct AdwApplicationWindowClass {
324    pub parent_class: gtk::GtkApplicationWindowClass,
325    pub padding: [gpointer; 4],
326}
327
328impl ::std::fmt::Debug for AdwApplicationWindowClass {
329    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
330        f.debug_struct(&format!("AdwApplicationWindowClass @ {self:p}"))
331            .field("parent_class", &self.parent_class)
332            .finish()
333    }
334}
335
336#[derive(Copy, Clone)]
337#[repr(C)]
338pub struct AdwAvatarClass {
339    pub parent_class: gtk::GtkWidgetClass,
340}
341
342impl ::std::fmt::Debug for AdwAvatarClass {
343    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
344        f.debug_struct(&format!("AdwAvatarClass @ {self:p}"))
345            .field("parent_class", &self.parent_class)
346            .finish()
347    }
348}
349
350#[derive(Copy, Clone)]
351#[repr(C)]
352pub struct AdwBannerClass {
353    pub parent_class: gtk::GtkWidgetClass,
354}
355
356impl ::std::fmt::Debug for AdwBannerClass {
357    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
358        f.debug_struct(&format!("AdwBannerClass @ {self:p}"))
359            .field("parent_class", &self.parent_class)
360            .finish()
361    }
362}
363
364#[derive(Copy, Clone)]
365#[repr(C)]
366pub struct AdwBinClass {
367    pub parent_class: gtk::GtkWidgetClass,
368}
369
370impl ::std::fmt::Debug for AdwBinClass {
371    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
372        f.debug_struct(&format!("AdwBinClass @ {self:p}"))
373            .field("parent_class", &self.parent_class)
374            .finish()
375    }
376}
377
378#[derive(Copy, Clone)]
379#[repr(C)]
380pub struct AdwBottomSheetClass {
381    pub parent_class: gtk::GtkWidgetClass,
382}
383
384impl ::std::fmt::Debug for AdwBottomSheetClass {
385    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
386        f.debug_struct(&format!("AdwBottomSheetClass @ {self:p}"))
387            .field("parent_class", &self.parent_class)
388            .finish()
389    }
390}
391
392#[derive(Copy, Clone)]
393#[repr(C)]
394pub struct AdwBreakpointBinClass {
395    pub parent_class: gtk::GtkWidgetClass,
396    pub padding: [gpointer; 4],
397}
398
399impl ::std::fmt::Debug for AdwBreakpointBinClass {
400    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
401        f.debug_struct(&format!("AdwBreakpointBinClass @ {self:p}"))
402            .field("parent_class", &self.parent_class)
403            .finish()
404    }
405}
406
407#[derive(Copy, Clone)]
408#[repr(C)]
409pub struct AdwBreakpointClass {
410    pub parent_class: gobject::GObjectClass,
411}
412
413impl ::std::fmt::Debug for AdwBreakpointClass {
414    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
415        f.debug_struct(&format!("AdwBreakpointClass @ {self:p}"))
416            .field("parent_class", &self.parent_class)
417            .finish()
418    }
419}
420
421#[repr(C)]
422#[allow(dead_code)]
423pub struct AdwBreakpointCondition {
424    _data: [u8; 0],
425    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
426}
427
428impl ::std::fmt::Debug for AdwBreakpointCondition {
429    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
430        f.debug_struct(&format!("AdwBreakpointCondition @ {self:p}"))
431            .finish()
432    }
433}
434
435#[derive(Copy, Clone)]
436#[repr(C)]
437pub struct AdwButtonContentClass {
438    pub parent_class: gtk::GtkWidgetClass,
439}
440
441impl ::std::fmt::Debug for AdwButtonContentClass {
442    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
443        f.debug_struct(&format!("AdwButtonContentClass @ {self:p}"))
444            .field("parent_class", &self.parent_class)
445            .finish()
446    }
447}
448
449#[derive(Copy, Clone)]
450#[repr(C)]
451pub struct AdwButtonRowClass {
452    pub parent_class: AdwPreferencesRowClass,
453}
454
455impl ::std::fmt::Debug for AdwButtonRowClass {
456    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
457        f.debug_struct(&format!("AdwButtonRowClass @ {self:p}"))
458            .field("parent_class", &self.parent_class)
459            .finish()
460    }
461}
462
463#[repr(C)]
464#[allow(dead_code)]
465pub struct _AdwCallbackAnimationTargetClass {
466    _data: [u8; 0],
467    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
468}
469
470pub type AdwCallbackAnimationTargetClass = _AdwCallbackAnimationTargetClass;
471
472#[derive(Copy, Clone)]
473#[repr(C)]
474pub struct AdwCarouselClass {
475    pub parent_class: gtk::GtkWidgetClass,
476}
477
478impl ::std::fmt::Debug for AdwCarouselClass {
479    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
480        f.debug_struct(&format!("AdwCarouselClass @ {self:p}"))
481            .field("parent_class", &self.parent_class)
482            .finish()
483    }
484}
485
486#[derive(Copy, Clone)]
487#[repr(C)]
488pub struct AdwCarouselIndicatorDotsClass {
489    pub parent_class: gtk::GtkWidgetClass,
490}
491
492impl ::std::fmt::Debug for AdwCarouselIndicatorDotsClass {
493    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
494        f.debug_struct(&format!("AdwCarouselIndicatorDotsClass @ {self:p}"))
495            .field("parent_class", &self.parent_class)
496            .finish()
497    }
498}
499
500#[derive(Copy, Clone)]
501#[repr(C)]
502pub struct AdwCarouselIndicatorLinesClass {
503    pub parent_class: gtk::GtkWidgetClass,
504}
505
506impl ::std::fmt::Debug for AdwCarouselIndicatorLinesClass {
507    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
508        f.debug_struct(&format!("AdwCarouselIndicatorLinesClass @ {self:p}"))
509            .field("parent_class", &self.parent_class)
510            .finish()
511    }
512}
513
514#[derive(Copy, Clone)]
515#[repr(C)]
516pub struct AdwClampClass {
517    pub parent_class: gtk::GtkWidgetClass,
518}
519
520impl ::std::fmt::Debug for AdwClampClass {
521    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
522        f.debug_struct(&format!("AdwClampClass @ {self:p}"))
523            .field("parent_class", &self.parent_class)
524            .finish()
525    }
526}
527
528#[derive(Copy, Clone)]
529#[repr(C)]
530pub struct AdwClampLayoutClass {
531    pub parent_class: gtk::GtkLayoutManagerClass,
532}
533
534impl ::std::fmt::Debug for AdwClampLayoutClass {
535    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
536        f.debug_struct(&format!("AdwClampLayoutClass @ {self:p}"))
537            .field("parent_class", &self.parent_class)
538            .finish()
539    }
540}
541
542#[derive(Copy, Clone)]
543#[repr(C)]
544pub struct AdwClampScrollableClass {
545    pub parent_class: gtk::GtkWidgetClass,
546}
547
548impl ::std::fmt::Debug for AdwClampScrollableClass {
549    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
550        f.debug_struct(&format!("AdwClampScrollableClass @ {self:p}"))
551            .field("parent_class", &self.parent_class)
552            .finish()
553    }
554}
555
556#[derive(Copy, Clone)]
557#[repr(C)]
558pub struct AdwComboRowClass {
559    pub parent_class: AdwActionRowClass,
560    pub padding: [gpointer; 4],
561}
562
563impl ::std::fmt::Debug for AdwComboRowClass {
564    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
565        f.debug_struct(&format!("AdwComboRowClass @ {self:p}"))
566            .field("parent_class", &self.parent_class)
567            .finish()
568    }
569}
570
571#[derive(Copy, Clone)]
572#[repr(C)]
573pub struct AdwDialogClass {
574    pub parent_class: gtk::GtkWidgetClass,
575    pub close_attempt: Option<unsafe extern "C" fn(*mut AdwDialog)>,
576    pub closed: Option<unsafe extern "C" fn(*mut AdwDialog)>,
577    pub padding: [gpointer; 4],
578}
579
580impl ::std::fmt::Debug for AdwDialogClass {
581    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
582        f.debug_struct(&format!("AdwDialogClass @ {self:p}"))
583            .field("parent_class", &self.parent_class)
584            .field("close_attempt", &self.close_attempt)
585            .field("closed", &self.closed)
586            .finish()
587    }
588}
589
590#[derive(Copy, Clone)]
591#[repr(C)]
592pub struct AdwEntryRowClass {
593    pub parent_class: AdwPreferencesRowClass,
594}
595
596impl ::std::fmt::Debug for AdwEntryRowClass {
597    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
598        f.debug_struct(&format!("AdwEntryRowClass @ {self:p}"))
599            .field("parent_class", &self.parent_class)
600            .finish()
601    }
602}
603
604#[derive(Copy, Clone)]
605#[repr(C)]
606pub struct AdwEnumListItemClass {
607    pub parent_class: gobject::GObjectClass,
608}
609
610impl ::std::fmt::Debug for AdwEnumListItemClass {
611    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
612        f.debug_struct(&format!("AdwEnumListItemClass @ {self:p}"))
613            .field("parent_class", &self.parent_class)
614            .finish()
615    }
616}
617
618#[derive(Copy, Clone)]
619#[repr(C)]
620pub struct AdwEnumListModelClass {
621    pub parent_class: gobject::GObjectClass,
622}
623
624impl ::std::fmt::Debug for AdwEnumListModelClass {
625    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
626        f.debug_struct(&format!("AdwEnumListModelClass @ {self:p}"))
627            .field("parent_class", &self.parent_class)
628            .finish()
629    }
630}
631
632#[derive(Copy, Clone)]
633#[repr(C)]
634pub struct AdwExpanderRowClass {
635    pub parent_class: AdwPreferencesRowClass,
636    pub padding: [gpointer; 4],
637}
638
639impl ::std::fmt::Debug for AdwExpanderRowClass {
640    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
641        f.debug_struct(&format!("AdwExpanderRowClass @ {self:p}"))
642            .field("parent_class", &self.parent_class)
643            .finish()
644    }
645}
646
647#[derive(Copy, Clone)]
648#[repr(C)]
649pub struct AdwFlapClass {
650    pub parent_class: gtk::GtkWidgetClass,
651}
652
653impl ::std::fmt::Debug for AdwFlapClass {
654    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
655        f.debug_struct(&format!("AdwFlapClass @ {self:p}"))
656            .field("parent_class", &self.parent_class)
657            .finish()
658    }
659}
660
661#[derive(Copy, Clone)]
662#[repr(C)]
663pub struct AdwHeaderBarClass {
664    pub parent_class: gtk::GtkWidgetClass,
665}
666
667impl ::std::fmt::Debug for AdwHeaderBarClass {
668    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
669        f.debug_struct(&format!("AdwHeaderBarClass @ {self:p}"))
670            .field("parent_class", &self.parent_class)
671            .finish()
672    }
673}
674
675#[derive(Copy, Clone)]
676#[repr(C)]
677pub struct AdwInlineViewSwitcherClass {
678    pub parent_class: gtk::GtkWidgetClass,
679}
680
681impl ::std::fmt::Debug for AdwInlineViewSwitcherClass {
682    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
683        f.debug_struct(&format!("AdwInlineViewSwitcherClass @ {self:p}"))
684            .field("parent_class", &self.parent_class)
685            .finish()
686    }
687}
688
689#[derive(Copy, Clone)]
690#[repr(C)]
691pub struct AdwLayoutClass {
692    pub parent_class: gobject::GObjectClass,
693}
694
695impl ::std::fmt::Debug for AdwLayoutClass {
696    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
697        f.debug_struct(&format!("AdwLayoutClass @ {self:p}"))
698            .field("parent_class", &self.parent_class)
699            .finish()
700    }
701}
702
703#[derive(Copy, Clone)]
704#[repr(C)]
705pub struct AdwLayoutSlotClass {
706    pub parent_class: gtk::GtkWidgetClass,
707}
708
709impl ::std::fmt::Debug for AdwLayoutSlotClass {
710    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
711        f.debug_struct(&format!("AdwLayoutSlotClass @ {self:p}"))
712            .field("parent_class", &self.parent_class)
713            .finish()
714    }
715}
716
717#[derive(Copy, Clone)]
718#[repr(C)]
719pub struct AdwLeafletClass {
720    pub parent_class: gtk::GtkWidgetClass,
721}
722
723impl ::std::fmt::Debug for AdwLeafletClass {
724    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
725        f.debug_struct(&format!("AdwLeafletClass @ {self:p}"))
726            .field("parent_class", &self.parent_class)
727            .finish()
728    }
729}
730
731#[derive(Copy, Clone)]
732#[repr(C)]
733pub struct AdwLeafletPageClass {
734    pub parent_class: gobject::GObjectClass,
735}
736
737impl ::std::fmt::Debug for AdwLeafletPageClass {
738    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
739        f.debug_struct(&format!("AdwLeafletPageClass @ {self:p}"))
740            .field("parent_class", &self.parent_class)
741            .finish()
742    }
743}
744
745#[derive(Copy, Clone)]
746#[repr(C)]
747pub struct AdwMessageDialogClass {
748    pub parent_class: gtk::GtkWindowClass,
749    pub response: Option<unsafe extern "C" fn(*mut AdwMessageDialog, *const c_char)>,
750    pub padding: [gpointer; 4],
751}
752
753impl ::std::fmt::Debug for AdwMessageDialogClass {
754    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
755        f.debug_struct(&format!("AdwMessageDialogClass @ {self:p}"))
756            .field("parent_class", &self.parent_class)
757            .field("response", &self.response)
758            .finish()
759    }
760}
761
762#[derive(Copy, Clone)]
763#[repr(C)]
764pub struct AdwMultiLayoutViewClass {
765    pub parent_class: gtk::GtkWidgetClass,
766}
767
768impl ::std::fmt::Debug for AdwMultiLayoutViewClass {
769    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
770        f.debug_struct(&format!("AdwMultiLayoutViewClass @ {self:p}"))
771            .field("parent_class", &self.parent_class)
772            .finish()
773    }
774}
775
776#[derive(Copy, Clone)]
777#[repr(C)]
778pub struct AdwNavigationPageClass {
779    pub parent_class: gtk::GtkWidgetClass,
780    pub showing: Option<unsafe extern "C" fn(*mut AdwNavigationPage)>,
781    pub shown: Option<unsafe extern "C" fn(*mut AdwNavigationPage)>,
782    pub hiding: Option<unsafe extern "C" fn(*mut AdwNavigationPage)>,
783    pub hidden: Option<unsafe extern "C" fn(*mut AdwNavigationPage)>,
784    pub padding: [gpointer; 8],
785}
786
787impl ::std::fmt::Debug for AdwNavigationPageClass {
788    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
789        f.debug_struct(&format!("AdwNavigationPageClass @ {self:p}"))
790            .field("parent_class", &self.parent_class)
791            .field("showing", &self.showing)
792            .field("shown", &self.shown)
793            .field("hiding", &self.hiding)
794            .field("hidden", &self.hidden)
795            .finish()
796    }
797}
798
799#[derive(Copy, Clone)]
800#[repr(C)]
801pub struct AdwNavigationSplitViewClass {
802    pub parent_class: gtk::GtkWidgetClass,
803}
804
805impl ::std::fmt::Debug for AdwNavigationSplitViewClass {
806    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
807        f.debug_struct(&format!("AdwNavigationSplitViewClass @ {self:p}"))
808            .field("parent_class", &self.parent_class)
809            .finish()
810    }
811}
812
813#[derive(Copy, Clone)]
814#[repr(C)]
815pub struct AdwNavigationViewClass {
816    pub parent_class: gtk::GtkWidgetClass,
817}
818
819impl ::std::fmt::Debug for AdwNavigationViewClass {
820    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
821        f.debug_struct(&format!("AdwNavigationViewClass @ {self:p}"))
822            .field("parent_class", &self.parent_class)
823            .finish()
824    }
825}
826
827#[repr(C)]
828#[allow(dead_code)]
829pub struct _AdwNoneAnimationTargetClass {
830    _data: [u8; 0],
831    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
832}
833
834pub type AdwNoneAnimationTargetClass = _AdwNoneAnimationTargetClass;
835
836#[derive(Copy, Clone)]
837#[repr(C)]
838pub struct AdwOverlaySplitViewClass {
839    pub parent_class: gtk::GtkWidgetClass,
840}
841
842impl ::std::fmt::Debug for AdwOverlaySplitViewClass {
843    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
844        f.debug_struct(&format!("AdwOverlaySplitViewClass @ {self:p}"))
845            .field("parent_class", &self.parent_class)
846            .finish()
847    }
848}
849
850#[derive(Copy, Clone)]
851#[repr(C)]
852pub struct AdwPasswordEntryRowClass {
853    pub parent_class: AdwEntryRowClass,
854}
855
856impl ::std::fmt::Debug for AdwPasswordEntryRowClass {
857    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
858        f.debug_struct(&format!("AdwPasswordEntryRowClass @ {self:p}"))
859            .field("parent_class", &self.parent_class)
860            .finish()
861    }
862}
863
864#[derive(Copy, Clone)]
865#[repr(C)]
866pub struct AdwPreferencesDialogClass {
867    pub parent_class: AdwDialogClass,
868    pub padding: [gpointer; 4],
869}
870
871impl ::std::fmt::Debug for AdwPreferencesDialogClass {
872    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
873        f.debug_struct(&format!("AdwPreferencesDialogClass @ {self:p}"))
874            .field("parent_class", &self.parent_class)
875            .finish()
876    }
877}
878
879#[derive(Copy, Clone)]
880#[repr(C)]
881pub struct AdwPreferencesGroupClass {
882    pub parent_class: gtk::GtkWidgetClass,
883    pub padding: [gpointer; 4],
884}
885
886impl ::std::fmt::Debug for AdwPreferencesGroupClass {
887    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
888        f.debug_struct(&format!("AdwPreferencesGroupClass @ {self:p}"))
889            .field("parent_class", &self.parent_class)
890            .finish()
891    }
892}
893
894#[derive(Copy, Clone)]
895#[repr(C)]
896pub struct AdwPreferencesPageClass {
897    pub parent_class: gtk::GtkWidgetClass,
898    pub padding: [gpointer; 4],
899}
900
901impl ::std::fmt::Debug for AdwPreferencesPageClass {
902    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
903        f.debug_struct(&format!("AdwPreferencesPageClass @ {self:p}"))
904            .field("parent_class", &self.parent_class)
905            .finish()
906    }
907}
908
909#[derive(Copy, Clone)]
910#[repr(C)]
911pub struct AdwPreferencesRowClass {
912    pub parent_class: gtk::GtkListBoxRowClass,
913    pub padding: [gpointer; 4],
914}
915
916impl ::std::fmt::Debug for AdwPreferencesRowClass {
917    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
918        f.debug_struct(&format!("AdwPreferencesRowClass @ {self:p}"))
919            .field("parent_class", &self.parent_class)
920            .finish()
921    }
922}
923
924#[derive(Copy, Clone)]
925#[repr(C)]
926pub struct AdwPreferencesWindowClass {
927    pub parent_class: AdwWindowClass,
928    pub padding: [gpointer; 4],
929}
930
931impl ::std::fmt::Debug for AdwPreferencesWindowClass {
932    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
933        f.debug_struct(&format!("AdwPreferencesWindowClass @ {self:p}"))
934            .field("parent_class", &self.parent_class)
935            .finish()
936    }
937}
938
939#[repr(C)]
940#[allow(dead_code)]
941pub struct _AdwPropertyAnimationTargetClass {
942    _data: [u8; 0],
943    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
944}
945
946pub type AdwPropertyAnimationTargetClass = _AdwPropertyAnimationTargetClass;
947
948#[derive(Copy, Clone)]
949#[repr(C)]
950pub struct AdwShortcutLabelClass {
951    pub parent_class: gtk::GtkWidgetClass,
952}
953
954impl ::std::fmt::Debug for AdwShortcutLabelClass {
955    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
956        f.debug_struct(&format!("AdwShortcutLabelClass @ {self:p}"))
957            .field("parent_class", &self.parent_class)
958            .finish()
959    }
960}
961
962#[derive(Copy, Clone)]
963#[repr(C)]
964pub struct AdwShortcutsDialogClass {
965    pub parent_class: AdwDialogClass,
966}
967
968impl ::std::fmt::Debug for AdwShortcutsDialogClass {
969    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
970        f.debug_struct(&format!("AdwShortcutsDialogClass @ {self:p}"))
971            .field("parent_class", &self.parent_class)
972            .finish()
973    }
974}
975
976#[derive(Copy, Clone)]
977#[repr(C)]
978pub struct AdwShortcutsItemClass {
979    pub parent_class: gobject::GObjectClass,
980}
981
982impl ::std::fmt::Debug for AdwShortcutsItemClass {
983    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
984        f.debug_struct(&format!("AdwShortcutsItemClass @ {self:p}"))
985            .field("parent_class", &self.parent_class)
986            .finish()
987    }
988}
989
990#[derive(Copy, Clone)]
991#[repr(C)]
992pub struct AdwShortcutsSectionClass {
993    pub parent_class: gobject::GObjectClass,
994}
995
996impl ::std::fmt::Debug for AdwShortcutsSectionClass {
997    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
998        f.debug_struct(&format!("AdwShortcutsSectionClass @ {self:p}"))
999            .field("parent_class", &self.parent_class)
1000            .finish()
1001    }
1002}
1003
1004#[derive(Copy, Clone)]
1005#[repr(C)]
1006pub struct AdwSidebarClass {
1007    pub parent_class: gtk::GtkWidgetClass,
1008}
1009
1010impl ::std::fmt::Debug for AdwSidebarClass {
1011    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1012        f.debug_struct(&format!("AdwSidebarClass @ {self:p}"))
1013            .field("parent_class", &self.parent_class)
1014            .finish()
1015    }
1016}
1017
1018#[derive(Copy, Clone)]
1019#[repr(C)]
1020pub struct AdwSidebarItemClass {
1021    pub parent_class: gobject::GObjectClass,
1022    pub padding: [gpointer; 4],
1023}
1024
1025impl ::std::fmt::Debug for AdwSidebarItemClass {
1026    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1027        f.debug_struct(&format!("AdwSidebarItemClass @ {self:p}"))
1028            .field("parent_class", &self.parent_class)
1029            .finish()
1030    }
1031}
1032
1033#[derive(Copy, Clone)]
1034#[repr(C)]
1035pub struct AdwSidebarSectionClass {
1036    pub parent_class: gobject::GObjectClass,
1037}
1038
1039impl ::std::fmt::Debug for AdwSidebarSectionClass {
1040    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1041        f.debug_struct(&format!("AdwSidebarSectionClass @ {self:p}"))
1042            .field("parent_class", &self.parent_class)
1043            .finish()
1044    }
1045}
1046
1047#[derive(Copy, Clone)]
1048#[repr(C)]
1049pub struct AdwSpinRowClass {
1050    pub parent_class: AdwActionRowClass,
1051}
1052
1053impl ::std::fmt::Debug for AdwSpinRowClass {
1054    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1055        f.debug_struct(&format!("AdwSpinRowClass @ {self:p}"))
1056            .field("parent_class", &self.parent_class)
1057            .finish()
1058    }
1059}
1060
1061#[derive(Copy, Clone)]
1062#[repr(C)]
1063pub struct AdwSpinnerClass {
1064    pub parent_class: gtk::GtkWidgetClass,
1065}
1066
1067impl ::std::fmt::Debug for AdwSpinnerClass {
1068    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1069        f.debug_struct(&format!("AdwSpinnerClass @ {self:p}"))
1070            .field("parent_class", &self.parent_class)
1071            .finish()
1072    }
1073}
1074
1075#[derive(Copy, Clone)]
1076#[repr(C)]
1077pub struct AdwSpinnerPaintableClass {
1078    pub parent_class: gobject::GObjectClass,
1079}
1080
1081impl ::std::fmt::Debug for AdwSpinnerPaintableClass {
1082    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1083        f.debug_struct(&format!("AdwSpinnerPaintableClass @ {self:p}"))
1084            .field("parent_class", &self.parent_class)
1085            .finish()
1086    }
1087}
1088
1089#[derive(Copy, Clone)]
1090#[repr(C)]
1091pub struct AdwSplitButtonClass {
1092    pub parent_class: gtk::GtkWidgetClass,
1093}
1094
1095impl ::std::fmt::Debug for AdwSplitButtonClass {
1096    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1097        f.debug_struct(&format!("AdwSplitButtonClass @ {self:p}"))
1098            .field("parent_class", &self.parent_class)
1099            .finish()
1100    }
1101}
1102
1103#[repr(C)]
1104#[allow(dead_code)]
1105pub struct _AdwSpringAnimationClass {
1106    _data: [u8; 0],
1107    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1108}
1109
1110pub type AdwSpringAnimationClass = _AdwSpringAnimationClass;
1111
1112#[repr(C)]
1113#[allow(dead_code)]
1114pub struct AdwSpringParams {
1115    _data: [u8; 0],
1116    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1117}
1118
1119impl ::std::fmt::Debug for AdwSpringParams {
1120    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1121        f.debug_struct(&format!("AdwSpringParams @ {self:p}"))
1122            .finish()
1123    }
1124}
1125
1126#[derive(Copy, Clone)]
1127#[repr(C)]
1128pub struct AdwSqueezerClass {
1129    pub parent_class: gtk::GtkWidgetClass,
1130}
1131
1132impl ::std::fmt::Debug for AdwSqueezerClass {
1133    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1134        f.debug_struct(&format!("AdwSqueezerClass @ {self:p}"))
1135            .field("parent_class", &self.parent_class)
1136            .finish()
1137    }
1138}
1139
1140#[derive(Copy, Clone)]
1141#[repr(C)]
1142pub struct AdwSqueezerPageClass {
1143    pub parent_class: gobject::GObjectClass,
1144}
1145
1146impl ::std::fmt::Debug for AdwSqueezerPageClass {
1147    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1148        f.debug_struct(&format!("AdwSqueezerPageClass @ {self:p}"))
1149            .field("parent_class", &self.parent_class)
1150            .finish()
1151    }
1152}
1153
1154#[derive(Copy, Clone)]
1155#[repr(C)]
1156pub struct AdwStatusPageClass {
1157    pub parent_class: gtk::GtkWidgetClass,
1158}
1159
1160impl ::std::fmt::Debug for AdwStatusPageClass {
1161    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1162        f.debug_struct(&format!("AdwStatusPageClass @ {self:p}"))
1163            .field("parent_class", &self.parent_class)
1164            .finish()
1165    }
1166}
1167
1168#[derive(Copy, Clone)]
1169#[repr(C)]
1170pub struct AdwStyleManagerClass {
1171    pub parent_class: gobject::GObjectClass,
1172}
1173
1174impl ::std::fmt::Debug for AdwStyleManagerClass {
1175    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1176        f.debug_struct(&format!("AdwStyleManagerClass @ {self:p}"))
1177            .field("parent_class", &self.parent_class)
1178            .finish()
1179    }
1180}
1181
1182#[derive(Copy, Clone)]
1183#[repr(C)]
1184pub struct AdwSwipeTrackerClass {
1185    pub parent_class: gobject::GObjectClass,
1186}
1187
1188impl ::std::fmt::Debug for AdwSwipeTrackerClass {
1189    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1190        f.debug_struct(&format!("AdwSwipeTrackerClass @ {self:p}"))
1191            .field("parent_class", &self.parent_class)
1192            .finish()
1193    }
1194}
1195
1196#[derive(Copy, Clone)]
1197#[repr(C)]
1198pub struct AdwSwipeableInterface {
1199    pub parent: gobject::GTypeInterface,
1200    pub get_distance: Option<unsafe extern "C" fn(*mut AdwSwipeable) -> c_double>,
1201    pub get_snap_points:
1202        Option<unsafe extern "C" fn(*mut AdwSwipeable, *mut c_int) -> *mut c_double>,
1203    pub get_progress: Option<unsafe extern "C" fn(*mut AdwSwipeable) -> c_double>,
1204    pub get_cancel_progress: Option<unsafe extern "C" fn(*mut AdwSwipeable) -> c_double>,
1205    pub get_swipe_area: Option<
1206        unsafe extern "C" fn(
1207            *mut AdwSwipeable,
1208            AdwNavigationDirection,
1209            gboolean,
1210            *mut gdk::GdkRectangle,
1211        ),
1212    >,
1213    pub padding: [gpointer; 4],
1214}
1215
1216impl ::std::fmt::Debug for AdwSwipeableInterface {
1217    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1218        f.debug_struct(&format!("AdwSwipeableInterface @ {self:p}"))
1219            .field("parent", &self.parent)
1220            .field("get_distance", &self.get_distance)
1221            .field("get_snap_points", &self.get_snap_points)
1222            .field("get_progress", &self.get_progress)
1223            .field("get_cancel_progress", &self.get_cancel_progress)
1224            .field("get_swipe_area", &self.get_swipe_area)
1225            .finish()
1226    }
1227}
1228
1229#[derive(Copy, Clone)]
1230#[repr(C)]
1231pub struct AdwSwitchRowClass {
1232    pub parent_class: AdwActionRowClass,
1233}
1234
1235impl ::std::fmt::Debug for AdwSwitchRowClass {
1236    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1237        f.debug_struct(&format!("AdwSwitchRowClass @ {self:p}"))
1238            .field("parent_class", &self.parent_class)
1239            .finish()
1240    }
1241}
1242
1243#[derive(Copy, Clone)]
1244#[repr(C)]
1245pub struct AdwTabBarClass {
1246    pub parent_class: gtk::GtkWidgetClass,
1247}
1248
1249impl ::std::fmt::Debug for AdwTabBarClass {
1250    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1251        f.debug_struct(&format!("AdwTabBarClass @ {self:p}"))
1252            .field("parent_class", &self.parent_class)
1253            .finish()
1254    }
1255}
1256
1257#[derive(Copy, Clone)]
1258#[repr(C)]
1259pub struct AdwTabButtonClass {
1260    pub parent_class: gtk::GtkWidgetClass,
1261}
1262
1263impl ::std::fmt::Debug for AdwTabButtonClass {
1264    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1265        f.debug_struct(&format!("AdwTabButtonClass @ {self:p}"))
1266            .field("parent_class", &self.parent_class)
1267            .finish()
1268    }
1269}
1270
1271#[derive(Copy, Clone)]
1272#[repr(C)]
1273pub struct AdwTabOverviewClass {
1274    pub parent_class: gtk::GtkWidgetClass,
1275}
1276
1277impl ::std::fmt::Debug for AdwTabOverviewClass {
1278    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1279        f.debug_struct(&format!("AdwTabOverviewClass @ {self:p}"))
1280            .field("parent_class", &self.parent_class)
1281            .finish()
1282    }
1283}
1284
1285#[derive(Copy, Clone)]
1286#[repr(C)]
1287pub struct AdwTabPageClass {
1288    pub parent_class: gobject::GObjectClass,
1289}
1290
1291impl ::std::fmt::Debug for AdwTabPageClass {
1292    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1293        f.debug_struct(&format!("AdwTabPageClass @ {self:p}"))
1294            .field("parent_class", &self.parent_class)
1295            .finish()
1296    }
1297}
1298
1299#[derive(Copy, Clone)]
1300#[repr(C)]
1301pub struct AdwTabViewClass {
1302    pub parent_class: gtk::GtkWidgetClass,
1303}
1304
1305impl ::std::fmt::Debug for AdwTabViewClass {
1306    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1307        f.debug_struct(&format!("AdwTabViewClass @ {self:p}"))
1308            .field("parent_class", &self.parent_class)
1309            .finish()
1310    }
1311}
1312
1313#[repr(C)]
1314#[allow(dead_code)]
1315pub struct _AdwTimedAnimationClass {
1316    _data: [u8; 0],
1317    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1318}
1319
1320pub type AdwTimedAnimationClass = _AdwTimedAnimationClass;
1321
1322#[derive(Copy, Clone)]
1323#[repr(C)]
1324pub struct AdwToastClass {
1325    pub parent_class: gobject::GObjectClass,
1326}
1327
1328impl ::std::fmt::Debug for AdwToastClass {
1329    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1330        f.debug_struct(&format!("AdwToastClass @ {self:p}"))
1331            .field("parent_class", &self.parent_class)
1332            .finish()
1333    }
1334}
1335
1336#[derive(Copy, Clone)]
1337#[repr(C)]
1338pub struct AdwToastOverlayClass {
1339    pub parent_class: gtk::GtkWidgetClass,
1340}
1341
1342impl ::std::fmt::Debug for AdwToastOverlayClass {
1343    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1344        f.debug_struct(&format!("AdwToastOverlayClass @ {self:p}"))
1345            .field("parent_class", &self.parent_class)
1346            .finish()
1347    }
1348}
1349
1350#[derive(Copy, Clone)]
1351#[repr(C)]
1352pub struct AdwToggleClass {
1353    pub parent_class: gobject::GObjectClass,
1354}
1355
1356impl ::std::fmt::Debug for AdwToggleClass {
1357    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1358        f.debug_struct(&format!("AdwToggleClass @ {self:p}"))
1359            .field("parent_class", &self.parent_class)
1360            .finish()
1361    }
1362}
1363
1364#[derive(Copy, Clone)]
1365#[repr(C)]
1366pub struct AdwToggleGroupClass {
1367    pub parent_class: gtk::GtkWidgetClass,
1368}
1369
1370impl ::std::fmt::Debug for AdwToggleGroupClass {
1371    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1372        f.debug_struct(&format!("AdwToggleGroupClass @ {self:p}"))
1373            .field("parent_class", &self.parent_class)
1374            .finish()
1375    }
1376}
1377
1378#[derive(Copy, Clone)]
1379#[repr(C)]
1380pub struct AdwToolbarViewClass {
1381    pub parent_class: gtk::GtkWidgetClass,
1382}
1383
1384impl ::std::fmt::Debug for AdwToolbarViewClass {
1385    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1386        f.debug_struct(&format!("AdwToolbarViewClass @ {self:p}"))
1387            .field("parent_class", &self.parent_class)
1388            .finish()
1389    }
1390}
1391
1392#[derive(Copy, Clone)]
1393#[repr(C)]
1394pub struct AdwViewStackClass {
1395    pub parent_class: gtk::GtkWidgetClass,
1396}
1397
1398impl ::std::fmt::Debug for AdwViewStackClass {
1399    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1400        f.debug_struct(&format!("AdwViewStackClass @ {self:p}"))
1401            .field("parent_class", &self.parent_class)
1402            .finish()
1403    }
1404}
1405
1406#[derive(Copy, Clone)]
1407#[repr(C)]
1408pub struct AdwViewStackPageClass {
1409    pub parent_class: gobject::GObjectClass,
1410}
1411
1412impl ::std::fmt::Debug for AdwViewStackPageClass {
1413    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1414        f.debug_struct(&format!("AdwViewStackPageClass @ {self:p}"))
1415            .field("parent_class", &self.parent_class)
1416            .finish()
1417    }
1418}
1419
1420#[derive(Copy, Clone)]
1421#[repr(C)]
1422pub struct AdwViewStackPagesClass {
1423    pub parent_class: gobject::GObjectClass,
1424}
1425
1426impl ::std::fmt::Debug for AdwViewStackPagesClass {
1427    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1428        f.debug_struct(&format!("AdwViewStackPagesClass @ {self:p}"))
1429            .field("parent_class", &self.parent_class)
1430            .finish()
1431    }
1432}
1433
1434#[derive(Copy, Clone)]
1435#[repr(C)]
1436pub struct AdwViewSwitcherBarClass {
1437    pub parent_class: gtk::GtkWidgetClass,
1438}
1439
1440impl ::std::fmt::Debug for AdwViewSwitcherBarClass {
1441    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1442        f.debug_struct(&format!("AdwViewSwitcherBarClass @ {self:p}"))
1443            .field("parent_class", &self.parent_class)
1444            .finish()
1445    }
1446}
1447
1448#[derive(Copy, Clone)]
1449#[repr(C)]
1450pub struct AdwViewSwitcherClass {
1451    pub parent_class: gtk::GtkWidgetClass,
1452}
1453
1454impl ::std::fmt::Debug for AdwViewSwitcherClass {
1455    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1456        f.debug_struct(&format!("AdwViewSwitcherClass @ {self:p}"))
1457            .field("parent_class", &self.parent_class)
1458            .finish()
1459    }
1460}
1461
1462#[derive(Copy, Clone)]
1463#[repr(C)]
1464pub struct AdwViewSwitcherSidebarClass {
1465    pub parent_class: gtk::GtkWidgetClass,
1466}
1467
1468impl ::std::fmt::Debug for AdwViewSwitcherSidebarClass {
1469    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1470        f.debug_struct(&format!("AdwViewSwitcherSidebarClass @ {self:p}"))
1471            .field("parent_class", &self.parent_class)
1472            .finish()
1473    }
1474}
1475
1476#[derive(Copy, Clone)]
1477#[repr(C)]
1478pub struct AdwViewSwitcherTitleClass {
1479    pub parent_class: gtk::GtkWidgetClass,
1480}
1481
1482impl ::std::fmt::Debug for AdwViewSwitcherTitleClass {
1483    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1484        f.debug_struct(&format!("AdwViewSwitcherTitleClass @ {self:p}"))
1485            .field("parent_class", &self.parent_class)
1486            .finish()
1487    }
1488}
1489
1490#[derive(Copy, Clone)]
1491#[repr(C)]
1492pub struct AdwWindowClass {
1493    pub parent_class: gtk::GtkWindowClass,
1494    pub padding: [gpointer; 4],
1495}
1496
1497impl ::std::fmt::Debug for AdwWindowClass {
1498    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1499        f.debug_struct(&format!("AdwWindowClass @ {self:p}"))
1500            .field("parent_class", &self.parent_class)
1501            .finish()
1502    }
1503}
1504
1505#[derive(Copy, Clone)]
1506#[repr(C)]
1507pub struct AdwWindowTitleClass {
1508    pub parent_class: gtk::GtkWidgetClass,
1509}
1510
1511impl ::std::fmt::Debug for AdwWindowTitleClass {
1512    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1513        f.debug_struct(&format!("AdwWindowTitleClass @ {self:p}"))
1514            .field("parent_class", &self.parent_class)
1515            .finish()
1516    }
1517}
1518
1519#[derive(Copy, Clone)]
1520#[repr(C)]
1521pub struct AdwWrapBoxClass {
1522    pub parent_class: gtk::GtkWidgetClass,
1523}
1524
1525impl ::std::fmt::Debug for AdwWrapBoxClass {
1526    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1527        f.debug_struct(&format!("AdwWrapBoxClass @ {self:p}"))
1528            .field("parent_class", &self.parent_class)
1529            .finish()
1530    }
1531}
1532
1533#[derive(Copy, Clone)]
1534#[repr(C)]
1535pub struct AdwWrapLayoutClass {
1536    pub parent_class: gtk::GtkLayoutManagerClass,
1537}
1538
1539impl ::std::fmt::Debug for AdwWrapLayoutClass {
1540    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1541        f.debug_struct(&format!("AdwWrapLayoutClass @ {self:p}"))
1542            .field("parent_class", &self.parent_class)
1543            .finish()
1544    }
1545}
1546
1547// Classes
1548#[repr(C)]
1549#[allow(dead_code)]
1550pub struct AdwAboutDialog {
1551    _data: [u8; 0],
1552    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1553}
1554
1555impl ::std::fmt::Debug for AdwAboutDialog {
1556    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1557        f.debug_struct(&format!("AdwAboutDialog @ {self:p}"))
1558            .finish()
1559    }
1560}
1561
1562#[repr(C)]
1563#[allow(dead_code)]
1564pub struct AdwAboutWindow {
1565    _data: [u8; 0],
1566    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1567}
1568
1569impl ::std::fmt::Debug for AdwAboutWindow {
1570    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1571        f.debug_struct(&format!("AdwAboutWindow @ {self:p}"))
1572            .finish()
1573    }
1574}
1575
1576#[derive(Copy, Clone)]
1577#[repr(C)]
1578pub struct AdwActionRow {
1579    pub parent_instance: AdwPreferencesRow,
1580}
1581
1582impl ::std::fmt::Debug for AdwActionRow {
1583    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1584        f.debug_struct(&format!("AdwActionRow @ {self:p}"))
1585            .field("parent_instance", &self.parent_instance)
1586            .finish()
1587    }
1588}
1589
1590#[derive(Copy, Clone)]
1591#[repr(C)]
1592pub struct AdwAlertDialog {
1593    pub parent_instance: AdwDialog,
1594}
1595
1596impl ::std::fmt::Debug for AdwAlertDialog {
1597    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1598        f.debug_struct(&format!("AdwAlertDialog @ {self:p}"))
1599            .field("parent_instance", &self.parent_instance)
1600            .finish()
1601    }
1602}
1603
1604#[derive(Copy, Clone)]
1605#[repr(C)]
1606pub struct AdwAnimation {
1607    pub parent_instance: gobject::GObject,
1608}
1609
1610impl ::std::fmt::Debug for AdwAnimation {
1611    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1612        f.debug_struct(&format!("AdwAnimation @ {self:p}"))
1613            .field("parent_instance", &self.parent_instance)
1614            .finish()
1615    }
1616}
1617
1618#[repr(C)]
1619#[allow(dead_code)]
1620pub struct AdwAnimationTarget {
1621    _data: [u8; 0],
1622    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1623}
1624
1625impl ::std::fmt::Debug for AdwAnimationTarget {
1626    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1627        f.debug_struct(&format!("AdwAnimationTarget @ {self:p}"))
1628            .finish()
1629    }
1630}
1631
1632#[derive(Copy, Clone)]
1633#[repr(C)]
1634pub struct AdwApplication {
1635    pub parent_instance: gtk::GtkApplication,
1636}
1637
1638impl ::std::fmt::Debug for AdwApplication {
1639    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1640        f.debug_struct(&format!("AdwApplication @ {self:p}"))
1641            .field("parent_instance", &self.parent_instance)
1642            .finish()
1643    }
1644}
1645
1646#[derive(Copy, Clone)]
1647#[repr(C)]
1648pub struct AdwApplicationWindow {
1649    pub parent_instance: gtk::GtkApplicationWindow,
1650}
1651
1652impl ::std::fmt::Debug for AdwApplicationWindow {
1653    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1654        f.debug_struct(&format!("AdwApplicationWindow @ {self:p}"))
1655            .field("parent_instance", &self.parent_instance)
1656            .finish()
1657    }
1658}
1659
1660#[repr(C)]
1661#[allow(dead_code)]
1662pub struct AdwAvatar {
1663    _data: [u8; 0],
1664    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1665}
1666
1667impl ::std::fmt::Debug for AdwAvatar {
1668    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1669        f.debug_struct(&format!("AdwAvatar @ {self:p}")).finish()
1670    }
1671}
1672
1673#[repr(C)]
1674#[allow(dead_code)]
1675pub struct AdwBanner {
1676    _data: [u8; 0],
1677    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1678}
1679
1680impl ::std::fmt::Debug for AdwBanner {
1681    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1682        f.debug_struct(&format!("AdwBanner @ {self:p}")).finish()
1683    }
1684}
1685
1686#[derive(Copy, Clone)]
1687#[repr(C)]
1688pub struct AdwBin {
1689    pub parent_instance: gtk::GtkWidget,
1690}
1691
1692impl ::std::fmt::Debug for AdwBin {
1693    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1694        f.debug_struct(&format!("AdwBin @ {self:p}"))
1695            .field("parent_instance", &self.parent_instance)
1696            .finish()
1697    }
1698}
1699
1700#[repr(C)]
1701#[allow(dead_code)]
1702pub struct AdwBottomSheet {
1703    _data: [u8; 0],
1704    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1705}
1706
1707impl ::std::fmt::Debug for AdwBottomSheet {
1708    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1709        f.debug_struct(&format!("AdwBottomSheet @ {self:p}"))
1710            .finish()
1711    }
1712}
1713
1714#[repr(C)]
1715#[allow(dead_code)]
1716pub struct AdwBreakpoint {
1717    _data: [u8; 0],
1718    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1719}
1720
1721impl ::std::fmt::Debug for AdwBreakpoint {
1722    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1723        f.debug_struct(&format!("AdwBreakpoint @ {self:p}"))
1724            .finish()
1725    }
1726}
1727
1728#[derive(Copy, Clone)]
1729#[repr(C)]
1730pub struct AdwBreakpointBin {
1731    pub parent_instance: gtk::GtkWidget,
1732}
1733
1734impl ::std::fmt::Debug for AdwBreakpointBin {
1735    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1736        f.debug_struct(&format!("AdwBreakpointBin @ {self:p}"))
1737            .field("parent_instance", &self.parent_instance)
1738            .finish()
1739    }
1740}
1741
1742#[repr(C)]
1743#[allow(dead_code)]
1744pub struct AdwButtonContent {
1745    _data: [u8; 0],
1746    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1747}
1748
1749impl ::std::fmt::Debug for AdwButtonContent {
1750    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1751        f.debug_struct(&format!("AdwButtonContent @ {self:p}"))
1752            .finish()
1753    }
1754}
1755
1756#[repr(C)]
1757#[allow(dead_code)]
1758pub struct AdwButtonRow {
1759    _data: [u8; 0],
1760    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1761}
1762
1763impl ::std::fmt::Debug for AdwButtonRow {
1764    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1765        f.debug_struct(&format!("AdwButtonRow @ {self:p}")).finish()
1766    }
1767}
1768
1769#[repr(C)]
1770#[allow(dead_code)]
1771pub struct AdwCallbackAnimationTarget {
1772    _data: [u8; 0],
1773    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1774}
1775
1776impl ::std::fmt::Debug for AdwCallbackAnimationTarget {
1777    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1778        f.debug_struct(&format!("AdwCallbackAnimationTarget @ {self:p}"))
1779            .finish()
1780    }
1781}
1782
1783#[repr(C)]
1784#[allow(dead_code)]
1785pub struct AdwCarousel {
1786    _data: [u8; 0],
1787    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1788}
1789
1790impl ::std::fmt::Debug for AdwCarousel {
1791    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1792        f.debug_struct(&format!("AdwCarousel @ {self:p}")).finish()
1793    }
1794}
1795
1796#[repr(C)]
1797#[allow(dead_code)]
1798pub struct AdwCarouselIndicatorDots {
1799    _data: [u8; 0],
1800    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1801}
1802
1803impl ::std::fmt::Debug for AdwCarouselIndicatorDots {
1804    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1805        f.debug_struct(&format!("AdwCarouselIndicatorDots @ {self:p}"))
1806            .finish()
1807    }
1808}
1809
1810#[repr(C)]
1811#[allow(dead_code)]
1812pub struct AdwCarouselIndicatorLines {
1813    _data: [u8; 0],
1814    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1815}
1816
1817impl ::std::fmt::Debug for AdwCarouselIndicatorLines {
1818    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1819        f.debug_struct(&format!("AdwCarouselIndicatorLines @ {self:p}"))
1820            .finish()
1821    }
1822}
1823
1824#[repr(C)]
1825#[allow(dead_code)]
1826pub struct AdwClamp {
1827    _data: [u8; 0],
1828    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1829}
1830
1831impl ::std::fmt::Debug for AdwClamp {
1832    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1833        f.debug_struct(&format!("AdwClamp @ {self:p}")).finish()
1834    }
1835}
1836
1837#[repr(C)]
1838#[allow(dead_code)]
1839pub struct AdwClampLayout {
1840    _data: [u8; 0],
1841    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1842}
1843
1844impl ::std::fmt::Debug for AdwClampLayout {
1845    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1846        f.debug_struct(&format!("AdwClampLayout @ {self:p}"))
1847            .finish()
1848    }
1849}
1850
1851#[repr(C)]
1852#[allow(dead_code)]
1853pub struct AdwClampScrollable {
1854    _data: [u8; 0],
1855    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1856}
1857
1858impl ::std::fmt::Debug for AdwClampScrollable {
1859    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1860        f.debug_struct(&format!("AdwClampScrollable @ {self:p}"))
1861            .finish()
1862    }
1863}
1864
1865#[derive(Copy, Clone)]
1866#[repr(C)]
1867pub struct AdwComboRow {
1868    pub parent_instance: AdwActionRow,
1869}
1870
1871impl ::std::fmt::Debug for AdwComboRow {
1872    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1873        f.debug_struct(&format!("AdwComboRow @ {self:p}"))
1874            .field("parent_instance", &self.parent_instance)
1875            .finish()
1876    }
1877}
1878
1879#[derive(Copy, Clone)]
1880#[repr(C)]
1881pub struct AdwDialog {
1882    pub parent_instance: gtk::GtkWidget,
1883}
1884
1885impl ::std::fmt::Debug for AdwDialog {
1886    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1887        f.debug_struct(&format!("AdwDialog @ {self:p}"))
1888            .field("parent_instance", &self.parent_instance)
1889            .finish()
1890    }
1891}
1892
1893#[derive(Copy, Clone)]
1894#[repr(C)]
1895pub struct AdwEntryRow {
1896    pub parent_instance: AdwPreferencesRow,
1897}
1898
1899impl ::std::fmt::Debug for AdwEntryRow {
1900    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1901        f.debug_struct(&format!("AdwEntryRow @ {self:p}"))
1902            .field("parent_instance", &self.parent_instance)
1903            .finish()
1904    }
1905}
1906
1907#[repr(C)]
1908#[allow(dead_code)]
1909pub struct AdwEnumListItem {
1910    _data: [u8; 0],
1911    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1912}
1913
1914impl ::std::fmt::Debug for AdwEnumListItem {
1915    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1916        f.debug_struct(&format!("AdwEnumListItem @ {self:p}"))
1917            .finish()
1918    }
1919}
1920
1921#[repr(C)]
1922#[allow(dead_code)]
1923pub struct AdwEnumListModel {
1924    _data: [u8; 0],
1925    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1926}
1927
1928impl ::std::fmt::Debug for AdwEnumListModel {
1929    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1930        f.debug_struct(&format!("AdwEnumListModel @ {self:p}"))
1931            .finish()
1932    }
1933}
1934
1935#[derive(Copy, Clone)]
1936#[repr(C)]
1937pub struct AdwExpanderRow {
1938    pub parent_instance: AdwPreferencesRow,
1939}
1940
1941impl ::std::fmt::Debug for AdwExpanderRow {
1942    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1943        f.debug_struct(&format!("AdwExpanderRow @ {self:p}"))
1944            .field("parent_instance", &self.parent_instance)
1945            .finish()
1946    }
1947}
1948
1949#[repr(C)]
1950#[allow(dead_code)]
1951pub struct AdwFlap {
1952    _data: [u8; 0],
1953    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1954}
1955
1956impl ::std::fmt::Debug for AdwFlap {
1957    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1958        f.debug_struct(&format!("AdwFlap @ {self:p}")).finish()
1959    }
1960}
1961
1962#[repr(C)]
1963#[allow(dead_code)]
1964pub struct AdwHeaderBar {
1965    _data: [u8; 0],
1966    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1967}
1968
1969impl ::std::fmt::Debug for AdwHeaderBar {
1970    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1971        f.debug_struct(&format!("AdwHeaderBar @ {self:p}")).finish()
1972    }
1973}
1974
1975#[repr(C)]
1976#[allow(dead_code)]
1977pub struct AdwInlineViewSwitcher {
1978    _data: [u8; 0],
1979    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1980}
1981
1982impl ::std::fmt::Debug for AdwInlineViewSwitcher {
1983    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1984        f.debug_struct(&format!("AdwInlineViewSwitcher @ {self:p}"))
1985            .finish()
1986    }
1987}
1988
1989#[repr(C)]
1990#[allow(dead_code)]
1991pub struct AdwLayout {
1992    _data: [u8; 0],
1993    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1994}
1995
1996impl ::std::fmt::Debug for AdwLayout {
1997    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1998        f.debug_struct(&format!("AdwLayout @ {self:p}")).finish()
1999    }
2000}
2001
2002#[repr(C)]
2003#[allow(dead_code)]
2004pub struct AdwLayoutSlot {
2005    _data: [u8; 0],
2006    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2007}
2008
2009impl ::std::fmt::Debug for AdwLayoutSlot {
2010    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2011        f.debug_struct(&format!("AdwLayoutSlot @ {self:p}"))
2012            .finish()
2013    }
2014}
2015
2016#[repr(C)]
2017#[allow(dead_code)]
2018pub struct AdwLeaflet {
2019    _data: [u8; 0],
2020    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2021}
2022
2023impl ::std::fmt::Debug for AdwLeaflet {
2024    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2025        f.debug_struct(&format!("AdwLeaflet @ {self:p}")).finish()
2026    }
2027}
2028
2029#[repr(C)]
2030#[allow(dead_code)]
2031pub struct AdwLeafletPage {
2032    _data: [u8; 0],
2033    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2034}
2035
2036impl ::std::fmt::Debug for AdwLeafletPage {
2037    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2038        f.debug_struct(&format!("AdwLeafletPage @ {self:p}"))
2039            .finish()
2040    }
2041}
2042
2043#[derive(Copy, Clone)]
2044#[repr(C)]
2045pub struct AdwMessageDialog {
2046    pub parent_instance: gtk::GtkWindow,
2047}
2048
2049impl ::std::fmt::Debug for AdwMessageDialog {
2050    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2051        f.debug_struct(&format!("AdwMessageDialog @ {self:p}"))
2052            .field("parent_instance", &self.parent_instance)
2053            .finish()
2054    }
2055}
2056
2057#[repr(C)]
2058#[allow(dead_code)]
2059pub struct AdwMultiLayoutView {
2060    _data: [u8; 0],
2061    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2062}
2063
2064impl ::std::fmt::Debug for AdwMultiLayoutView {
2065    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2066        f.debug_struct(&format!("AdwMultiLayoutView @ {self:p}"))
2067            .finish()
2068    }
2069}
2070
2071#[derive(Copy, Clone)]
2072#[repr(C)]
2073pub struct AdwNavigationPage {
2074    pub parent_instance: gtk::GtkWidget,
2075}
2076
2077impl ::std::fmt::Debug for AdwNavigationPage {
2078    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2079        f.debug_struct(&format!("AdwNavigationPage @ {self:p}"))
2080            .field("parent_instance", &self.parent_instance)
2081            .finish()
2082    }
2083}
2084
2085#[repr(C)]
2086#[allow(dead_code)]
2087pub struct AdwNavigationSplitView {
2088    _data: [u8; 0],
2089    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2090}
2091
2092impl ::std::fmt::Debug for AdwNavigationSplitView {
2093    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2094        f.debug_struct(&format!("AdwNavigationSplitView @ {self:p}"))
2095            .finish()
2096    }
2097}
2098
2099#[repr(C)]
2100#[allow(dead_code)]
2101pub struct AdwNavigationView {
2102    _data: [u8; 0],
2103    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2104}
2105
2106impl ::std::fmt::Debug for AdwNavigationView {
2107    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2108        f.debug_struct(&format!("AdwNavigationView @ {self:p}"))
2109            .finish()
2110    }
2111}
2112
2113#[repr(C)]
2114#[allow(dead_code)]
2115pub struct AdwNoneAnimationTarget {
2116    _data: [u8; 0],
2117    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2118}
2119
2120impl ::std::fmt::Debug for AdwNoneAnimationTarget {
2121    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2122        f.debug_struct(&format!("AdwNoneAnimationTarget @ {self:p}"))
2123            .finish()
2124    }
2125}
2126
2127#[repr(C)]
2128#[allow(dead_code)]
2129pub struct AdwOverlaySplitView {
2130    _data: [u8; 0],
2131    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2132}
2133
2134impl ::std::fmt::Debug for AdwOverlaySplitView {
2135    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2136        f.debug_struct(&format!("AdwOverlaySplitView @ {self:p}"))
2137            .finish()
2138    }
2139}
2140
2141#[repr(C)]
2142#[allow(dead_code)]
2143pub struct AdwPasswordEntryRow {
2144    _data: [u8; 0],
2145    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2146}
2147
2148impl ::std::fmt::Debug for AdwPasswordEntryRow {
2149    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2150        f.debug_struct(&format!("AdwPasswordEntryRow @ {self:p}"))
2151            .finish()
2152    }
2153}
2154
2155#[derive(Copy, Clone)]
2156#[repr(C)]
2157pub struct AdwPreferencesDialog {
2158    pub parent_instance: AdwDialog,
2159}
2160
2161impl ::std::fmt::Debug for AdwPreferencesDialog {
2162    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2163        f.debug_struct(&format!("AdwPreferencesDialog @ {self:p}"))
2164            .field("parent_instance", &self.parent_instance)
2165            .finish()
2166    }
2167}
2168
2169#[derive(Copy, Clone)]
2170#[repr(C)]
2171pub struct AdwPreferencesGroup {
2172    pub parent_instance: gtk::GtkWidget,
2173}
2174
2175impl ::std::fmt::Debug for AdwPreferencesGroup {
2176    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2177        f.debug_struct(&format!("AdwPreferencesGroup @ {self:p}"))
2178            .field("parent_instance", &self.parent_instance)
2179            .finish()
2180    }
2181}
2182
2183#[derive(Copy, Clone)]
2184#[repr(C)]
2185pub struct AdwPreferencesPage {
2186    pub parent_instance: gtk::GtkWidget,
2187}
2188
2189impl ::std::fmt::Debug for AdwPreferencesPage {
2190    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2191        f.debug_struct(&format!("AdwPreferencesPage @ {self:p}"))
2192            .field("parent_instance", &self.parent_instance)
2193            .finish()
2194    }
2195}
2196
2197#[derive(Copy, Clone)]
2198#[repr(C)]
2199pub struct AdwPreferencesRow {
2200    pub parent_instance: gtk::GtkListBoxRow,
2201}
2202
2203impl ::std::fmt::Debug for AdwPreferencesRow {
2204    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2205        f.debug_struct(&format!("AdwPreferencesRow @ {self:p}"))
2206            .field("parent_instance", &self.parent_instance)
2207            .finish()
2208    }
2209}
2210
2211#[derive(Copy, Clone)]
2212#[repr(C)]
2213pub struct AdwPreferencesWindow {
2214    pub parent_instance: AdwWindow,
2215}
2216
2217impl ::std::fmt::Debug for AdwPreferencesWindow {
2218    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2219        f.debug_struct(&format!("AdwPreferencesWindow @ {self:p}"))
2220            .field("parent_instance", &self.parent_instance)
2221            .finish()
2222    }
2223}
2224
2225#[repr(C)]
2226#[allow(dead_code)]
2227pub struct AdwPropertyAnimationTarget {
2228    _data: [u8; 0],
2229    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2230}
2231
2232impl ::std::fmt::Debug for AdwPropertyAnimationTarget {
2233    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2234        f.debug_struct(&format!("AdwPropertyAnimationTarget @ {self:p}"))
2235            .finish()
2236    }
2237}
2238
2239#[repr(C)]
2240#[allow(dead_code)]
2241pub struct AdwShortcutLabel {
2242    _data: [u8; 0],
2243    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2244}
2245
2246impl ::std::fmt::Debug for AdwShortcutLabel {
2247    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2248        f.debug_struct(&format!("AdwShortcutLabel @ {self:p}"))
2249            .finish()
2250    }
2251}
2252
2253#[repr(C)]
2254#[allow(dead_code)]
2255pub struct AdwShortcutsDialog {
2256    _data: [u8; 0],
2257    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2258}
2259
2260impl ::std::fmt::Debug for AdwShortcutsDialog {
2261    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2262        f.debug_struct(&format!("AdwShortcutsDialog @ {self:p}"))
2263            .finish()
2264    }
2265}
2266
2267#[repr(C)]
2268#[allow(dead_code)]
2269pub struct AdwShortcutsItem {
2270    _data: [u8; 0],
2271    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2272}
2273
2274impl ::std::fmt::Debug for AdwShortcutsItem {
2275    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2276        f.debug_struct(&format!("AdwShortcutsItem @ {self:p}"))
2277            .finish()
2278    }
2279}
2280
2281#[repr(C)]
2282#[allow(dead_code)]
2283pub struct AdwShortcutsSection {
2284    _data: [u8; 0],
2285    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2286}
2287
2288impl ::std::fmt::Debug for AdwShortcutsSection {
2289    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2290        f.debug_struct(&format!("AdwShortcutsSection @ {self:p}"))
2291            .finish()
2292    }
2293}
2294
2295#[repr(C)]
2296#[allow(dead_code)]
2297pub struct AdwSidebar {
2298    _data: [u8; 0],
2299    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2300}
2301
2302impl ::std::fmt::Debug for AdwSidebar {
2303    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2304        f.debug_struct(&format!("AdwSidebar @ {self:p}")).finish()
2305    }
2306}
2307
2308#[derive(Copy, Clone)]
2309#[repr(C)]
2310pub struct AdwSidebarItem {
2311    pub parent_instance: gobject::GObject,
2312}
2313
2314impl ::std::fmt::Debug for AdwSidebarItem {
2315    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2316        f.debug_struct(&format!("AdwSidebarItem @ {self:p}"))
2317            .field("parent_instance", &self.parent_instance)
2318            .finish()
2319    }
2320}
2321
2322#[repr(C)]
2323#[allow(dead_code)]
2324pub struct AdwSidebarSection {
2325    _data: [u8; 0],
2326    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2327}
2328
2329impl ::std::fmt::Debug for AdwSidebarSection {
2330    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2331        f.debug_struct(&format!("AdwSidebarSection @ {self:p}"))
2332            .finish()
2333    }
2334}
2335
2336#[repr(C)]
2337#[allow(dead_code)]
2338pub struct AdwSpinRow {
2339    _data: [u8; 0],
2340    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2341}
2342
2343impl ::std::fmt::Debug for AdwSpinRow {
2344    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2345        f.debug_struct(&format!("AdwSpinRow @ {self:p}")).finish()
2346    }
2347}
2348
2349#[repr(C)]
2350#[allow(dead_code)]
2351pub struct AdwSpinner {
2352    _data: [u8; 0],
2353    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2354}
2355
2356impl ::std::fmt::Debug for AdwSpinner {
2357    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2358        f.debug_struct(&format!("AdwSpinner @ {self:p}")).finish()
2359    }
2360}
2361
2362#[repr(C)]
2363#[allow(dead_code)]
2364pub struct AdwSpinnerPaintable {
2365    _data: [u8; 0],
2366    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2367}
2368
2369impl ::std::fmt::Debug for AdwSpinnerPaintable {
2370    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2371        f.debug_struct(&format!("AdwSpinnerPaintable @ {self:p}"))
2372            .finish()
2373    }
2374}
2375
2376#[repr(C)]
2377#[allow(dead_code)]
2378pub struct AdwSplitButton {
2379    _data: [u8; 0],
2380    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2381}
2382
2383impl ::std::fmt::Debug for AdwSplitButton {
2384    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2385        f.debug_struct(&format!("AdwSplitButton @ {self:p}"))
2386            .finish()
2387    }
2388}
2389
2390#[repr(C)]
2391#[allow(dead_code)]
2392pub struct AdwSpringAnimation {
2393    _data: [u8; 0],
2394    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2395}
2396
2397impl ::std::fmt::Debug for AdwSpringAnimation {
2398    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2399        f.debug_struct(&format!("AdwSpringAnimation @ {self:p}"))
2400            .finish()
2401    }
2402}
2403
2404#[repr(C)]
2405#[allow(dead_code)]
2406pub struct AdwSqueezer {
2407    _data: [u8; 0],
2408    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2409}
2410
2411impl ::std::fmt::Debug for AdwSqueezer {
2412    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2413        f.debug_struct(&format!("AdwSqueezer @ {self:p}")).finish()
2414    }
2415}
2416
2417#[repr(C)]
2418#[allow(dead_code)]
2419pub struct AdwSqueezerPage {
2420    _data: [u8; 0],
2421    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2422}
2423
2424impl ::std::fmt::Debug for AdwSqueezerPage {
2425    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2426        f.debug_struct(&format!("AdwSqueezerPage @ {self:p}"))
2427            .finish()
2428    }
2429}
2430
2431#[repr(C)]
2432#[allow(dead_code)]
2433pub struct AdwStatusPage {
2434    _data: [u8; 0],
2435    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2436}
2437
2438impl ::std::fmt::Debug for AdwStatusPage {
2439    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2440        f.debug_struct(&format!("AdwStatusPage @ {self:p}"))
2441            .finish()
2442    }
2443}
2444
2445#[repr(C)]
2446#[allow(dead_code)]
2447pub struct AdwStyleManager {
2448    _data: [u8; 0],
2449    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2450}
2451
2452impl ::std::fmt::Debug for AdwStyleManager {
2453    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2454        f.debug_struct(&format!("AdwStyleManager @ {self:p}"))
2455            .finish()
2456    }
2457}
2458
2459#[repr(C)]
2460#[allow(dead_code)]
2461pub struct AdwSwipeTracker {
2462    _data: [u8; 0],
2463    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2464}
2465
2466impl ::std::fmt::Debug for AdwSwipeTracker {
2467    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2468        f.debug_struct(&format!("AdwSwipeTracker @ {self:p}"))
2469            .finish()
2470    }
2471}
2472
2473#[repr(C)]
2474#[allow(dead_code)]
2475pub struct AdwSwitchRow {
2476    _data: [u8; 0],
2477    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2478}
2479
2480impl ::std::fmt::Debug for AdwSwitchRow {
2481    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2482        f.debug_struct(&format!("AdwSwitchRow @ {self:p}")).finish()
2483    }
2484}
2485
2486#[repr(C)]
2487#[allow(dead_code)]
2488pub struct AdwTabBar {
2489    _data: [u8; 0],
2490    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2491}
2492
2493impl ::std::fmt::Debug for AdwTabBar {
2494    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2495        f.debug_struct(&format!("AdwTabBar @ {self:p}")).finish()
2496    }
2497}
2498
2499#[repr(C)]
2500#[allow(dead_code)]
2501pub struct AdwTabButton {
2502    _data: [u8; 0],
2503    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2504}
2505
2506impl ::std::fmt::Debug for AdwTabButton {
2507    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2508        f.debug_struct(&format!("AdwTabButton @ {self:p}")).finish()
2509    }
2510}
2511
2512#[repr(C)]
2513#[allow(dead_code)]
2514pub struct AdwTabOverview {
2515    _data: [u8; 0],
2516    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2517}
2518
2519impl ::std::fmt::Debug for AdwTabOverview {
2520    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2521        f.debug_struct(&format!("AdwTabOverview @ {self:p}"))
2522            .finish()
2523    }
2524}
2525
2526#[repr(C)]
2527#[allow(dead_code)]
2528pub struct AdwTabPage {
2529    _data: [u8; 0],
2530    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2531}
2532
2533impl ::std::fmt::Debug for AdwTabPage {
2534    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2535        f.debug_struct(&format!("AdwTabPage @ {self:p}")).finish()
2536    }
2537}
2538
2539#[repr(C)]
2540#[allow(dead_code)]
2541pub struct AdwTabView {
2542    _data: [u8; 0],
2543    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2544}
2545
2546impl ::std::fmt::Debug for AdwTabView {
2547    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2548        f.debug_struct(&format!("AdwTabView @ {self:p}")).finish()
2549    }
2550}
2551
2552#[repr(C)]
2553#[allow(dead_code)]
2554pub struct AdwTimedAnimation {
2555    _data: [u8; 0],
2556    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2557}
2558
2559impl ::std::fmt::Debug for AdwTimedAnimation {
2560    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2561        f.debug_struct(&format!("AdwTimedAnimation @ {self:p}"))
2562            .finish()
2563    }
2564}
2565
2566#[repr(C)]
2567#[allow(dead_code)]
2568pub struct AdwToast {
2569    _data: [u8; 0],
2570    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2571}
2572
2573impl ::std::fmt::Debug for AdwToast {
2574    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2575        f.debug_struct(&format!("AdwToast @ {self:p}")).finish()
2576    }
2577}
2578
2579#[repr(C)]
2580#[allow(dead_code)]
2581pub struct AdwToastOverlay {
2582    _data: [u8; 0],
2583    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2584}
2585
2586impl ::std::fmt::Debug for AdwToastOverlay {
2587    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2588        f.debug_struct(&format!("AdwToastOverlay @ {self:p}"))
2589            .finish()
2590    }
2591}
2592
2593#[repr(C)]
2594#[allow(dead_code)]
2595pub struct AdwToggle {
2596    _data: [u8; 0],
2597    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2598}
2599
2600impl ::std::fmt::Debug for AdwToggle {
2601    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2602        f.debug_struct(&format!("AdwToggle @ {self:p}")).finish()
2603    }
2604}
2605
2606#[repr(C)]
2607#[allow(dead_code)]
2608pub struct AdwToggleGroup {
2609    _data: [u8; 0],
2610    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2611}
2612
2613impl ::std::fmt::Debug for AdwToggleGroup {
2614    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2615        f.debug_struct(&format!("AdwToggleGroup @ {self:p}"))
2616            .finish()
2617    }
2618}
2619
2620#[repr(C)]
2621#[allow(dead_code)]
2622pub struct AdwToolbarView {
2623    _data: [u8; 0],
2624    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2625}
2626
2627impl ::std::fmt::Debug for AdwToolbarView {
2628    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2629        f.debug_struct(&format!("AdwToolbarView @ {self:p}"))
2630            .finish()
2631    }
2632}
2633
2634#[repr(C)]
2635#[allow(dead_code)]
2636pub struct AdwViewStack {
2637    _data: [u8; 0],
2638    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2639}
2640
2641impl ::std::fmt::Debug for AdwViewStack {
2642    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2643        f.debug_struct(&format!("AdwViewStack @ {self:p}")).finish()
2644    }
2645}
2646
2647#[repr(C)]
2648#[allow(dead_code)]
2649pub struct AdwViewStackPage {
2650    _data: [u8; 0],
2651    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2652}
2653
2654impl ::std::fmt::Debug for AdwViewStackPage {
2655    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2656        f.debug_struct(&format!("AdwViewStackPage @ {self:p}"))
2657            .finish()
2658    }
2659}
2660
2661#[repr(C)]
2662#[allow(dead_code)]
2663pub struct AdwViewStackPages {
2664    _data: [u8; 0],
2665    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2666}
2667
2668impl ::std::fmt::Debug for AdwViewStackPages {
2669    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2670        f.debug_struct(&format!("AdwViewStackPages @ {self:p}"))
2671            .finish()
2672    }
2673}
2674
2675#[repr(C)]
2676#[allow(dead_code)]
2677pub struct AdwViewSwitcher {
2678    _data: [u8; 0],
2679    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2680}
2681
2682impl ::std::fmt::Debug for AdwViewSwitcher {
2683    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2684        f.debug_struct(&format!("AdwViewSwitcher @ {self:p}"))
2685            .finish()
2686    }
2687}
2688
2689#[repr(C)]
2690#[allow(dead_code)]
2691pub struct AdwViewSwitcherBar {
2692    _data: [u8; 0],
2693    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2694}
2695
2696impl ::std::fmt::Debug for AdwViewSwitcherBar {
2697    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2698        f.debug_struct(&format!("AdwViewSwitcherBar @ {self:p}"))
2699            .finish()
2700    }
2701}
2702
2703#[repr(C)]
2704#[allow(dead_code)]
2705pub struct AdwViewSwitcherSidebar {
2706    _data: [u8; 0],
2707    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2708}
2709
2710impl ::std::fmt::Debug for AdwViewSwitcherSidebar {
2711    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2712        f.debug_struct(&format!("AdwViewSwitcherSidebar @ {self:p}"))
2713            .finish()
2714    }
2715}
2716
2717#[repr(C)]
2718#[allow(dead_code)]
2719pub struct AdwViewSwitcherTitle {
2720    _data: [u8; 0],
2721    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2722}
2723
2724impl ::std::fmt::Debug for AdwViewSwitcherTitle {
2725    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2726        f.debug_struct(&format!("AdwViewSwitcherTitle @ {self:p}"))
2727            .finish()
2728    }
2729}
2730
2731#[derive(Copy, Clone)]
2732#[repr(C)]
2733pub struct AdwWindow {
2734    pub parent_instance: gtk::GtkWindow,
2735}
2736
2737impl ::std::fmt::Debug for AdwWindow {
2738    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2739        f.debug_struct(&format!("AdwWindow @ {self:p}"))
2740            .field("parent_instance", &self.parent_instance)
2741            .finish()
2742    }
2743}
2744
2745#[repr(C)]
2746#[allow(dead_code)]
2747pub struct AdwWindowTitle {
2748    _data: [u8; 0],
2749    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2750}
2751
2752impl ::std::fmt::Debug for AdwWindowTitle {
2753    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2754        f.debug_struct(&format!("AdwWindowTitle @ {self:p}"))
2755            .finish()
2756    }
2757}
2758
2759#[repr(C)]
2760#[allow(dead_code)]
2761pub struct AdwWrapBox {
2762    _data: [u8; 0],
2763    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2764}
2765
2766impl ::std::fmt::Debug for AdwWrapBox {
2767    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2768        f.debug_struct(&format!("AdwWrapBox @ {self:p}")).finish()
2769    }
2770}
2771
2772#[repr(C)]
2773#[allow(dead_code)]
2774pub struct AdwWrapLayout {
2775    _data: [u8; 0],
2776    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2777}
2778
2779impl ::std::fmt::Debug for AdwWrapLayout {
2780    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2781        f.debug_struct(&format!("AdwWrapLayout @ {self:p}"))
2782            .finish()
2783    }
2784}
2785
2786// Interfaces
2787#[repr(C)]
2788#[allow(dead_code)]
2789pub struct AdwSwipeable {
2790    _data: [u8; 0],
2791    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2792}
2793
2794impl ::std::fmt::Debug for AdwSwipeable {
2795    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2796        write!(f, "AdwSwipeable @ {self:p}")
2797    }
2798}
2799
2800unsafe extern "C" {
2801
2802    //=========================================================================
2803    // AdwAccentColor
2804    //=========================================================================
2805    #[cfg(feature = "v1_6")]
2806    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
2807    pub fn adw_accent_color_get_type() -> GType;
2808    #[cfg(feature = "v1_6")]
2809    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
2810    pub fn adw_accent_color_to_rgba(self_: AdwAccentColor, rgba: *mut gdk::GdkRGBA);
2811    #[cfg(feature = "v1_6")]
2812    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
2813    pub fn adw_accent_color_to_standalone_rgba(
2814        self_: AdwAccentColor,
2815        dark: gboolean,
2816        rgba: *mut gdk::GdkRGBA,
2817    );
2818
2819    //=========================================================================
2820    // AdwAnimationState
2821    //=========================================================================
2822    pub fn adw_animation_state_get_type() -> GType;
2823
2824    //=========================================================================
2825    // AdwBannerButtonStyle
2826    //=========================================================================
2827    #[cfg(feature = "v1_7")]
2828    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2829    pub fn adw_banner_button_style_get_type() -> GType;
2830
2831    //=========================================================================
2832    // AdwBreakpointConditionLengthType
2833    //=========================================================================
2834    #[cfg(feature = "v1_4")]
2835    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2836    pub fn adw_breakpoint_condition_length_type_get_type() -> GType;
2837
2838    //=========================================================================
2839    // AdwBreakpointConditionRatioType
2840    //=========================================================================
2841    #[cfg(feature = "v1_4")]
2842    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2843    pub fn adw_breakpoint_condition_ratio_type_get_type() -> GType;
2844
2845    //=========================================================================
2846    // AdwCenteringPolicy
2847    //=========================================================================
2848    pub fn adw_centering_policy_get_type() -> GType;
2849
2850    //=========================================================================
2851    // AdwColorScheme
2852    //=========================================================================
2853    pub fn adw_color_scheme_get_type() -> GType;
2854
2855    //=========================================================================
2856    // AdwDialogPresentationMode
2857    //=========================================================================
2858    #[cfg(feature = "v1_5")]
2859    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
2860    pub fn adw_dialog_presentation_mode_get_type() -> GType;
2861
2862    //=========================================================================
2863    // AdwEasing
2864    //=========================================================================
2865    pub fn adw_easing_get_type() -> GType;
2866    pub fn adw_easing_ease(self_: AdwEasing, value: c_double) -> c_double;
2867
2868    //=========================================================================
2869    // AdwFlapFoldPolicy
2870    //=========================================================================
2871    pub fn adw_flap_fold_policy_get_type() -> GType;
2872
2873    //=========================================================================
2874    // AdwFlapTransitionType
2875    //=========================================================================
2876    pub fn adw_flap_transition_type_get_type() -> GType;
2877
2878    //=========================================================================
2879    // AdwFoldThresholdPolicy
2880    //=========================================================================
2881    pub fn adw_fold_threshold_policy_get_type() -> GType;
2882
2883    //=========================================================================
2884    // AdwInlineViewSwitcherDisplayMode
2885    //=========================================================================
2886    #[cfg(feature = "v1_7")]
2887    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2888    pub fn adw_inline_view_switcher_display_mode_get_type() -> GType;
2889
2890    //=========================================================================
2891    // AdwJustifyMode
2892    //=========================================================================
2893    #[cfg(feature = "v1_7")]
2894    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2895    pub fn adw_justify_mode_get_type() -> GType;
2896
2897    //=========================================================================
2898    // AdwLeafletTransitionType
2899    //=========================================================================
2900    pub fn adw_leaflet_transition_type_get_type() -> GType;
2901
2902    //=========================================================================
2903    // AdwLengthUnit
2904    //=========================================================================
2905    #[cfg(feature = "v1_4")]
2906    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2907    pub fn adw_length_unit_get_type() -> GType;
2908    #[cfg(feature = "v1_4")]
2909    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2910    pub fn adw_length_unit_from_px(
2911        unit: AdwLengthUnit,
2912        value: c_double,
2913        settings: *mut gtk::GtkSettings,
2914    ) -> c_double;
2915    #[cfg(feature = "v1_4")]
2916    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2917    pub fn adw_length_unit_to_px(
2918        unit: AdwLengthUnit,
2919        value: c_double,
2920        settings: *mut gtk::GtkSettings,
2921    ) -> c_double;
2922
2923    //=========================================================================
2924    // AdwNavigationDirection
2925    //=========================================================================
2926    pub fn adw_navigation_direction_get_type() -> GType;
2927
2928    //=========================================================================
2929    // AdwPackDirection
2930    //=========================================================================
2931    #[cfg(feature = "v1_7")]
2932    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2933    pub fn adw_pack_direction_get_type() -> GType;
2934
2935    //=========================================================================
2936    // AdwResponseAppearance
2937    //=========================================================================
2938    #[cfg(feature = "v1_2")]
2939    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
2940    pub fn adw_response_appearance_get_type() -> GType;
2941
2942    //=========================================================================
2943    // AdwSidebarMode
2944    //=========================================================================
2945    #[cfg(feature = "v1_9")]
2946    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
2947    pub fn adw_sidebar_mode_get_type() -> GType;
2948
2949    //=========================================================================
2950    // AdwSqueezerTransitionType
2951    //=========================================================================
2952    pub fn adw_squeezer_transition_type_get_type() -> GType;
2953
2954    //=========================================================================
2955    // AdwToastPriority
2956    //=========================================================================
2957    pub fn adw_toast_priority_get_type() -> GType;
2958
2959    //=========================================================================
2960    // AdwToolbarStyle
2961    //=========================================================================
2962    #[cfg(feature = "v1_4")]
2963    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2964    pub fn adw_toolbar_style_get_type() -> GType;
2965
2966    //=========================================================================
2967    // AdwViewSwitcherPolicy
2968    //=========================================================================
2969    pub fn adw_view_switcher_policy_get_type() -> GType;
2970
2971    //=========================================================================
2972    // AdwWrapPolicy
2973    //=========================================================================
2974    #[cfg(feature = "v1_7")]
2975    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
2976    pub fn adw_wrap_policy_get_type() -> GType;
2977
2978    //=========================================================================
2979    // AdwTabViewShortcuts
2980    //=========================================================================
2981    #[cfg(feature = "v1_2")]
2982    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
2983    pub fn adw_tab_view_shortcuts_get_type() -> GType;
2984
2985    //=========================================================================
2986    // AdwBreakpointCondition
2987    //=========================================================================
2988    #[cfg(feature = "v1_4")]
2989    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2990    pub fn adw_breakpoint_condition_get_type() -> GType;
2991    #[cfg(feature = "v1_4")]
2992    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2993    pub fn adw_breakpoint_condition_new_and(
2994        condition_1: *mut AdwBreakpointCondition,
2995        condition_2: *mut AdwBreakpointCondition,
2996    ) -> *mut AdwBreakpointCondition;
2997    #[cfg(feature = "v1_4")]
2998    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
2999    pub fn adw_breakpoint_condition_new_length(
3000        type_: AdwBreakpointConditionLengthType,
3001        value: c_double,
3002        unit: AdwLengthUnit,
3003    ) -> *mut AdwBreakpointCondition;
3004    #[cfg(feature = "v1_4")]
3005    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3006    pub fn adw_breakpoint_condition_new_or(
3007        condition_1: *mut AdwBreakpointCondition,
3008        condition_2: *mut AdwBreakpointCondition,
3009    ) -> *mut AdwBreakpointCondition;
3010    #[cfg(feature = "v1_4")]
3011    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3012    pub fn adw_breakpoint_condition_new_ratio(
3013        type_: AdwBreakpointConditionRatioType,
3014        width: c_int,
3015        height: c_int,
3016    ) -> *mut AdwBreakpointCondition;
3017    #[cfg(feature = "v1_4")]
3018    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3019    pub fn adw_breakpoint_condition_copy(
3020        self_: *mut AdwBreakpointCondition,
3021    ) -> *mut AdwBreakpointCondition;
3022    #[cfg(feature = "v1_4")]
3023    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3024    pub fn adw_breakpoint_condition_free(self_: *mut AdwBreakpointCondition);
3025    #[cfg(feature = "v1_4")]
3026    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3027    pub fn adw_breakpoint_condition_to_string(self_: *mut AdwBreakpointCondition) -> *mut c_char;
3028    #[cfg(feature = "v1_4")]
3029    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3030    pub fn adw_breakpoint_condition_parse(str: *const c_char) -> *mut AdwBreakpointCondition;
3031
3032    //=========================================================================
3033    // AdwSpringParams
3034    //=========================================================================
3035    pub fn adw_spring_params_get_type() -> GType;
3036    pub fn adw_spring_params_new(
3037        damping_ratio: c_double,
3038        mass: c_double,
3039        stiffness: c_double,
3040    ) -> *mut AdwSpringParams;
3041    pub fn adw_spring_params_new_full(
3042        damping: c_double,
3043        mass: c_double,
3044        stiffness: c_double,
3045    ) -> *mut AdwSpringParams;
3046    pub fn adw_spring_params_get_damping(self_: *mut AdwSpringParams) -> c_double;
3047    pub fn adw_spring_params_get_damping_ratio(self_: *mut AdwSpringParams) -> c_double;
3048    pub fn adw_spring_params_get_mass(self_: *mut AdwSpringParams) -> c_double;
3049    pub fn adw_spring_params_get_stiffness(self_: *mut AdwSpringParams) -> c_double;
3050    pub fn adw_spring_params_ref(self_: *mut AdwSpringParams) -> *mut AdwSpringParams;
3051    pub fn adw_spring_params_unref(self_: *mut AdwSpringParams);
3052
3053    //=========================================================================
3054    // AdwAboutDialog
3055    //=========================================================================
3056    #[cfg(feature = "v1_5")]
3057    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3058    pub fn adw_about_dialog_get_type() -> GType;
3059    #[cfg(feature = "v1_5")]
3060    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3061    pub fn adw_about_dialog_new() -> *mut AdwDialog;
3062    #[cfg(feature = "v1_5")]
3063    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3064    #[cfg(not(target_env = "msvc"))]
3065    #[cfg_attr(docsrs, doc(cfg(not(target_env = "msvc"))))]
3066    pub fn adw_about_dialog_new_from_appdata(
3067        resource_path: *const c_char,
3068        release_notes_version: *const c_char,
3069    ) -> *mut AdwDialog;
3070    #[cfg(feature = "v1_5")]
3071    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3072    pub fn adw_about_dialog_add_acknowledgement_section(
3073        self_: *mut AdwAboutDialog,
3074        name: *const c_char,
3075        people: *mut *const c_char,
3076    );
3077    #[cfg(feature = "v1_5")]
3078    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3079    pub fn adw_about_dialog_add_credit_section(
3080        self_: *mut AdwAboutDialog,
3081        name: *const c_char,
3082        people: *mut *const c_char,
3083    );
3084    #[cfg(feature = "v1_5")]
3085    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3086    pub fn adw_about_dialog_add_legal_section(
3087        self_: *mut AdwAboutDialog,
3088        title: *const c_char,
3089        copyright: *const c_char,
3090        license_type: gtk::GtkLicense,
3091        license: *const c_char,
3092    );
3093    #[cfg(feature = "v1_5")]
3094    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3095    pub fn adw_about_dialog_add_link(
3096        self_: *mut AdwAboutDialog,
3097        title: *const c_char,
3098        url: *const c_char,
3099    );
3100    #[cfg(feature = "v1_7")]
3101    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
3102    pub fn adw_about_dialog_add_other_app(
3103        self_: *mut AdwAboutDialog,
3104        appid: *const c_char,
3105        name: *const c_char,
3106        summary: *const c_char,
3107    );
3108    #[cfg(feature = "v1_9")]
3109    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
3110    pub fn adw_about_dialog_get_appdata_resource_path(self_: *mut AdwAboutDialog) -> *const c_char;
3111    #[cfg(feature = "v1_5")]
3112    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3113    pub fn adw_about_dialog_get_application_icon(self_: *mut AdwAboutDialog) -> *const c_char;
3114    #[cfg(feature = "v1_5")]
3115    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3116    pub fn adw_about_dialog_get_application_name(self_: *mut AdwAboutDialog) -> *const c_char;
3117    #[cfg(feature = "v1_5")]
3118    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3119    pub fn adw_about_dialog_get_artists(self_: *mut AdwAboutDialog) -> *const *const c_char;
3120    #[cfg(feature = "v1_5")]
3121    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3122    pub fn adw_about_dialog_get_comments(self_: *mut AdwAboutDialog) -> *const c_char;
3123    #[cfg(feature = "v1_5")]
3124    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3125    pub fn adw_about_dialog_get_copyright(self_: *mut AdwAboutDialog) -> *const c_char;
3126    #[cfg(feature = "v1_5")]
3127    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3128    pub fn adw_about_dialog_get_debug_info(self_: *mut AdwAboutDialog) -> *const c_char;
3129    #[cfg(feature = "v1_5")]
3130    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3131    pub fn adw_about_dialog_get_debug_info_filename(self_: *mut AdwAboutDialog) -> *const c_char;
3132    #[cfg(feature = "v1_5")]
3133    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3134    pub fn adw_about_dialog_get_designers(self_: *mut AdwAboutDialog) -> *const *const c_char;
3135    #[cfg(feature = "v1_5")]
3136    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3137    pub fn adw_about_dialog_get_developer_name(self_: *mut AdwAboutDialog) -> *const c_char;
3138    #[cfg(feature = "v1_5")]
3139    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3140    pub fn adw_about_dialog_get_developers(self_: *mut AdwAboutDialog) -> *const *const c_char;
3141    #[cfg(feature = "v1_5")]
3142    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3143    pub fn adw_about_dialog_get_documenters(self_: *mut AdwAboutDialog) -> *const *const c_char;
3144    #[cfg(feature = "v1_5")]
3145    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3146    pub fn adw_about_dialog_get_issue_url(self_: *mut AdwAboutDialog) -> *const c_char;
3147    #[cfg(feature = "v1_5")]
3148    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3149    pub fn adw_about_dialog_get_license(self_: *mut AdwAboutDialog) -> *const c_char;
3150    #[cfg(feature = "v1_5")]
3151    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3152    pub fn adw_about_dialog_get_license_type(self_: *mut AdwAboutDialog) -> gtk::GtkLicense;
3153    #[cfg(feature = "v1_5")]
3154    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3155    pub fn adw_about_dialog_get_release_notes(self_: *mut AdwAboutDialog) -> *const c_char;
3156    #[cfg(feature = "v1_5")]
3157    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3158    pub fn adw_about_dialog_get_release_notes_version(self_: *mut AdwAboutDialog) -> *const c_char;
3159    #[cfg(feature = "v1_5")]
3160    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3161    pub fn adw_about_dialog_get_support_url(self_: *mut AdwAboutDialog) -> *const c_char;
3162    #[cfg(feature = "v1_5")]
3163    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3164    pub fn adw_about_dialog_get_translator_credits(self_: *mut AdwAboutDialog) -> *const c_char;
3165    #[cfg(feature = "v1_5")]
3166    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3167    pub fn adw_about_dialog_get_version(self_: *mut AdwAboutDialog) -> *const c_char;
3168    #[cfg(feature = "v1_5")]
3169    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3170    pub fn adw_about_dialog_get_website(self_: *mut AdwAboutDialog) -> *const c_char;
3171    #[cfg(feature = "v1_5")]
3172    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3173    pub fn adw_about_dialog_set_application_icon(
3174        self_: *mut AdwAboutDialog,
3175        application_icon: *const c_char,
3176    );
3177    #[cfg(feature = "v1_5")]
3178    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3179    pub fn adw_about_dialog_set_application_name(
3180        self_: *mut AdwAboutDialog,
3181        application_name: *const c_char,
3182    );
3183    #[cfg(feature = "v1_5")]
3184    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3185    pub fn adw_about_dialog_set_artists(self_: *mut AdwAboutDialog, artists: *mut *const c_char);
3186    #[cfg(feature = "v1_5")]
3187    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3188    pub fn adw_about_dialog_set_comments(self_: *mut AdwAboutDialog, comments: *const c_char);
3189    #[cfg(feature = "v1_5")]
3190    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3191    pub fn adw_about_dialog_set_copyright(self_: *mut AdwAboutDialog, copyright: *const c_char);
3192    #[cfg(feature = "v1_5")]
3193    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3194    pub fn adw_about_dialog_set_debug_info(self_: *mut AdwAboutDialog, debug_info: *const c_char);
3195    #[cfg(feature = "v1_5")]
3196    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3197    pub fn adw_about_dialog_set_debug_info_filename(
3198        self_: *mut AdwAboutDialog,
3199        filename: *const c_char,
3200    );
3201    #[cfg(feature = "v1_5")]
3202    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3203    pub fn adw_about_dialog_set_designers(
3204        self_: *mut AdwAboutDialog,
3205        designers: *mut *const c_char,
3206    );
3207    #[cfg(feature = "v1_5")]
3208    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3209    pub fn adw_about_dialog_set_developer_name(
3210        self_: *mut AdwAboutDialog,
3211        developer_name: *const c_char,
3212    );
3213    #[cfg(feature = "v1_5")]
3214    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3215    pub fn adw_about_dialog_set_developers(
3216        self_: *mut AdwAboutDialog,
3217        developers: *mut *const c_char,
3218    );
3219    #[cfg(feature = "v1_5")]
3220    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3221    pub fn adw_about_dialog_set_documenters(
3222        self_: *mut AdwAboutDialog,
3223        documenters: *mut *const c_char,
3224    );
3225    #[cfg(feature = "v1_5")]
3226    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3227    pub fn adw_about_dialog_set_issue_url(self_: *mut AdwAboutDialog, issue_url: *const c_char);
3228    #[cfg(feature = "v1_5")]
3229    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3230    pub fn adw_about_dialog_set_license(self_: *mut AdwAboutDialog, license: *const c_char);
3231    #[cfg(feature = "v1_5")]
3232    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3233    pub fn adw_about_dialog_set_license_type(
3234        self_: *mut AdwAboutDialog,
3235        license_type: gtk::GtkLicense,
3236    );
3237    #[cfg(feature = "v1_5")]
3238    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3239    pub fn adw_about_dialog_set_release_notes(
3240        self_: *mut AdwAboutDialog,
3241        release_notes: *const c_char,
3242    );
3243    #[cfg(feature = "v1_5")]
3244    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3245    pub fn adw_about_dialog_set_release_notes_version(
3246        self_: *mut AdwAboutDialog,
3247        version: *const c_char,
3248    );
3249    #[cfg(feature = "v1_5")]
3250    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3251    pub fn adw_about_dialog_set_support_url(self_: *mut AdwAboutDialog, support_url: *const c_char);
3252    #[cfg(feature = "v1_5")]
3253    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3254    pub fn adw_about_dialog_set_translator_credits(
3255        self_: *mut AdwAboutDialog,
3256        translator_credits: *const c_char,
3257    );
3258    #[cfg(feature = "v1_5")]
3259    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3260    pub fn adw_about_dialog_set_version(self_: *mut AdwAboutDialog, version: *const c_char);
3261    #[cfg(feature = "v1_5")]
3262    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3263    pub fn adw_about_dialog_set_website(self_: *mut AdwAboutDialog, website: *const c_char);
3264
3265    //=========================================================================
3266    // AdwAboutWindow
3267    //=========================================================================
3268    #[cfg(feature = "v1_2")]
3269    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3270    pub fn adw_about_window_get_type() -> GType;
3271    #[cfg(feature = "v1_2")]
3272    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3273    pub fn adw_about_window_new() -> *mut gtk::GtkWidget;
3274    #[cfg(feature = "v1_4")]
3275    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3276    #[cfg(not(target_env = "msvc"))]
3277    #[cfg_attr(docsrs, doc(cfg(not(target_env = "msvc"))))]
3278    pub fn adw_about_window_new_from_appdata(
3279        resource_path: *const c_char,
3280        release_notes_version: *const c_char,
3281    ) -> *mut gtk::GtkWidget;
3282    #[cfg(feature = "v1_2")]
3283    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3284    pub fn adw_about_window_add_acknowledgement_section(
3285        self_: *mut AdwAboutWindow,
3286        name: *const c_char,
3287        people: *mut *const c_char,
3288    );
3289    #[cfg(feature = "v1_2")]
3290    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3291    pub fn adw_about_window_add_credit_section(
3292        self_: *mut AdwAboutWindow,
3293        name: *const c_char,
3294        people: *mut *const c_char,
3295    );
3296    #[cfg(feature = "v1_2")]
3297    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3298    pub fn adw_about_window_add_legal_section(
3299        self_: *mut AdwAboutWindow,
3300        title: *const c_char,
3301        copyright: *const c_char,
3302        license_type: gtk::GtkLicense,
3303        license: *const c_char,
3304    );
3305    #[cfg(feature = "v1_2")]
3306    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3307    pub fn adw_about_window_add_link(
3308        self_: *mut AdwAboutWindow,
3309        title: *const c_char,
3310        url: *const c_char,
3311    );
3312    #[cfg(feature = "v1_2")]
3313    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3314    pub fn adw_about_window_get_application_icon(self_: *mut AdwAboutWindow) -> *const c_char;
3315    #[cfg(feature = "v1_2")]
3316    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3317    pub fn adw_about_window_get_application_name(self_: *mut AdwAboutWindow) -> *const c_char;
3318    #[cfg(feature = "v1_2")]
3319    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3320    pub fn adw_about_window_get_artists(self_: *mut AdwAboutWindow) -> *const *const c_char;
3321    #[cfg(feature = "v1_2")]
3322    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3323    pub fn adw_about_window_get_comments(self_: *mut AdwAboutWindow) -> *const c_char;
3324    #[cfg(feature = "v1_2")]
3325    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3326    pub fn adw_about_window_get_copyright(self_: *mut AdwAboutWindow) -> *const c_char;
3327    #[cfg(feature = "v1_2")]
3328    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3329    pub fn adw_about_window_get_debug_info(self_: *mut AdwAboutWindow) -> *const c_char;
3330    #[cfg(feature = "v1_2")]
3331    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3332    pub fn adw_about_window_get_debug_info_filename(self_: *mut AdwAboutWindow) -> *const c_char;
3333    #[cfg(feature = "v1_2")]
3334    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3335    pub fn adw_about_window_get_designers(self_: *mut AdwAboutWindow) -> *const *const c_char;
3336    #[cfg(feature = "v1_2")]
3337    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3338    pub fn adw_about_window_get_developer_name(self_: *mut AdwAboutWindow) -> *const c_char;
3339    #[cfg(feature = "v1_2")]
3340    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3341    pub fn adw_about_window_get_developers(self_: *mut AdwAboutWindow) -> *const *const c_char;
3342    #[cfg(feature = "v1_2")]
3343    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3344    pub fn adw_about_window_get_documenters(self_: *mut AdwAboutWindow) -> *const *const c_char;
3345    #[cfg(feature = "v1_2")]
3346    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3347    pub fn adw_about_window_get_issue_url(self_: *mut AdwAboutWindow) -> *const c_char;
3348    #[cfg(feature = "v1_2")]
3349    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3350    pub fn adw_about_window_get_license(self_: *mut AdwAboutWindow) -> *const c_char;
3351    #[cfg(feature = "v1_2")]
3352    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3353    pub fn adw_about_window_get_license_type(self_: *mut AdwAboutWindow) -> gtk::GtkLicense;
3354    #[cfg(feature = "v1_2")]
3355    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3356    pub fn adw_about_window_get_release_notes(self_: *mut AdwAboutWindow) -> *const c_char;
3357    #[cfg(feature = "v1_2")]
3358    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3359    pub fn adw_about_window_get_release_notes_version(self_: *mut AdwAboutWindow) -> *const c_char;
3360    #[cfg(feature = "v1_2")]
3361    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3362    pub fn adw_about_window_get_support_url(self_: *mut AdwAboutWindow) -> *const c_char;
3363    #[cfg(feature = "v1_2")]
3364    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3365    pub fn adw_about_window_get_translator_credits(self_: *mut AdwAboutWindow) -> *const c_char;
3366    #[cfg(feature = "v1_2")]
3367    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3368    pub fn adw_about_window_get_version(self_: *mut AdwAboutWindow) -> *const c_char;
3369    #[cfg(feature = "v1_2")]
3370    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3371    pub fn adw_about_window_get_website(self_: *mut AdwAboutWindow) -> *const c_char;
3372    #[cfg(feature = "v1_2")]
3373    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3374    pub fn adw_about_window_set_application_icon(
3375        self_: *mut AdwAboutWindow,
3376        application_icon: *const c_char,
3377    );
3378    #[cfg(feature = "v1_2")]
3379    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3380    pub fn adw_about_window_set_application_name(
3381        self_: *mut AdwAboutWindow,
3382        application_name: *const c_char,
3383    );
3384    #[cfg(feature = "v1_2")]
3385    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3386    pub fn adw_about_window_set_artists(self_: *mut AdwAboutWindow, artists: *mut *const c_char);
3387    #[cfg(feature = "v1_2")]
3388    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3389    pub fn adw_about_window_set_comments(self_: *mut AdwAboutWindow, comments: *const c_char);
3390    #[cfg(feature = "v1_2")]
3391    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3392    pub fn adw_about_window_set_copyright(self_: *mut AdwAboutWindow, copyright: *const c_char);
3393    #[cfg(feature = "v1_2")]
3394    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3395    pub fn adw_about_window_set_debug_info(self_: *mut AdwAboutWindow, debug_info: *const c_char);
3396    #[cfg(feature = "v1_2")]
3397    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3398    pub fn adw_about_window_set_debug_info_filename(
3399        self_: *mut AdwAboutWindow,
3400        filename: *const c_char,
3401    );
3402    #[cfg(feature = "v1_2")]
3403    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3404    pub fn adw_about_window_set_designers(
3405        self_: *mut AdwAboutWindow,
3406        designers: *mut *const c_char,
3407    );
3408    #[cfg(feature = "v1_2")]
3409    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3410    pub fn adw_about_window_set_developer_name(
3411        self_: *mut AdwAboutWindow,
3412        developer_name: *const c_char,
3413    );
3414    #[cfg(feature = "v1_2")]
3415    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3416    pub fn adw_about_window_set_developers(
3417        self_: *mut AdwAboutWindow,
3418        developers: *mut *const c_char,
3419    );
3420    #[cfg(feature = "v1_2")]
3421    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3422    pub fn adw_about_window_set_documenters(
3423        self_: *mut AdwAboutWindow,
3424        documenters: *mut *const c_char,
3425    );
3426    #[cfg(feature = "v1_2")]
3427    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3428    pub fn adw_about_window_set_issue_url(self_: *mut AdwAboutWindow, issue_url: *const c_char);
3429    #[cfg(feature = "v1_2")]
3430    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3431    pub fn adw_about_window_set_license(self_: *mut AdwAboutWindow, license: *const c_char);
3432    #[cfg(feature = "v1_2")]
3433    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3434    pub fn adw_about_window_set_license_type(
3435        self_: *mut AdwAboutWindow,
3436        license_type: gtk::GtkLicense,
3437    );
3438    #[cfg(feature = "v1_2")]
3439    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3440    pub fn adw_about_window_set_release_notes(
3441        self_: *mut AdwAboutWindow,
3442        release_notes: *const c_char,
3443    );
3444    #[cfg(feature = "v1_2")]
3445    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3446    pub fn adw_about_window_set_release_notes_version(
3447        self_: *mut AdwAboutWindow,
3448        version: *const c_char,
3449    );
3450    #[cfg(feature = "v1_2")]
3451    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3452    pub fn adw_about_window_set_support_url(self_: *mut AdwAboutWindow, support_url: *const c_char);
3453    #[cfg(feature = "v1_2")]
3454    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3455    pub fn adw_about_window_set_translator_credits(
3456        self_: *mut AdwAboutWindow,
3457        translator_credits: *const c_char,
3458    );
3459    #[cfg(feature = "v1_2")]
3460    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3461    pub fn adw_about_window_set_version(self_: *mut AdwAboutWindow, version: *const c_char);
3462    #[cfg(feature = "v1_2")]
3463    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
3464    pub fn adw_about_window_set_website(self_: *mut AdwAboutWindow, website: *const c_char);
3465
3466    //=========================================================================
3467    // AdwActionRow
3468    //=========================================================================
3469    pub fn adw_action_row_get_type() -> GType;
3470    pub fn adw_action_row_new() -> *mut gtk::GtkWidget;
3471    pub fn adw_action_row_activate(self_: *mut AdwActionRow);
3472    pub fn adw_action_row_add_prefix(self_: *mut AdwActionRow, widget: *mut gtk::GtkWidget);
3473    pub fn adw_action_row_add_suffix(self_: *mut AdwActionRow, widget: *mut gtk::GtkWidget);
3474    pub fn adw_action_row_get_activatable_widget(self_: *mut AdwActionRow) -> *mut gtk::GtkWidget;
3475    pub fn adw_action_row_get_icon_name(self_: *mut AdwActionRow) -> *const c_char;
3476    pub fn adw_action_row_get_subtitle(self_: *mut AdwActionRow) -> *const c_char;
3477    pub fn adw_action_row_get_subtitle_lines(self_: *mut AdwActionRow) -> c_int;
3478    #[cfg(feature = "v1_3")]
3479    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
3480    pub fn adw_action_row_get_subtitle_selectable(self_: *mut AdwActionRow) -> gboolean;
3481    pub fn adw_action_row_get_title_lines(self_: *mut AdwActionRow) -> c_int;
3482    pub fn adw_action_row_remove(self_: *mut AdwActionRow, widget: *mut gtk::GtkWidget);
3483    pub fn adw_action_row_set_activatable_widget(
3484        self_: *mut AdwActionRow,
3485        widget: *mut gtk::GtkWidget,
3486    );
3487    pub fn adw_action_row_set_icon_name(self_: *mut AdwActionRow, icon_name: *const c_char);
3488    pub fn adw_action_row_set_subtitle(self_: *mut AdwActionRow, subtitle: *const c_char);
3489    pub fn adw_action_row_set_subtitle_lines(self_: *mut AdwActionRow, subtitle_lines: c_int);
3490    #[cfg(feature = "v1_3")]
3491    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
3492    pub fn adw_action_row_set_subtitle_selectable(
3493        self_: *mut AdwActionRow,
3494        subtitle_selectable: gboolean,
3495    );
3496    pub fn adw_action_row_set_title_lines(self_: *mut AdwActionRow, title_lines: c_int);
3497
3498    //=========================================================================
3499    // AdwAlertDialog
3500    //=========================================================================
3501    #[cfg(feature = "v1_5")]
3502    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3503    pub fn adw_alert_dialog_get_type() -> GType;
3504    #[cfg(feature = "v1_5")]
3505    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3506    pub fn adw_alert_dialog_new(heading: *const c_char, body: *const c_char) -> *mut AdwDialog;
3507    #[cfg(feature = "v1_5")]
3508    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3509    pub fn adw_alert_dialog_add_response(
3510        self_: *mut AdwAlertDialog,
3511        id: *const c_char,
3512        label: *const c_char,
3513    );
3514    #[cfg(feature = "v1_5")]
3515    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3516    pub fn adw_alert_dialog_add_responses(self_: *mut AdwAlertDialog, first_id: *const c_char, ...);
3517    #[cfg(feature = "v1_5")]
3518    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3519    pub fn adw_alert_dialog_choose(
3520        self_: *mut AdwAlertDialog,
3521        parent: *mut gtk::GtkWidget,
3522        cancellable: *mut gio::GCancellable,
3523        callback: gio::GAsyncReadyCallback,
3524        user_data: gpointer,
3525    );
3526    #[cfg(feature = "v1_5")]
3527    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3528    pub fn adw_alert_dialog_choose_finish(
3529        self_: *mut AdwAlertDialog,
3530        result: *mut gio::GAsyncResult,
3531    ) -> *const c_char;
3532    #[cfg(feature = "v1_5")]
3533    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3534    pub fn adw_alert_dialog_format_body(self_: *mut AdwAlertDialog, format: *const c_char, ...);
3535    #[cfg(feature = "v1_5")]
3536    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3537    pub fn adw_alert_dialog_format_body_markup(
3538        self_: *mut AdwAlertDialog,
3539        format: *const c_char,
3540        ...
3541    );
3542    #[cfg(feature = "v1_5")]
3543    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3544    pub fn adw_alert_dialog_format_heading(self_: *mut AdwAlertDialog, format: *const c_char, ...);
3545    #[cfg(feature = "v1_5")]
3546    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3547    pub fn adw_alert_dialog_format_heading_markup(
3548        self_: *mut AdwAlertDialog,
3549        format: *const c_char,
3550        ...
3551    );
3552    #[cfg(feature = "v1_5")]
3553    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3554    pub fn adw_alert_dialog_get_body(self_: *mut AdwAlertDialog) -> *const c_char;
3555    #[cfg(feature = "v1_5")]
3556    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3557    pub fn adw_alert_dialog_get_body_use_markup(self_: *mut AdwAlertDialog) -> gboolean;
3558    #[cfg(feature = "v1_5")]
3559    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3560    pub fn adw_alert_dialog_get_close_response(self_: *mut AdwAlertDialog) -> *const c_char;
3561    #[cfg(feature = "v1_5")]
3562    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3563    pub fn adw_alert_dialog_get_default_response(self_: *mut AdwAlertDialog) -> *const c_char;
3564    #[cfg(feature = "v1_5")]
3565    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3566    pub fn adw_alert_dialog_get_extra_child(self_: *mut AdwAlertDialog) -> *mut gtk::GtkWidget;
3567    #[cfg(feature = "v1_5")]
3568    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3569    pub fn adw_alert_dialog_get_heading(self_: *mut AdwAlertDialog) -> *const c_char;
3570    #[cfg(feature = "v1_5")]
3571    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3572    pub fn adw_alert_dialog_get_heading_use_markup(self_: *mut AdwAlertDialog) -> gboolean;
3573    #[cfg(feature = "v1_5")]
3574    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3575    pub fn adw_alert_dialog_get_prefer_wide_layout(self_: *mut AdwAlertDialog) -> gboolean;
3576    #[cfg(feature = "v1_5")]
3577    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3578    pub fn adw_alert_dialog_get_response_appearance(
3579        self_: *mut AdwAlertDialog,
3580        response: *const c_char,
3581    ) -> AdwResponseAppearance;
3582    #[cfg(feature = "v1_5")]
3583    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3584    pub fn adw_alert_dialog_get_response_enabled(
3585        self_: *mut AdwAlertDialog,
3586        response: *const c_char,
3587    ) -> gboolean;
3588    #[cfg(feature = "v1_5")]
3589    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3590    pub fn adw_alert_dialog_get_response_label(
3591        self_: *mut AdwAlertDialog,
3592        response: *const c_char,
3593    ) -> *const c_char;
3594    #[cfg(feature = "v1_5")]
3595    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3596    pub fn adw_alert_dialog_has_response(
3597        self_: *mut AdwAlertDialog,
3598        response: *const c_char,
3599    ) -> gboolean;
3600    #[cfg(feature = "v1_5")]
3601    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3602    pub fn adw_alert_dialog_remove_response(self_: *mut AdwAlertDialog, id: *const c_char);
3603    #[cfg(feature = "v1_5")]
3604    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3605    pub fn adw_alert_dialog_set_body(self_: *mut AdwAlertDialog, body: *const c_char);
3606    #[cfg(feature = "v1_5")]
3607    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3608    pub fn adw_alert_dialog_set_body_use_markup(self_: *mut AdwAlertDialog, use_markup: gboolean);
3609    #[cfg(feature = "v1_5")]
3610    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3611    pub fn adw_alert_dialog_set_close_response(self_: *mut AdwAlertDialog, response: *const c_char);
3612    #[cfg(feature = "v1_5")]
3613    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3614    pub fn adw_alert_dialog_set_default_response(
3615        self_: *mut AdwAlertDialog,
3616        response: *const c_char,
3617    );
3618    #[cfg(feature = "v1_5")]
3619    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3620    pub fn adw_alert_dialog_set_extra_child(self_: *mut AdwAlertDialog, child: *mut gtk::GtkWidget);
3621    #[cfg(feature = "v1_5")]
3622    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3623    pub fn adw_alert_dialog_set_heading(self_: *mut AdwAlertDialog, heading: *const c_char);
3624    #[cfg(feature = "v1_5")]
3625    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3626    pub fn adw_alert_dialog_set_heading_use_markup(
3627        self_: *mut AdwAlertDialog,
3628        use_markup: gboolean,
3629    );
3630    #[cfg(feature = "v1_6")]
3631    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3632    pub fn adw_alert_dialog_set_prefer_wide_layout(
3633        self_: *mut AdwAlertDialog,
3634        prefer_wide_layout: gboolean,
3635    );
3636    #[cfg(feature = "v1_5")]
3637    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3638    pub fn adw_alert_dialog_set_response_appearance(
3639        self_: *mut AdwAlertDialog,
3640        response: *const c_char,
3641        appearance: AdwResponseAppearance,
3642    );
3643    #[cfg(feature = "v1_5")]
3644    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3645    pub fn adw_alert_dialog_set_response_enabled(
3646        self_: *mut AdwAlertDialog,
3647        response: *const c_char,
3648        enabled: gboolean,
3649    );
3650    #[cfg(feature = "v1_5")]
3651    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3652    pub fn adw_alert_dialog_set_response_label(
3653        self_: *mut AdwAlertDialog,
3654        response: *const c_char,
3655        label: *const c_char,
3656    );
3657
3658    //=========================================================================
3659    // AdwAnimation
3660    //=========================================================================
3661    pub fn adw_animation_get_type() -> GType;
3662    #[cfg(feature = "v1_3")]
3663    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
3664    pub fn adw_animation_get_follow_enable_animations_setting(self_: *mut AdwAnimation)
3665    -> gboolean;
3666    pub fn adw_animation_get_state(self_: *mut AdwAnimation) -> AdwAnimationState;
3667    pub fn adw_animation_get_target(self_: *mut AdwAnimation) -> *mut AdwAnimationTarget;
3668    pub fn adw_animation_get_value(self_: *mut AdwAnimation) -> c_double;
3669    pub fn adw_animation_get_widget(self_: *mut AdwAnimation) -> *mut gtk::GtkWidget;
3670    pub fn adw_animation_pause(self_: *mut AdwAnimation);
3671    pub fn adw_animation_play(self_: *mut AdwAnimation);
3672    pub fn adw_animation_reset(self_: *mut AdwAnimation);
3673    pub fn adw_animation_resume(self_: *mut AdwAnimation);
3674    #[cfg(feature = "v1_3")]
3675    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
3676    pub fn adw_animation_set_follow_enable_animations_setting(
3677        self_: *mut AdwAnimation,
3678        setting: gboolean,
3679    );
3680    pub fn adw_animation_set_target(self_: *mut AdwAnimation, target: *mut AdwAnimationTarget);
3681    pub fn adw_animation_skip(self_: *mut AdwAnimation);
3682
3683    //=========================================================================
3684    // AdwAnimationTarget
3685    //=========================================================================
3686    pub fn adw_animation_target_get_type() -> GType;
3687
3688    //=========================================================================
3689    // AdwApplication
3690    //=========================================================================
3691    pub fn adw_application_get_type() -> GType;
3692    pub fn adw_application_new(
3693        application_id: *const c_char,
3694        flags: gio::GApplicationFlags,
3695    ) -> *mut AdwApplication;
3696    pub fn adw_application_get_style_manager(self_: *mut AdwApplication) -> *mut AdwStyleManager;
3697
3698    //=========================================================================
3699    // AdwApplicationWindow
3700    //=========================================================================
3701    pub fn adw_application_window_get_type() -> GType;
3702    pub fn adw_application_window_new(app: *mut gtk::GtkApplication) -> *mut gtk::GtkWidget;
3703    #[cfg(feature = "v1_4")]
3704    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3705    pub fn adw_application_window_add_breakpoint(
3706        self_: *mut AdwApplicationWindow,
3707        breakpoint: *mut AdwBreakpoint,
3708    );
3709    #[cfg(feature = "v1_7")]
3710    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
3711    pub fn adw_application_window_get_adaptive_preview(
3712        self_: *mut AdwApplicationWindow,
3713    ) -> gboolean;
3714    pub fn adw_application_window_get_content(
3715        self_: *mut AdwApplicationWindow,
3716    ) -> *mut gtk::GtkWidget;
3717    #[cfg(feature = "v1_4")]
3718    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3719    pub fn adw_application_window_get_current_breakpoint(
3720        self_: *mut AdwApplicationWindow,
3721    ) -> *mut AdwBreakpoint;
3722    #[cfg(feature = "v1_5")]
3723    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3724    pub fn adw_application_window_get_dialogs(
3725        self_: *mut AdwApplicationWindow,
3726    ) -> *mut gio::GListModel;
3727    #[cfg(feature = "v1_5")]
3728    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3729    pub fn adw_application_window_get_visible_dialog(
3730        self_: *mut AdwApplicationWindow,
3731    ) -> *mut AdwDialog;
3732    #[cfg(feature = "v1_7")]
3733    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
3734    pub fn adw_application_window_set_adaptive_preview(
3735        self_: *mut AdwApplicationWindow,
3736        adaptive_preview: gboolean,
3737    );
3738    pub fn adw_application_window_set_content(
3739        self_: *mut AdwApplicationWindow,
3740        content: *mut gtk::GtkWidget,
3741    );
3742
3743    //=========================================================================
3744    // AdwAvatar
3745    //=========================================================================
3746    pub fn adw_avatar_get_type() -> GType;
3747    pub fn adw_avatar_new(
3748        size: c_int,
3749        text: *const c_char,
3750        show_initials: gboolean,
3751    ) -> *mut gtk::GtkWidget;
3752    pub fn adw_avatar_draw_to_texture(
3753        self_: *mut AdwAvatar,
3754        scale_factor: c_int,
3755    ) -> *mut gdk::GdkTexture;
3756    pub fn adw_avatar_get_custom_image(self_: *mut AdwAvatar) -> *mut gdk::GdkPaintable;
3757    pub fn adw_avatar_get_icon_name(self_: *mut AdwAvatar) -> *const c_char;
3758    pub fn adw_avatar_get_show_initials(self_: *mut AdwAvatar) -> gboolean;
3759    pub fn adw_avatar_get_size(self_: *mut AdwAvatar) -> c_int;
3760    pub fn adw_avatar_get_text(self_: *mut AdwAvatar) -> *const c_char;
3761    pub fn adw_avatar_set_custom_image(self_: *mut AdwAvatar, custom_image: *mut gdk::GdkPaintable);
3762    pub fn adw_avatar_set_icon_name(self_: *mut AdwAvatar, icon_name: *const c_char);
3763    pub fn adw_avatar_set_show_initials(self_: *mut AdwAvatar, show_initials: gboolean);
3764    pub fn adw_avatar_set_size(self_: *mut AdwAvatar, size: c_int);
3765    pub fn adw_avatar_set_text(self_: *mut AdwAvatar, text: *const c_char);
3766
3767    //=========================================================================
3768    // AdwBanner
3769    //=========================================================================
3770    #[cfg(feature = "v1_3")]
3771    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
3772    pub fn adw_banner_get_type() -> GType;
3773    #[cfg(feature = "v1_3")]
3774    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
3775    pub fn adw_banner_new(title: *const c_char) -> *mut gtk::GtkWidget;
3776    #[cfg(feature = "v1_3")]
3777    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
3778    pub fn adw_banner_get_button_label(self_: *mut AdwBanner) -> *const c_char;
3779    #[cfg(feature = "v1_7")]
3780    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
3781    pub fn adw_banner_get_button_style(self_: *mut AdwBanner) -> AdwBannerButtonStyle;
3782    #[cfg(feature = "v1_3")]
3783    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
3784    pub fn adw_banner_get_revealed(self_: *mut AdwBanner) -> gboolean;
3785    #[cfg(feature = "v1_3")]
3786    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
3787    pub fn adw_banner_get_title(self_: *mut AdwBanner) -> *const c_char;
3788    #[cfg(feature = "v1_3")]
3789    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
3790    pub fn adw_banner_get_use_markup(self_: *mut AdwBanner) -> gboolean;
3791    #[cfg(feature = "v1_3")]
3792    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
3793    pub fn adw_banner_set_button_label(self_: *mut AdwBanner, label: *const c_char);
3794    #[cfg(feature = "v1_7")]
3795    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
3796    pub fn adw_banner_set_button_style(self_: *mut AdwBanner, style: AdwBannerButtonStyle);
3797    #[cfg(feature = "v1_3")]
3798    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
3799    pub fn adw_banner_set_revealed(self_: *mut AdwBanner, revealed: gboolean);
3800    #[cfg(feature = "v1_3")]
3801    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
3802    pub fn adw_banner_set_title(self_: *mut AdwBanner, title: *const c_char);
3803    #[cfg(feature = "v1_3")]
3804    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
3805    pub fn adw_banner_set_use_markup(self_: *mut AdwBanner, use_markup: gboolean);
3806
3807    //=========================================================================
3808    // AdwBin
3809    //=========================================================================
3810    pub fn adw_bin_get_type() -> GType;
3811    pub fn adw_bin_new() -> *mut gtk::GtkWidget;
3812    pub fn adw_bin_get_child(self_: *mut AdwBin) -> *mut gtk::GtkWidget;
3813    pub fn adw_bin_set_child(self_: *mut AdwBin, child: *mut gtk::GtkWidget);
3814
3815    //=========================================================================
3816    // AdwBottomSheet
3817    //=========================================================================
3818    #[cfg(feature = "v1_6")]
3819    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3820    pub fn adw_bottom_sheet_get_type() -> GType;
3821    #[cfg(feature = "v1_6")]
3822    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3823    pub fn adw_bottom_sheet_new() -> *mut gtk::GtkWidget;
3824    #[cfg(feature = "v1_6")]
3825    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3826    pub fn adw_bottom_sheet_get_align(self_: *mut AdwBottomSheet) -> c_float;
3827    #[cfg(feature = "v1_6")]
3828    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3829    pub fn adw_bottom_sheet_get_bottom_bar(self_: *mut AdwBottomSheet) -> *mut gtk::GtkWidget;
3830    #[cfg(feature = "v1_6")]
3831    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3832    pub fn adw_bottom_sheet_get_bottom_bar_height(self_: *mut AdwBottomSheet) -> c_int;
3833    #[cfg(feature = "v1_6")]
3834    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3835    pub fn adw_bottom_sheet_get_can_close(self_: *mut AdwBottomSheet) -> gboolean;
3836    #[cfg(feature = "v1_6")]
3837    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3838    pub fn adw_bottom_sheet_get_can_open(self_: *mut AdwBottomSheet) -> gboolean;
3839    #[cfg(feature = "v1_6")]
3840    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3841    pub fn adw_bottom_sheet_get_content(self_: *mut AdwBottomSheet) -> *mut gtk::GtkWidget;
3842    #[cfg(feature = "v1_6")]
3843    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3844    pub fn adw_bottom_sheet_get_full_width(self_: *mut AdwBottomSheet) -> gboolean;
3845    #[cfg(feature = "v1_6")]
3846    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3847    pub fn adw_bottom_sheet_get_modal(self_: *mut AdwBottomSheet) -> gboolean;
3848    #[cfg(feature = "v1_6")]
3849    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3850    pub fn adw_bottom_sheet_get_open(self_: *mut AdwBottomSheet) -> gboolean;
3851    #[cfg(feature = "v1_7")]
3852    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
3853    pub fn adw_bottom_sheet_get_reveal_bottom_bar(self_: *mut AdwBottomSheet) -> gboolean;
3854    #[cfg(feature = "v1_6")]
3855    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3856    pub fn adw_bottom_sheet_get_sheet(self_: *mut AdwBottomSheet) -> *mut gtk::GtkWidget;
3857    #[cfg(feature = "v1_6")]
3858    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3859    pub fn adw_bottom_sheet_get_sheet_height(self_: *mut AdwBottomSheet) -> c_int;
3860    #[cfg(feature = "v1_6")]
3861    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3862    pub fn adw_bottom_sheet_get_show_drag_handle(self_: *mut AdwBottomSheet) -> gboolean;
3863    #[cfg(feature = "v1_6")]
3864    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3865    pub fn adw_bottom_sheet_set_align(self_: *mut AdwBottomSheet, align: c_float);
3866    #[cfg(feature = "v1_6")]
3867    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3868    pub fn adw_bottom_sheet_set_bottom_bar(
3869        self_: *mut AdwBottomSheet,
3870        bottom_bar: *mut gtk::GtkWidget,
3871    );
3872    #[cfg(feature = "v1_6")]
3873    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3874    pub fn adw_bottom_sheet_set_can_close(self_: *mut AdwBottomSheet, can_close: gboolean);
3875    #[cfg(feature = "v1_6")]
3876    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3877    pub fn adw_bottom_sheet_set_can_open(self_: *mut AdwBottomSheet, can_open: gboolean);
3878    #[cfg(feature = "v1_6")]
3879    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3880    pub fn adw_bottom_sheet_set_content(self_: *mut AdwBottomSheet, content: *mut gtk::GtkWidget);
3881    #[cfg(feature = "v1_6")]
3882    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3883    pub fn adw_bottom_sheet_set_full_width(self_: *mut AdwBottomSheet, full_width: gboolean);
3884    #[cfg(feature = "v1_6")]
3885    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3886    pub fn adw_bottom_sheet_set_modal(self_: *mut AdwBottomSheet, modal: gboolean);
3887    #[cfg(feature = "v1_6")]
3888    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3889    pub fn adw_bottom_sheet_set_open(self_: *mut AdwBottomSheet, open: gboolean);
3890    #[cfg(feature = "v1_7")]
3891    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
3892    pub fn adw_bottom_sheet_set_reveal_bottom_bar(self_: *mut AdwBottomSheet, reveal: gboolean);
3893    #[cfg(feature = "v1_6")]
3894    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3895    pub fn adw_bottom_sheet_set_sheet(self_: *mut AdwBottomSheet, sheet: *mut gtk::GtkWidget);
3896    #[cfg(feature = "v1_6")]
3897    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
3898    pub fn adw_bottom_sheet_set_show_drag_handle(
3899        self_: *mut AdwBottomSheet,
3900        show_drag_handle: gboolean,
3901    );
3902
3903    //=========================================================================
3904    // AdwBreakpoint
3905    //=========================================================================
3906    #[cfg(feature = "v1_4")]
3907    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3908    pub fn adw_breakpoint_get_type() -> GType;
3909    #[cfg(feature = "v1_4")]
3910    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3911    pub fn adw_breakpoint_new(condition: *mut AdwBreakpointCondition) -> *mut AdwBreakpoint;
3912    #[cfg(feature = "v1_4")]
3913    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3914    pub fn adw_breakpoint_add_setter(
3915        self_: *mut AdwBreakpoint,
3916        object: *mut gobject::GObject,
3917        property: *const c_char,
3918        value: *const gobject::GValue,
3919    );
3920    #[cfg(feature = "v1_4")]
3921    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3922    pub fn adw_breakpoint_add_setters(
3923        self_: *mut AdwBreakpoint,
3924        first_object: *mut gobject::GObject,
3925        first_property: *const c_char,
3926        ...
3927    );
3928    //#[cfg(feature = "v1_4")]
3929    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3930    //pub fn adw_breakpoint_add_setters_valist(self_: *mut AdwBreakpoint, first_object: *mut gobject::GObject, first_property: *const c_char, args: /*Unimplemented*/va_list);
3931    #[cfg(feature = "v1_4")]
3932    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3933    pub fn adw_breakpoint_add_settersv(
3934        self_: *mut AdwBreakpoint,
3935        n_setters: c_int,
3936        objects: *mut *mut gobject::GObject,
3937        names: *mut *const c_char,
3938        values: *mut *const gobject::GValue,
3939    );
3940    #[cfg(feature = "v1_4")]
3941    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3942    pub fn adw_breakpoint_get_condition(self_: *mut AdwBreakpoint) -> *mut AdwBreakpointCondition;
3943    #[cfg(feature = "v1_4")]
3944    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3945    pub fn adw_breakpoint_set_condition(
3946        self_: *mut AdwBreakpoint,
3947        condition: *mut AdwBreakpointCondition,
3948    );
3949
3950    //=========================================================================
3951    // AdwBreakpointBin
3952    //=========================================================================
3953    #[cfg(feature = "v1_4")]
3954    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3955    pub fn adw_breakpoint_bin_get_type() -> GType;
3956    #[cfg(feature = "v1_4")]
3957    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3958    pub fn adw_breakpoint_bin_new() -> *mut gtk::GtkWidget;
3959    #[cfg(feature = "v1_4")]
3960    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3961    pub fn adw_breakpoint_bin_add_breakpoint(
3962        self_: *mut AdwBreakpointBin,
3963        breakpoint: *mut AdwBreakpoint,
3964    );
3965    #[cfg(feature = "v1_4")]
3966    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3967    pub fn adw_breakpoint_bin_get_child(self_: *mut AdwBreakpointBin) -> *mut gtk::GtkWidget;
3968    #[cfg(feature = "v1_4")]
3969    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3970    pub fn adw_breakpoint_bin_get_current_breakpoint(
3971        self_: *mut AdwBreakpointBin,
3972    ) -> *mut AdwBreakpoint;
3973    #[cfg(feature = "v1_5")]
3974    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
3975    pub fn adw_breakpoint_bin_remove_breakpoint(
3976        self_: *mut AdwBreakpointBin,
3977        breakpoint: *mut AdwBreakpoint,
3978    );
3979    #[cfg(feature = "v1_4")]
3980    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3981    pub fn adw_breakpoint_bin_set_child(self_: *mut AdwBreakpointBin, child: *mut gtk::GtkWidget);
3982
3983    //=========================================================================
3984    // AdwButtonContent
3985    //=========================================================================
3986    pub fn adw_button_content_get_type() -> GType;
3987    pub fn adw_button_content_new() -> *mut gtk::GtkWidget;
3988    #[cfg(feature = "v1_4")]
3989    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3990    pub fn adw_button_content_get_can_shrink(self_: *mut AdwButtonContent) -> gboolean;
3991    pub fn adw_button_content_get_icon_name(self_: *mut AdwButtonContent) -> *const c_char;
3992    pub fn adw_button_content_get_label(self_: *mut AdwButtonContent) -> *const c_char;
3993    pub fn adw_button_content_get_use_underline(self_: *mut AdwButtonContent) -> gboolean;
3994    #[cfg(feature = "v1_4")]
3995    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
3996    pub fn adw_button_content_set_can_shrink(self_: *mut AdwButtonContent, can_shrink: gboolean);
3997    pub fn adw_button_content_set_icon_name(self_: *mut AdwButtonContent, icon_name: *const c_char);
3998    pub fn adw_button_content_set_label(self_: *mut AdwButtonContent, label: *const c_char);
3999    pub fn adw_button_content_set_use_underline(
4000        self_: *mut AdwButtonContent,
4001        use_underline: gboolean,
4002    );
4003
4004    //=========================================================================
4005    // AdwButtonRow
4006    //=========================================================================
4007    #[cfg(feature = "v1_6")]
4008    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4009    pub fn adw_button_row_get_type() -> GType;
4010    #[cfg(feature = "v1_6")]
4011    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4012    pub fn adw_button_row_new() -> *mut gtk::GtkWidget;
4013    #[cfg(feature = "v1_6")]
4014    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4015    pub fn adw_button_row_get_end_icon_name(self_: *mut AdwButtonRow) -> *const c_char;
4016    #[cfg(feature = "v1_6")]
4017    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4018    pub fn adw_button_row_get_start_icon_name(self_: *mut AdwButtonRow) -> *const c_char;
4019    #[cfg(feature = "v1_6")]
4020    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4021    pub fn adw_button_row_set_end_icon_name(self_: *mut AdwButtonRow, icon_name: *const c_char);
4022    #[cfg(feature = "v1_6")]
4023    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4024    pub fn adw_button_row_set_start_icon_name(self_: *mut AdwButtonRow, icon_name: *const c_char);
4025
4026    //=========================================================================
4027    // AdwCallbackAnimationTarget
4028    //=========================================================================
4029    pub fn adw_callback_animation_target_get_type() -> GType;
4030    pub fn adw_callback_animation_target_new(
4031        callback: AdwAnimationTargetFunc,
4032        user_data: gpointer,
4033        destroy: glib::GDestroyNotify,
4034    ) -> *mut AdwAnimationTarget;
4035
4036    //=========================================================================
4037    // AdwCarousel
4038    //=========================================================================
4039    pub fn adw_carousel_get_type() -> GType;
4040    pub fn adw_carousel_new() -> *mut gtk::GtkWidget;
4041    pub fn adw_carousel_append(self_: *mut AdwCarousel, child: *mut gtk::GtkWidget);
4042    pub fn adw_carousel_get_allow_long_swipes(self_: *mut AdwCarousel) -> gboolean;
4043    pub fn adw_carousel_get_allow_mouse_drag(self_: *mut AdwCarousel) -> gboolean;
4044    pub fn adw_carousel_get_allow_scroll_wheel(self_: *mut AdwCarousel) -> gboolean;
4045    pub fn adw_carousel_get_interactive(self_: *mut AdwCarousel) -> gboolean;
4046    pub fn adw_carousel_get_n_pages(self_: *mut AdwCarousel) -> c_uint;
4047    pub fn adw_carousel_get_nth_page(self_: *mut AdwCarousel, n: c_uint) -> *mut gtk::GtkWidget;
4048    pub fn adw_carousel_get_position(self_: *mut AdwCarousel) -> c_double;
4049    pub fn adw_carousel_get_reveal_duration(self_: *mut AdwCarousel) -> c_uint;
4050    pub fn adw_carousel_get_scroll_params(self_: *mut AdwCarousel) -> *mut AdwSpringParams;
4051    pub fn adw_carousel_get_spacing(self_: *mut AdwCarousel) -> c_uint;
4052    pub fn adw_carousel_insert(
4053        self_: *mut AdwCarousel,
4054        child: *mut gtk::GtkWidget,
4055        position: c_int,
4056    );
4057    pub fn adw_carousel_prepend(self_: *mut AdwCarousel, child: *mut gtk::GtkWidget);
4058    pub fn adw_carousel_remove(self_: *mut AdwCarousel, child: *mut gtk::GtkWidget);
4059    pub fn adw_carousel_reorder(
4060        self_: *mut AdwCarousel,
4061        child: *mut gtk::GtkWidget,
4062        position: c_int,
4063    );
4064    pub fn adw_carousel_scroll_to(
4065        self_: *mut AdwCarousel,
4066        widget: *mut gtk::GtkWidget,
4067        animate: gboolean,
4068    );
4069    pub fn adw_carousel_set_allow_long_swipes(self_: *mut AdwCarousel, allow_long_swipes: gboolean);
4070    pub fn adw_carousel_set_allow_mouse_drag(self_: *mut AdwCarousel, allow_mouse_drag: gboolean);
4071    pub fn adw_carousel_set_allow_scroll_wheel(
4072        self_: *mut AdwCarousel,
4073        allow_scroll_wheel: gboolean,
4074    );
4075    pub fn adw_carousel_set_interactive(self_: *mut AdwCarousel, interactive: gboolean);
4076    pub fn adw_carousel_set_reveal_duration(self_: *mut AdwCarousel, reveal_duration: c_uint);
4077    pub fn adw_carousel_set_scroll_params(self_: *mut AdwCarousel, params: *mut AdwSpringParams);
4078    pub fn adw_carousel_set_spacing(self_: *mut AdwCarousel, spacing: c_uint);
4079
4080    //=========================================================================
4081    // AdwCarouselIndicatorDots
4082    //=========================================================================
4083    pub fn adw_carousel_indicator_dots_get_type() -> GType;
4084    pub fn adw_carousel_indicator_dots_new() -> *mut gtk::GtkWidget;
4085    pub fn adw_carousel_indicator_dots_get_carousel(
4086        self_: *mut AdwCarouselIndicatorDots,
4087    ) -> *mut AdwCarousel;
4088    pub fn adw_carousel_indicator_dots_set_carousel(
4089        self_: *mut AdwCarouselIndicatorDots,
4090        carousel: *mut AdwCarousel,
4091    );
4092
4093    //=========================================================================
4094    // AdwCarouselIndicatorLines
4095    //=========================================================================
4096    pub fn adw_carousel_indicator_lines_get_type() -> GType;
4097    pub fn adw_carousel_indicator_lines_new() -> *mut gtk::GtkWidget;
4098    pub fn adw_carousel_indicator_lines_get_carousel(
4099        self_: *mut AdwCarouselIndicatorLines,
4100    ) -> *mut AdwCarousel;
4101    pub fn adw_carousel_indicator_lines_set_carousel(
4102        self_: *mut AdwCarouselIndicatorLines,
4103        carousel: *mut AdwCarousel,
4104    );
4105
4106    //=========================================================================
4107    // AdwClamp
4108    //=========================================================================
4109    pub fn adw_clamp_get_type() -> GType;
4110    pub fn adw_clamp_new() -> *mut gtk::GtkWidget;
4111    pub fn adw_clamp_get_child(self_: *mut AdwClamp) -> *mut gtk::GtkWidget;
4112    pub fn adw_clamp_get_maximum_size(self_: *mut AdwClamp) -> c_int;
4113    pub fn adw_clamp_get_tightening_threshold(self_: *mut AdwClamp) -> c_int;
4114    #[cfg(feature = "v1_4")]
4115    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4116    pub fn adw_clamp_get_unit(self_: *mut AdwClamp) -> AdwLengthUnit;
4117    pub fn adw_clamp_set_child(self_: *mut AdwClamp, child: *mut gtk::GtkWidget);
4118    pub fn adw_clamp_set_maximum_size(self_: *mut AdwClamp, maximum_size: c_int);
4119    pub fn adw_clamp_set_tightening_threshold(self_: *mut AdwClamp, tightening_threshold: c_int);
4120    #[cfg(feature = "v1_4")]
4121    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4122    pub fn adw_clamp_set_unit(self_: *mut AdwClamp, unit: AdwLengthUnit);
4123
4124    //=========================================================================
4125    // AdwClampLayout
4126    //=========================================================================
4127    pub fn adw_clamp_layout_get_type() -> GType;
4128    pub fn adw_clamp_layout_new() -> *mut gtk::GtkLayoutManager;
4129    pub fn adw_clamp_layout_get_maximum_size(self_: *mut AdwClampLayout) -> c_int;
4130    pub fn adw_clamp_layout_get_tightening_threshold(self_: *mut AdwClampLayout) -> c_int;
4131    #[cfg(feature = "v1_4")]
4132    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4133    pub fn adw_clamp_layout_get_unit(self_: *mut AdwClampLayout) -> AdwLengthUnit;
4134    pub fn adw_clamp_layout_set_maximum_size(self_: *mut AdwClampLayout, maximum_size: c_int);
4135    pub fn adw_clamp_layout_set_tightening_threshold(
4136        self_: *mut AdwClampLayout,
4137        tightening_threshold: c_int,
4138    );
4139    #[cfg(feature = "v1_4")]
4140    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4141    pub fn adw_clamp_layout_set_unit(self_: *mut AdwClampLayout, unit: AdwLengthUnit);
4142
4143    //=========================================================================
4144    // AdwClampScrollable
4145    //=========================================================================
4146    pub fn adw_clamp_scrollable_get_type() -> GType;
4147    pub fn adw_clamp_scrollable_new() -> *mut gtk::GtkWidget;
4148    pub fn adw_clamp_scrollable_get_child(self_: *mut AdwClampScrollable) -> *mut gtk::GtkWidget;
4149    pub fn adw_clamp_scrollable_get_maximum_size(self_: *mut AdwClampScrollable) -> c_int;
4150    pub fn adw_clamp_scrollable_get_tightening_threshold(self_: *mut AdwClampScrollable) -> c_int;
4151    #[cfg(feature = "v1_4")]
4152    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4153    pub fn adw_clamp_scrollable_get_unit(self_: *mut AdwClampScrollable) -> AdwLengthUnit;
4154    pub fn adw_clamp_scrollable_set_child(
4155        self_: *mut AdwClampScrollable,
4156        child: *mut gtk::GtkWidget,
4157    );
4158    pub fn adw_clamp_scrollable_set_maximum_size(
4159        self_: *mut AdwClampScrollable,
4160        maximum_size: c_int,
4161    );
4162    pub fn adw_clamp_scrollable_set_tightening_threshold(
4163        self_: *mut AdwClampScrollable,
4164        tightening_threshold: c_int,
4165    );
4166    #[cfg(feature = "v1_4")]
4167    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4168    pub fn adw_clamp_scrollable_set_unit(self_: *mut AdwClampScrollable, unit: AdwLengthUnit);
4169
4170    //=========================================================================
4171    // AdwComboRow
4172    //=========================================================================
4173    pub fn adw_combo_row_get_type() -> GType;
4174    pub fn adw_combo_row_new() -> *mut gtk::GtkWidget;
4175    #[cfg(feature = "v1_4")]
4176    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4177    pub fn adw_combo_row_get_enable_search(self_: *mut AdwComboRow) -> gboolean;
4178    pub fn adw_combo_row_get_expression(self_: *mut AdwComboRow) -> *mut gtk::GtkExpression;
4179    pub fn adw_combo_row_get_factory(self_: *mut AdwComboRow) -> *mut gtk::GtkListItemFactory;
4180    #[cfg(feature = "v1_6")]
4181    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4182    pub fn adw_combo_row_get_header_factory(
4183        self_: *mut AdwComboRow,
4184    ) -> *mut gtk::GtkListItemFactory;
4185    pub fn adw_combo_row_get_list_factory(self_: *mut AdwComboRow) -> *mut gtk::GtkListItemFactory;
4186    pub fn adw_combo_row_get_model(self_: *mut AdwComboRow) -> *mut gio::GListModel;
4187    #[cfg(feature = "v1_6")]
4188    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4189    pub fn adw_combo_row_get_search_match_mode(
4190        self_: *mut AdwComboRow,
4191    ) -> gtk::GtkStringFilterMatchMode;
4192    pub fn adw_combo_row_get_selected(self_: *mut AdwComboRow) -> c_uint;
4193    pub fn adw_combo_row_get_selected_item(self_: *mut AdwComboRow) -> *mut gobject::GObject;
4194    pub fn adw_combo_row_get_use_subtitle(self_: *mut AdwComboRow) -> gboolean;
4195    #[cfg(feature = "v1_4")]
4196    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4197    pub fn adw_combo_row_set_enable_search(self_: *mut AdwComboRow, enable_search: gboolean);
4198    pub fn adw_combo_row_set_expression(
4199        self_: *mut AdwComboRow,
4200        expression: *mut gtk::GtkExpression,
4201    );
4202    pub fn adw_combo_row_set_factory(
4203        self_: *mut AdwComboRow,
4204        factory: *mut gtk::GtkListItemFactory,
4205    );
4206    #[cfg(feature = "v1_6")]
4207    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4208    pub fn adw_combo_row_set_header_factory(
4209        self_: *mut AdwComboRow,
4210        factory: *mut gtk::GtkListItemFactory,
4211    );
4212    pub fn adw_combo_row_set_list_factory(
4213        self_: *mut AdwComboRow,
4214        factory: *mut gtk::GtkListItemFactory,
4215    );
4216    pub fn adw_combo_row_set_model(self_: *mut AdwComboRow, model: *mut gio::GListModel);
4217    #[cfg(feature = "v1_6")]
4218    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4219    pub fn adw_combo_row_set_search_match_mode(
4220        self_: *mut AdwComboRow,
4221        search_match_mode: gtk::GtkStringFilterMatchMode,
4222    );
4223    pub fn adw_combo_row_set_selected(self_: *mut AdwComboRow, position: c_uint);
4224    pub fn adw_combo_row_set_use_subtitle(self_: *mut AdwComboRow, use_subtitle: gboolean);
4225
4226    //=========================================================================
4227    // AdwDialog
4228    //=========================================================================
4229    #[cfg(feature = "v1_5")]
4230    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4231    pub fn adw_dialog_get_type() -> GType;
4232    #[cfg(feature = "v1_5")]
4233    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4234    pub fn adw_dialog_new() -> *mut AdwDialog;
4235    #[cfg(feature = "v1_5")]
4236    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4237    pub fn adw_dialog_add_breakpoint(self_: *mut AdwDialog, breakpoint: *mut AdwBreakpoint);
4238    #[cfg(feature = "v1_5")]
4239    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4240    pub fn adw_dialog_close(self_: *mut AdwDialog) -> gboolean;
4241    #[cfg(feature = "v1_5")]
4242    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4243    pub fn adw_dialog_force_close(self_: *mut AdwDialog);
4244    #[cfg(feature = "v1_5")]
4245    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4246    pub fn adw_dialog_get_can_close(self_: *mut AdwDialog) -> gboolean;
4247    #[cfg(feature = "v1_5")]
4248    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4249    pub fn adw_dialog_get_child(self_: *mut AdwDialog) -> *mut gtk::GtkWidget;
4250    #[cfg(feature = "v1_5")]
4251    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4252    pub fn adw_dialog_get_content_height(self_: *mut AdwDialog) -> c_int;
4253    #[cfg(feature = "v1_5")]
4254    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4255    pub fn adw_dialog_get_content_width(self_: *mut AdwDialog) -> c_int;
4256    #[cfg(feature = "v1_5")]
4257    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4258    pub fn adw_dialog_get_current_breakpoint(self_: *mut AdwDialog) -> *mut AdwBreakpoint;
4259    #[cfg(feature = "v1_5")]
4260    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4261    pub fn adw_dialog_get_default_widget(self_: *mut AdwDialog) -> *mut gtk::GtkWidget;
4262    #[cfg(feature = "v1_5")]
4263    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4264    pub fn adw_dialog_get_focus(self_: *mut AdwDialog) -> *mut gtk::GtkWidget;
4265    #[cfg(feature = "v1_5")]
4266    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4267    pub fn adw_dialog_get_follows_content_size(self_: *mut AdwDialog) -> gboolean;
4268    #[cfg(feature = "v1_5")]
4269    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4270    pub fn adw_dialog_get_presentation_mode(self_: *mut AdwDialog) -> AdwDialogPresentationMode;
4271    #[cfg(feature = "v1_5")]
4272    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4273    pub fn adw_dialog_get_title(self_: *mut AdwDialog) -> *const c_char;
4274    #[cfg(feature = "v1_5")]
4275    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4276    pub fn adw_dialog_present(self_: *mut AdwDialog, parent: *mut gtk::GtkWidget);
4277    #[cfg(feature = "v1_5")]
4278    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4279    pub fn adw_dialog_set_can_close(self_: *mut AdwDialog, can_close: gboolean);
4280    #[cfg(feature = "v1_5")]
4281    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4282    pub fn adw_dialog_set_child(self_: *mut AdwDialog, child: *mut gtk::GtkWidget);
4283    #[cfg(feature = "v1_5")]
4284    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4285    pub fn adw_dialog_set_content_height(self_: *mut AdwDialog, content_height: c_int);
4286    #[cfg(feature = "v1_5")]
4287    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4288    pub fn adw_dialog_set_content_width(self_: *mut AdwDialog, content_width: c_int);
4289    #[cfg(feature = "v1_5")]
4290    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4291    pub fn adw_dialog_set_default_widget(
4292        self_: *mut AdwDialog,
4293        default_widget: *mut gtk::GtkWidget,
4294    );
4295    #[cfg(feature = "v1_5")]
4296    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4297    pub fn adw_dialog_set_focus(self_: *mut AdwDialog, focus: *mut gtk::GtkWidget);
4298    #[cfg(feature = "v1_5")]
4299    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4300    pub fn adw_dialog_set_follows_content_size(
4301        self_: *mut AdwDialog,
4302        follows_content_size: gboolean,
4303    );
4304    #[cfg(feature = "v1_5")]
4305    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4306    pub fn adw_dialog_set_presentation_mode(
4307        self_: *mut AdwDialog,
4308        presentation_mode: AdwDialogPresentationMode,
4309    );
4310    #[cfg(feature = "v1_5")]
4311    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4312    pub fn adw_dialog_set_title(self_: *mut AdwDialog, title: *const c_char);
4313
4314    //=========================================================================
4315    // AdwEntryRow
4316    //=========================================================================
4317    #[cfg(feature = "v1_2")]
4318    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4319    pub fn adw_entry_row_get_type() -> GType;
4320    #[cfg(feature = "v1_2")]
4321    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4322    pub fn adw_entry_row_new() -> *mut gtk::GtkWidget;
4323    #[cfg(feature = "v1_2")]
4324    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4325    pub fn adw_entry_row_add_prefix(self_: *mut AdwEntryRow, widget: *mut gtk::GtkWidget);
4326    #[cfg(feature = "v1_2")]
4327    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4328    pub fn adw_entry_row_add_suffix(self_: *mut AdwEntryRow, widget: *mut gtk::GtkWidget);
4329    #[cfg(feature = "v1_2")]
4330    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4331    pub fn adw_entry_row_get_activates_default(self_: *mut AdwEntryRow) -> gboolean;
4332    #[cfg(feature = "v1_2")]
4333    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4334    pub fn adw_entry_row_get_attributes(self_: *mut AdwEntryRow) -> *mut pango::PangoAttrList;
4335    #[cfg(feature = "v1_2")]
4336    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4337    pub fn adw_entry_row_get_enable_emoji_completion(self_: *mut AdwEntryRow) -> gboolean;
4338    #[cfg(feature = "v1_2")]
4339    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4340    pub fn adw_entry_row_get_input_hints(self_: *mut AdwEntryRow) -> gtk::GtkInputHints;
4341    #[cfg(feature = "v1_2")]
4342    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4343    pub fn adw_entry_row_get_input_purpose(self_: *mut AdwEntryRow) -> gtk::GtkInputPurpose;
4344    #[cfg(feature = "v1_6")]
4345    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4346    pub fn adw_entry_row_get_max_length(self_: *mut AdwEntryRow) -> c_int;
4347    #[cfg(feature = "v1_2")]
4348    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4349    pub fn adw_entry_row_get_show_apply_button(self_: *mut AdwEntryRow) -> gboolean;
4350    #[cfg(feature = "v1_5")]
4351    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4352    pub fn adw_entry_row_get_text_length(self_: *mut AdwEntryRow) -> c_uint;
4353    #[cfg(feature = "v1_3")]
4354    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
4355    pub fn adw_entry_row_grab_focus_without_selecting(self_: *mut AdwEntryRow) -> gboolean;
4356    #[cfg(feature = "v1_2")]
4357    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4358    pub fn adw_entry_row_remove(self_: *mut AdwEntryRow, widget: *mut gtk::GtkWidget);
4359    #[cfg(feature = "v1_2")]
4360    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4361    pub fn adw_entry_row_set_activates_default(self_: *mut AdwEntryRow, activates: gboolean);
4362    #[cfg(feature = "v1_2")]
4363    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4364    pub fn adw_entry_row_set_attributes(
4365        self_: *mut AdwEntryRow,
4366        attributes: *mut pango::PangoAttrList,
4367    );
4368    #[cfg(feature = "v1_2")]
4369    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4370    pub fn adw_entry_row_set_enable_emoji_completion(
4371        self_: *mut AdwEntryRow,
4372        enable_emoji_completion: gboolean,
4373    );
4374    #[cfg(feature = "v1_2")]
4375    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4376    pub fn adw_entry_row_set_input_hints(self_: *mut AdwEntryRow, hints: gtk::GtkInputHints);
4377    #[cfg(feature = "v1_2")]
4378    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4379    pub fn adw_entry_row_set_input_purpose(self_: *mut AdwEntryRow, purpose: gtk::GtkInputPurpose);
4380    #[cfg(feature = "v1_6")]
4381    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4382    pub fn adw_entry_row_set_max_length(self_: *mut AdwEntryRow, max_length: c_int);
4383    #[cfg(feature = "v1_2")]
4384    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4385    pub fn adw_entry_row_set_show_apply_button(
4386        self_: *mut AdwEntryRow,
4387        show_apply_button: gboolean,
4388    );
4389
4390    //=========================================================================
4391    // AdwEnumListItem
4392    //=========================================================================
4393    pub fn adw_enum_list_item_get_type() -> GType;
4394    pub fn adw_enum_list_item_get_name(self_: *mut AdwEnumListItem) -> *const c_char;
4395    pub fn adw_enum_list_item_get_nick(self_: *mut AdwEnumListItem) -> *const c_char;
4396    pub fn adw_enum_list_item_get_value(self_: *mut AdwEnumListItem) -> c_int;
4397
4398    //=========================================================================
4399    // AdwEnumListModel
4400    //=========================================================================
4401    pub fn adw_enum_list_model_get_type() -> GType;
4402    pub fn adw_enum_list_model_new(enum_type: GType) -> *mut AdwEnumListModel;
4403    pub fn adw_enum_list_model_find_position(self_: *mut AdwEnumListModel, value: c_int) -> c_uint;
4404    pub fn adw_enum_list_model_get_enum_type(self_: *mut AdwEnumListModel) -> GType;
4405
4406    //=========================================================================
4407    // AdwExpanderRow
4408    //=========================================================================
4409    pub fn adw_expander_row_get_type() -> GType;
4410    pub fn adw_expander_row_new() -> *mut gtk::GtkWidget;
4411    pub fn adw_expander_row_add_action(self_: *mut AdwExpanderRow, widget: *mut gtk::GtkWidget);
4412    pub fn adw_expander_row_add_prefix(self_: *mut AdwExpanderRow, widget: *mut gtk::GtkWidget);
4413    pub fn adw_expander_row_add_row(self_: *mut AdwExpanderRow, child: *mut gtk::GtkWidget);
4414    #[cfg(feature = "v1_4")]
4415    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4416    pub fn adw_expander_row_add_suffix(self_: *mut AdwExpanderRow, widget: *mut gtk::GtkWidget);
4417    pub fn adw_expander_row_get_enable_expansion(self_: *mut AdwExpanderRow) -> gboolean;
4418    pub fn adw_expander_row_get_expanded(self_: *mut AdwExpanderRow) -> gboolean;
4419    pub fn adw_expander_row_get_icon_name(self_: *mut AdwExpanderRow) -> *const c_char;
4420    pub fn adw_expander_row_get_show_enable_switch(self_: *mut AdwExpanderRow) -> gboolean;
4421    pub fn adw_expander_row_get_subtitle(self_: *mut AdwExpanderRow) -> *const c_char;
4422    #[cfg(feature = "v1_3")]
4423    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
4424    pub fn adw_expander_row_get_subtitle_lines(self_: *mut AdwExpanderRow) -> c_int;
4425    #[cfg(feature = "v1_3")]
4426    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
4427    pub fn adw_expander_row_get_title_lines(self_: *mut AdwExpanderRow) -> c_int;
4428    pub fn adw_expander_row_remove(self_: *mut AdwExpanderRow, child: *mut gtk::GtkWidget);
4429    pub fn adw_expander_row_set_enable_expansion(
4430        self_: *mut AdwExpanderRow,
4431        enable_expansion: gboolean,
4432    );
4433    pub fn adw_expander_row_set_expanded(self_: *mut AdwExpanderRow, expanded: gboolean);
4434    pub fn adw_expander_row_set_icon_name(self_: *mut AdwExpanderRow, icon_name: *const c_char);
4435    pub fn adw_expander_row_set_show_enable_switch(
4436        self_: *mut AdwExpanderRow,
4437        show_enable_switch: gboolean,
4438    );
4439    pub fn adw_expander_row_set_subtitle(self_: *mut AdwExpanderRow, subtitle: *const c_char);
4440    #[cfg(feature = "v1_3")]
4441    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
4442    pub fn adw_expander_row_set_subtitle_lines(self_: *mut AdwExpanderRow, subtitle_lines: c_int);
4443    #[cfg(feature = "v1_3")]
4444    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
4445    pub fn adw_expander_row_set_title_lines(self_: *mut AdwExpanderRow, title_lines: c_int);
4446
4447    //=========================================================================
4448    // AdwFlap
4449    //=========================================================================
4450    pub fn adw_flap_get_type() -> GType;
4451    pub fn adw_flap_new() -> *mut gtk::GtkWidget;
4452    pub fn adw_flap_get_content(self_: *mut AdwFlap) -> *mut gtk::GtkWidget;
4453    pub fn adw_flap_get_flap(self_: *mut AdwFlap) -> *mut gtk::GtkWidget;
4454    pub fn adw_flap_get_flap_position(self_: *mut AdwFlap) -> gtk::GtkPackType;
4455    pub fn adw_flap_get_fold_duration(self_: *mut AdwFlap) -> c_uint;
4456    pub fn adw_flap_get_fold_policy(self_: *mut AdwFlap) -> AdwFlapFoldPolicy;
4457    pub fn adw_flap_get_fold_threshold_policy(self_: *mut AdwFlap) -> AdwFoldThresholdPolicy;
4458    pub fn adw_flap_get_folded(self_: *mut AdwFlap) -> gboolean;
4459    pub fn adw_flap_get_locked(self_: *mut AdwFlap) -> gboolean;
4460    pub fn adw_flap_get_modal(self_: *mut AdwFlap) -> gboolean;
4461    pub fn adw_flap_get_reveal_flap(self_: *mut AdwFlap) -> gboolean;
4462    pub fn adw_flap_get_reveal_params(self_: *mut AdwFlap) -> *mut AdwSpringParams;
4463    pub fn adw_flap_get_reveal_progress(self_: *mut AdwFlap) -> c_double;
4464    pub fn adw_flap_get_separator(self_: *mut AdwFlap) -> *mut gtk::GtkWidget;
4465    pub fn adw_flap_get_swipe_to_close(self_: *mut AdwFlap) -> gboolean;
4466    pub fn adw_flap_get_swipe_to_open(self_: *mut AdwFlap) -> gboolean;
4467    pub fn adw_flap_get_transition_type(self_: *mut AdwFlap) -> AdwFlapTransitionType;
4468    pub fn adw_flap_set_content(self_: *mut AdwFlap, content: *mut gtk::GtkWidget);
4469    pub fn adw_flap_set_flap(self_: *mut AdwFlap, flap: *mut gtk::GtkWidget);
4470    pub fn adw_flap_set_flap_position(self_: *mut AdwFlap, position: gtk::GtkPackType);
4471    pub fn adw_flap_set_fold_duration(self_: *mut AdwFlap, duration: c_uint);
4472    pub fn adw_flap_set_fold_policy(self_: *mut AdwFlap, policy: AdwFlapFoldPolicy);
4473    pub fn adw_flap_set_fold_threshold_policy(self_: *mut AdwFlap, policy: AdwFoldThresholdPolicy);
4474    pub fn adw_flap_set_locked(self_: *mut AdwFlap, locked: gboolean);
4475    pub fn adw_flap_set_modal(self_: *mut AdwFlap, modal: gboolean);
4476    pub fn adw_flap_set_reveal_flap(self_: *mut AdwFlap, reveal_flap: gboolean);
4477    pub fn adw_flap_set_reveal_params(self_: *mut AdwFlap, params: *mut AdwSpringParams);
4478    pub fn adw_flap_set_separator(self_: *mut AdwFlap, separator: *mut gtk::GtkWidget);
4479    pub fn adw_flap_set_swipe_to_close(self_: *mut AdwFlap, swipe_to_close: gboolean);
4480    pub fn adw_flap_set_swipe_to_open(self_: *mut AdwFlap, swipe_to_open: gboolean);
4481    pub fn adw_flap_set_transition_type(
4482        self_: *mut AdwFlap,
4483        transition_type: AdwFlapTransitionType,
4484    );
4485
4486    //=========================================================================
4487    // AdwHeaderBar
4488    //=========================================================================
4489    pub fn adw_header_bar_get_type() -> GType;
4490    pub fn adw_header_bar_new() -> *mut gtk::GtkWidget;
4491    pub fn adw_header_bar_get_centering_policy(self_: *mut AdwHeaderBar) -> AdwCenteringPolicy;
4492    pub fn adw_header_bar_get_decoration_layout(self_: *mut AdwHeaderBar) -> *const c_char;
4493    #[cfg(feature = "v1_4")]
4494    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4495    pub fn adw_header_bar_get_show_back_button(self_: *mut AdwHeaderBar) -> gboolean;
4496    pub fn adw_header_bar_get_show_end_title_buttons(self_: *mut AdwHeaderBar) -> gboolean;
4497    pub fn adw_header_bar_get_show_start_title_buttons(self_: *mut AdwHeaderBar) -> gboolean;
4498    #[cfg(feature = "v1_4")]
4499    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4500    pub fn adw_header_bar_get_show_title(self_: *mut AdwHeaderBar) -> gboolean;
4501    pub fn adw_header_bar_get_title_widget(self_: *mut AdwHeaderBar) -> *mut gtk::GtkWidget;
4502    pub fn adw_header_bar_pack_end(self_: *mut AdwHeaderBar, child: *mut gtk::GtkWidget);
4503    pub fn adw_header_bar_pack_start(self_: *mut AdwHeaderBar, child: *mut gtk::GtkWidget);
4504    pub fn adw_header_bar_remove(self_: *mut AdwHeaderBar, child: *mut gtk::GtkWidget);
4505    pub fn adw_header_bar_set_centering_policy(
4506        self_: *mut AdwHeaderBar,
4507        centering_policy: AdwCenteringPolicy,
4508    );
4509    pub fn adw_header_bar_set_decoration_layout(self_: *mut AdwHeaderBar, layout: *const c_char);
4510    #[cfg(feature = "v1_4")]
4511    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4512    pub fn adw_header_bar_set_show_back_button(
4513        self_: *mut AdwHeaderBar,
4514        show_back_button: gboolean,
4515    );
4516    pub fn adw_header_bar_set_show_end_title_buttons(self_: *mut AdwHeaderBar, setting: gboolean);
4517    pub fn adw_header_bar_set_show_start_title_buttons(self_: *mut AdwHeaderBar, setting: gboolean);
4518    #[cfg(feature = "v1_4")]
4519    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4520    pub fn adw_header_bar_set_show_title(self_: *mut AdwHeaderBar, show_title: gboolean);
4521    pub fn adw_header_bar_set_title_widget(
4522        self_: *mut AdwHeaderBar,
4523        title_widget: *mut gtk::GtkWidget,
4524    );
4525
4526    //=========================================================================
4527    // AdwInlineViewSwitcher
4528    //=========================================================================
4529    #[cfg(feature = "v1_7")]
4530    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
4531    pub fn adw_inline_view_switcher_get_type() -> GType;
4532    #[cfg(feature = "v1_7")]
4533    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
4534    pub fn adw_inline_view_switcher_new() -> *mut gtk::GtkWidget;
4535    #[cfg(feature = "v1_7")]
4536    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
4537    pub fn adw_inline_view_switcher_get_can_shrink(self_: *mut AdwInlineViewSwitcher) -> gboolean;
4538    #[cfg(feature = "v1_7")]
4539    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
4540    pub fn adw_inline_view_switcher_get_display_mode(
4541        self_: *mut AdwInlineViewSwitcher,
4542    ) -> AdwInlineViewSwitcherDisplayMode;
4543    #[cfg(feature = "v1_7")]
4544    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
4545    pub fn adw_inline_view_switcher_get_homogeneous(self_: *mut AdwInlineViewSwitcher) -> gboolean;
4546    #[cfg(feature = "v1_7")]
4547    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
4548    pub fn adw_inline_view_switcher_get_stack(
4549        self_: *mut AdwInlineViewSwitcher,
4550    ) -> *mut AdwViewStack;
4551    #[cfg(feature = "v1_7")]
4552    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
4553    pub fn adw_inline_view_switcher_set_can_shrink(
4554        self_: *mut AdwInlineViewSwitcher,
4555        can_shrink: gboolean,
4556    );
4557    #[cfg(feature = "v1_7")]
4558    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
4559    pub fn adw_inline_view_switcher_set_display_mode(
4560        self_: *mut AdwInlineViewSwitcher,
4561        mode: AdwInlineViewSwitcherDisplayMode,
4562    );
4563    #[cfg(feature = "v1_7")]
4564    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
4565    pub fn adw_inline_view_switcher_set_homogeneous(
4566        self_: *mut AdwInlineViewSwitcher,
4567        homogeneous: gboolean,
4568    );
4569    #[cfg(feature = "v1_7")]
4570    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
4571    pub fn adw_inline_view_switcher_set_stack(
4572        self_: *mut AdwInlineViewSwitcher,
4573        stack: *mut AdwViewStack,
4574    );
4575
4576    //=========================================================================
4577    // AdwLayout
4578    //=========================================================================
4579    #[cfg(feature = "v1_6")]
4580    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4581    pub fn adw_layout_get_type() -> GType;
4582    #[cfg(feature = "v1_6")]
4583    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4584    pub fn adw_layout_new(content: *mut gtk::GtkWidget) -> *mut AdwLayout;
4585    #[cfg(feature = "v1_6")]
4586    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4587    pub fn adw_layout_get_content(self_: *mut AdwLayout) -> *mut gtk::GtkWidget;
4588    #[cfg(feature = "v1_6")]
4589    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4590    pub fn adw_layout_get_name(self_: *mut AdwLayout) -> *const c_char;
4591    #[cfg(feature = "v1_6")]
4592    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4593    pub fn adw_layout_set_name(self_: *mut AdwLayout, name: *const c_char);
4594
4595    //=========================================================================
4596    // AdwLayoutSlot
4597    //=========================================================================
4598    #[cfg(feature = "v1_6")]
4599    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4600    pub fn adw_layout_slot_get_type() -> GType;
4601    #[cfg(feature = "v1_6")]
4602    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4603    pub fn adw_layout_slot_new(id: *const c_char) -> *mut gtk::GtkWidget;
4604    #[cfg(feature = "v1_6")]
4605    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4606    pub fn adw_layout_slot_get_slot_id(self_: *mut AdwLayoutSlot) -> *const c_char;
4607
4608    //=========================================================================
4609    // AdwLeaflet
4610    //=========================================================================
4611    pub fn adw_leaflet_get_type() -> GType;
4612    pub fn adw_leaflet_new() -> *mut gtk::GtkWidget;
4613    pub fn adw_leaflet_append(
4614        self_: *mut AdwLeaflet,
4615        child: *mut gtk::GtkWidget,
4616    ) -> *mut AdwLeafletPage;
4617    pub fn adw_leaflet_get_adjacent_child(
4618        self_: *mut AdwLeaflet,
4619        direction: AdwNavigationDirection,
4620    ) -> *mut gtk::GtkWidget;
4621    pub fn adw_leaflet_get_can_navigate_back(self_: *mut AdwLeaflet) -> gboolean;
4622    pub fn adw_leaflet_get_can_navigate_forward(self_: *mut AdwLeaflet) -> gboolean;
4623    pub fn adw_leaflet_get_can_unfold(self_: *mut AdwLeaflet) -> gboolean;
4624    pub fn adw_leaflet_get_child_by_name(
4625        self_: *mut AdwLeaflet,
4626        name: *const c_char,
4627    ) -> *mut gtk::GtkWidget;
4628    pub fn adw_leaflet_get_child_transition_params(self_: *mut AdwLeaflet) -> *mut AdwSpringParams;
4629    pub fn adw_leaflet_get_child_transition_running(self_: *mut AdwLeaflet) -> gboolean;
4630    pub fn adw_leaflet_get_fold_threshold_policy(self_: *mut AdwLeaflet) -> AdwFoldThresholdPolicy;
4631    pub fn adw_leaflet_get_folded(self_: *mut AdwLeaflet) -> gboolean;
4632    pub fn adw_leaflet_get_homogeneous(self_: *mut AdwLeaflet) -> gboolean;
4633    pub fn adw_leaflet_get_mode_transition_duration(self_: *mut AdwLeaflet) -> c_uint;
4634    pub fn adw_leaflet_get_page(
4635        self_: *mut AdwLeaflet,
4636        child: *mut gtk::GtkWidget,
4637    ) -> *mut AdwLeafletPage;
4638    pub fn adw_leaflet_get_pages(self_: *mut AdwLeaflet) -> *mut gtk::GtkSelectionModel;
4639    pub fn adw_leaflet_get_transition_type(self_: *mut AdwLeaflet) -> AdwLeafletTransitionType;
4640    pub fn adw_leaflet_get_visible_child(self_: *mut AdwLeaflet) -> *mut gtk::GtkWidget;
4641    pub fn adw_leaflet_get_visible_child_name(self_: *mut AdwLeaflet) -> *const c_char;
4642    pub fn adw_leaflet_insert_child_after(
4643        self_: *mut AdwLeaflet,
4644        child: *mut gtk::GtkWidget,
4645        sibling: *mut gtk::GtkWidget,
4646    ) -> *mut AdwLeafletPage;
4647    pub fn adw_leaflet_navigate(
4648        self_: *mut AdwLeaflet,
4649        direction: AdwNavigationDirection,
4650    ) -> gboolean;
4651    pub fn adw_leaflet_prepend(
4652        self_: *mut AdwLeaflet,
4653        child: *mut gtk::GtkWidget,
4654    ) -> *mut AdwLeafletPage;
4655    pub fn adw_leaflet_remove(self_: *mut AdwLeaflet, child: *mut gtk::GtkWidget);
4656    pub fn adw_leaflet_reorder_child_after(
4657        self_: *mut AdwLeaflet,
4658        child: *mut gtk::GtkWidget,
4659        sibling: *mut gtk::GtkWidget,
4660    );
4661    pub fn adw_leaflet_set_can_navigate_back(self_: *mut AdwLeaflet, can_navigate_back: gboolean);
4662    pub fn adw_leaflet_set_can_navigate_forward(
4663        self_: *mut AdwLeaflet,
4664        can_navigate_forward: gboolean,
4665    );
4666    pub fn adw_leaflet_set_can_unfold(self_: *mut AdwLeaflet, can_unfold: gboolean);
4667    pub fn adw_leaflet_set_child_transition_params(
4668        self_: *mut AdwLeaflet,
4669        params: *mut AdwSpringParams,
4670    );
4671    pub fn adw_leaflet_set_fold_threshold_policy(
4672        self_: *mut AdwLeaflet,
4673        policy: AdwFoldThresholdPolicy,
4674    );
4675    pub fn adw_leaflet_set_homogeneous(self_: *mut AdwLeaflet, homogeneous: gboolean);
4676    pub fn adw_leaflet_set_mode_transition_duration(self_: *mut AdwLeaflet, duration: c_uint);
4677    pub fn adw_leaflet_set_transition_type(
4678        self_: *mut AdwLeaflet,
4679        transition: AdwLeafletTransitionType,
4680    );
4681    pub fn adw_leaflet_set_visible_child(
4682        self_: *mut AdwLeaflet,
4683        visible_child: *mut gtk::GtkWidget,
4684    );
4685    pub fn adw_leaflet_set_visible_child_name(self_: *mut AdwLeaflet, name: *const c_char);
4686
4687    //=========================================================================
4688    // AdwLeafletPage
4689    //=========================================================================
4690    pub fn adw_leaflet_page_get_type() -> GType;
4691    pub fn adw_leaflet_page_get_child(self_: *mut AdwLeafletPage) -> *mut gtk::GtkWidget;
4692    pub fn adw_leaflet_page_get_name(self_: *mut AdwLeafletPage) -> *const c_char;
4693    pub fn adw_leaflet_page_get_navigatable(self_: *mut AdwLeafletPage) -> gboolean;
4694    pub fn adw_leaflet_page_set_name(self_: *mut AdwLeafletPage, name: *const c_char);
4695    pub fn adw_leaflet_page_set_navigatable(self_: *mut AdwLeafletPage, navigatable: gboolean);
4696
4697    //=========================================================================
4698    // AdwMessageDialog
4699    //=========================================================================
4700    #[cfg(feature = "v1_2")]
4701    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4702    pub fn adw_message_dialog_get_type() -> GType;
4703    #[cfg(feature = "v1_2")]
4704    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4705    pub fn adw_message_dialog_new(
4706        parent: *mut gtk::GtkWindow,
4707        heading: *const c_char,
4708        body: *const c_char,
4709    ) -> *mut gtk::GtkWidget;
4710    #[cfg(feature = "v1_2")]
4711    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4712    pub fn adw_message_dialog_add_response(
4713        self_: *mut AdwMessageDialog,
4714        id: *const c_char,
4715        label: *const c_char,
4716    );
4717    #[cfg(feature = "v1_2")]
4718    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4719    pub fn adw_message_dialog_add_responses(
4720        self_: *mut AdwMessageDialog,
4721        first_id: *const c_char,
4722        ...
4723    );
4724    #[cfg(feature = "v1_3")]
4725    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
4726    pub fn adw_message_dialog_choose(
4727        self_: *mut AdwMessageDialog,
4728        cancellable: *mut gio::GCancellable,
4729        callback: gio::GAsyncReadyCallback,
4730        user_data: gpointer,
4731    );
4732    #[cfg(feature = "v1_3")]
4733    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
4734    pub fn adw_message_dialog_choose_finish(
4735        self_: *mut AdwMessageDialog,
4736        result: *mut gio::GAsyncResult,
4737    ) -> *const c_char;
4738    #[cfg(feature = "v1_2")]
4739    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4740    pub fn adw_message_dialog_format_body(self_: *mut AdwMessageDialog, format: *const c_char, ...);
4741    #[cfg(feature = "v1_2")]
4742    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4743    pub fn adw_message_dialog_format_body_markup(
4744        self_: *mut AdwMessageDialog,
4745        format: *const c_char,
4746        ...
4747    );
4748    #[cfg(feature = "v1_2")]
4749    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4750    pub fn adw_message_dialog_format_heading(
4751        self_: *mut AdwMessageDialog,
4752        format: *const c_char,
4753        ...
4754    );
4755    #[cfg(feature = "v1_2")]
4756    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4757    pub fn adw_message_dialog_format_heading_markup(
4758        self_: *mut AdwMessageDialog,
4759        format: *const c_char,
4760        ...
4761    );
4762    #[cfg(feature = "v1_2")]
4763    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4764    pub fn adw_message_dialog_get_body(self_: *mut AdwMessageDialog) -> *const c_char;
4765    #[cfg(feature = "v1_2")]
4766    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4767    pub fn adw_message_dialog_get_body_use_markup(self_: *mut AdwMessageDialog) -> gboolean;
4768    #[cfg(feature = "v1_2")]
4769    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4770    pub fn adw_message_dialog_get_close_response(self_: *mut AdwMessageDialog) -> *const c_char;
4771    #[cfg(feature = "v1_2")]
4772    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4773    pub fn adw_message_dialog_get_default_response(self_: *mut AdwMessageDialog) -> *const c_char;
4774    #[cfg(feature = "v1_2")]
4775    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4776    pub fn adw_message_dialog_get_extra_child(self_: *mut AdwMessageDialog) -> *mut gtk::GtkWidget;
4777    #[cfg(feature = "v1_2")]
4778    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4779    pub fn adw_message_dialog_get_heading(self_: *mut AdwMessageDialog) -> *const c_char;
4780    #[cfg(feature = "v1_2")]
4781    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4782    pub fn adw_message_dialog_get_heading_use_markup(self_: *mut AdwMessageDialog) -> gboolean;
4783    #[cfg(feature = "v1_2")]
4784    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4785    pub fn adw_message_dialog_get_response_appearance(
4786        self_: *mut AdwMessageDialog,
4787        response: *const c_char,
4788    ) -> AdwResponseAppearance;
4789    #[cfg(feature = "v1_2")]
4790    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4791    pub fn adw_message_dialog_get_response_enabled(
4792        self_: *mut AdwMessageDialog,
4793        response: *const c_char,
4794    ) -> gboolean;
4795    #[cfg(feature = "v1_2")]
4796    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4797    pub fn adw_message_dialog_get_response_label(
4798        self_: *mut AdwMessageDialog,
4799        response: *const c_char,
4800    ) -> *const c_char;
4801    #[cfg(feature = "v1_2")]
4802    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4803    pub fn adw_message_dialog_has_response(
4804        self_: *mut AdwMessageDialog,
4805        response: *const c_char,
4806    ) -> gboolean;
4807    #[cfg(feature = "v1_5")]
4808    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
4809    pub fn adw_message_dialog_remove_response(self_: *mut AdwMessageDialog, id: *const c_char);
4810    #[cfg(feature = "v1_2")]
4811    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4812    pub fn adw_message_dialog_response(self_: *mut AdwMessageDialog, response: *const c_char);
4813    #[cfg(feature = "v1_2")]
4814    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4815    pub fn adw_message_dialog_set_body(self_: *mut AdwMessageDialog, body: *const c_char);
4816    #[cfg(feature = "v1_2")]
4817    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4818    pub fn adw_message_dialog_set_body_use_markup(
4819        self_: *mut AdwMessageDialog,
4820        use_markup: gboolean,
4821    );
4822    #[cfg(feature = "v1_2")]
4823    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4824    pub fn adw_message_dialog_set_close_response(
4825        self_: *mut AdwMessageDialog,
4826        response: *const c_char,
4827    );
4828    #[cfg(feature = "v1_2")]
4829    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4830    pub fn adw_message_dialog_set_default_response(
4831        self_: *mut AdwMessageDialog,
4832        response: *const c_char,
4833    );
4834    #[cfg(feature = "v1_2")]
4835    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4836    pub fn adw_message_dialog_set_extra_child(
4837        self_: *mut AdwMessageDialog,
4838        child: *mut gtk::GtkWidget,
4839    );
4840    #[cfg(feature = "v1_2")]
4841    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4842    pub fn adw_message_dialog_set_heading(self_: *mut AdwMessageDialog, heading: *const c_char);
4843    #[cfg(feature = "v1_2")]
4844    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4845    pub fn adw_message_dialog_set_heading_use_markup(
4846        self_: *mut AdwMessageDialog,
4847        use_markup: gboolean,
4848    );
4849    #[cfg(feature = "v1_2")]
4850    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4851    pub fn adw_message_dialog_set_response_appearance(
4852        self_: *mut AdwMessageDialog,
4853        response: *const c_char,
4854        appearance: AdwResponseAppearance,
4855    );
4856    #[cfg(feature = "v1_2")]
4857    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4858    pub fn adw_message_dialog_set_response_enabled(
4859        self_: *mut AdwMessageDialog,
4860        response: *const c_char,
4861        enabled: gboolean,
4862    );
4863    #[cfg(feature = "v1_2")]
4864    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
4865    pub fn adw_message_dialog_set_response_label(
4866        self_: *mut AdwMessageDialog,
4867        response: *const c_char,
4868        label: *const c_char,
4869    );
4870
4871    //=========================================================================
4872    // AdwMultiLayoutView
4873    //=========================================================================
4874    #[cfg(feature = "v1_6")]
4875    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4876    pub fn adw_multi_layout_view_get_type() -> GType;
4877    #[cfg(feature = "v1_6")]
4878    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4879    pub fn adw_multi_layout_view_new() -> *mut gtk::GtkWidget;
4880    #[cfg(feature = "v1_6")]
4881    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4882    pub fn adw_multi_layout_view_add_layout(self_: *mut AdwMultiLayoutView, layout: *mut AdwLayout);
4883    #[cfg(feature = "v1_6")]
4884    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4885    pub fn adw_multi_layout_view_get_child(
4886        self_: *mut AdwMultiLayoutView,
4887        id: *const c_char,
4888    ) -> *mut gtk::GtkWidget;
4889    #[cfg(feature = "v1_6")]
4890    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4891    pub fn adw_multi_layout_view_get_layout(self_: *mut AdwMultiLayoutView) -> *mut AdwLayout;
4892    #[cfg(feature = "v1_6")]
4893    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4894    pub fn adw_multi_layout_view_get_layout_by_name(
4895        self_: *mut AdwMultiLayoutView,
4896        name: *const c_char,
4897    ) -> *mut AdwLayout;
4898    #[cfg(feature = "v1_6")]
4899    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4900    pub fn adw_multi_layout_view_get_layout_name(self_: *mut AdwMultiLayoutView) -> *const c_char;
4901    #[cfg(feature = "v1_6")]
4902    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4903    pub fn adw_multi_layout_view_remove_layout(
4904        self_: *mut AdwMultiLayoutView,
4905        layout: *mut AdwLayout,
4906    );
4907    #[cfg(feature = "v1_6")]
4908    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4909    pub fn adw_multi_layout_view_set_child(
4910        self_: *mut AdwMultiLayoutView,
4911        id: *const c_char,
4912        child: *mut gtk::GtkWidget,
4913    );
4914    #[cfg(feature = "v1_6")]
4915    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4916    pub fn adw_multi_layout_view_set_layout(self_: *mut AdwMultiLayoutView, layout: *mut AdwLayout);
4917    #[cfg(feature = "v1_6")]
4918    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
4919    pub fn adw_multi_layout_view_set_layout_name(
4920        self_: *mut AdwMultiLayoutView,
4921        name: *const c_char,
4922    );
4923
4924    //=========================================================================
4925    // AdwNavigationPage
4926    //=========================================================================
4927    #[cfg(feature = "v1_4")]
4928    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4929    pub fn adw_navigation_page_get_type() -> GType;
4930    #[cfg(feature = "v1_4")]
4931    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4932    pub fn adw_navigation_page_new(
4933        child: *mut gtk::GtkWidget,
4934        title: *const c_char,
4935    ) -> *mut AdwNavigationPage;
4936    #[cfg(feature = "v1_4")]
4937    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4938    pub fn adw_navigation_page_new_with_tag(
4939        child: *mut gtk::GtkWidget,
4940        title: *const c_char,
4941        tag: *const c_char,
4942    ) -> *mut AdwNavigationPage;
4943    #[cfg(feature = "v1_4")]
4944    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4945    pub fn adw_navigation_page_get_can_pop(self_: *mut AdwNavigationPage) -> gboolean;
4946    #[cfg(feature = "v1_4")]
4947    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4948    pub fn adw_navigation_page_get_child(self_: *mut AdwNavigationPage) -> *mut gtk::GtkWidget;
4949    #[cfg(feature = "v1_4")]
4950    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4951    pub fn adw_navigation_page_get_tag(self_: *mut AdwNavigationPage) -> *const c_char;
4952    #[cfg(feature = "v1_4")]
4953    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4954    pub fn adw_navigation_page_get_title(self_: *mut AdwNavigationPage) -> *const c_char;
4955    #[cfg(feature = "v1_4")]
4956    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4957    pub fn adw_navigation_page_set_can_pop(self_: *mut AdwNavigationPage, can_pop: gboolean);
4958    #[cfg(feature = "v1_4")]
4959    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4960    pub fn adw_navigation_page_set_child(self_: *mut AdwNavigationPage, child: *mut gtk::GtkWidget);
4961    #[cfg(feature = "v1_4")]
4962    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4963    pub fn adw_navigation_page_set_tag(self_: *mut AdwNavigationPage, tag: *const c_char);
4964    #[cfg(feature = "v1_4")]
4965    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4966    pub fn adw_navigation_page_set_title(self_: *mut AdwNavigationPage, title: *const c_char);
4967
4968    //=========================================================================
4969    // AdwNavigationSplitView
4970    //=========================================================================
4971    #[cfg(feature = "v1_4")]
4972    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4973    pub fn adw_navigation_split_view_get_type() -> GType;
4974    #[cfg(feature = "v1_4")]
4975    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4976    pub fn adw_navigation_split_view_new() -> *mut gtk::GtkWidget;
4977    #[cfg(feature = "v1_4")]
4978    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4979    pub fn adw_navigation_split_view_get_collapsed(self_: *mut AdwNavigationSplitView) -> gboolean;
4980    #[cfg(feature = "v1_4")]
4981    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4982    pub fn adw_navigation_split_view_get_content(
4983        self_: *mut AdwNavigationSplitView,
4984    ) -> *mut AdwNavigationPage;
4985    #[cfg(feature = "v1_4")]
4986    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4987    pub fn adw_navigation_split_view_get_max_sidebar_width(
4988        self_: *mut AdwNavigationSplitView,
4989    ) -> c_double;
4990    #[cfg(feature = "v1_4")]
4991    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4992    pub fn adw_navigation_split_view_get_min_sidebar_width(
4993        self_: *mut AdwNavigationSplitView,
4994    ) -> c_double;
4995    #[cfg(feature = "v1_4")]
4996    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
4997    pub fn adw_navigation_split_view_get_show_content(
4998        self_: *mut AdwNavigationSplitView,
4999    ) -> gboolean;
5000    #[cfg(feature = "v1_4")]
5001    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5002    pub fn adw_navigation_split_view_get_sidebar(
5003        self_: *mut AdwNavigationSplitView,
5004    ) -> *mut AdwNavigationPage;
5005    #[cfg(feature = "v1_7")]
5006    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
5007    pub fn adw_navigation_split_view_get_sidebar_position(
5008        self_: *mut AdwNavigationSplitView,
5009    ) -> gtk::GtkPackType;
5010    #[cfg(feature = "v1_4")]
5011    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5012    pub fn adw_navigation_split_view_get_sidebar_width_fraction(
5013        self_: *mut AdwNavigationSplitView,
5014    ) -> c_double;
5015    #[cfg(feature = "v1_4")]
5016    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5017    pub fn adw_navigation_split_view_get_sidebar_width_unit(
5018        self_: *mut AdwNavigationSplitView,
5019    ) -> AdwLengthUnit;
5020    #[cfg(feature = "v1_4")]
5021    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5022    pub fn adw_navigation_split_view_set_collapsed(
5023        self_: *mut AdwNavigationSplitView,
5024        collapsed: gboolean,
5025    );
5026    #[cfg(feature = "v1_4")]
5027    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5028    pub fn adw_navigation_split_view_set_content(
5029        self_: *mut AdwNavigationSplitView,
5030        content: *mut AdwNavigationPage,
5031    );
5032    #[cfg(feature = "v1_4")]
5033    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5034    pub fn adw_navigation_split_view_set_max_sidebar_width(
5035        self_: *mut AdwNavigationSplitView,
5036        width: c_double,
5037    );
5038    #[cfg(feature = "v1_4")]
5039    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5040    pub fn adw_navigation_split_view_set_min_sidebar_width(
5041        self_: *mut AdwNavigationSplitView,
5042        width: c_double,
5043    );
5044    #[cfg(feature = "v1_4")]
5045    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5046    pub fn adw_navigation_split_view_set_show_content(
5047        self_: *mut AdwNavigationSplitView,
5048        show_content: gboolean,
5049    );
5050    #[cfg(feature = "v1_4")]
5051    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5052    pub fn adw_navigation_split_view_set_sidebar(
5053        self_: *mut AdwNavigationSplitView,
5054        sidebar: *mut AdwNavigationPage,
5055    );
5056    #[cfg(feature = "v1_7")]
5057    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
5058    pub fn adw_navigation_split_view_set_sidebar_position(
5059        self_: *mut AdwNavigationSplitView,
5060        position: gtk::GtkPackType,
5061    );
5062    #[cfg(feature = "v1_4")]
5063    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5064    pub fn adw_navigation_split_view_set_sidebar_width_fraction(
5065        self_: *mut AdwNavigationSplitView,
5066        fraction: c_double,
5067    );
5068    #[cfg(feature = "v1_4")]
5069    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5070    pub fn adw_navigation_split_view_set_sidebar_width_unit(
5071        self_: *mut AdwNavigationSplitView,
5072        unit: AdwLengthUnit,
5073    );
5074
5075    //=========================================================================
5076    // AdwNavigationView
5077    //=========================================================================
5078    #[cfg(feature = "v1_4")]
5079    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5080    pub fn adw_navigation_view_get_type() -> GType;
5081    #[cfg(feature = "v1_4")]
5082    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5083    pub fn adw_navigation_view_new() -> *mut gtk::GtkWidget;
5084    #[cfg(feature = "v1_4")]
5085    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5086    pub fn adw_navigation_view_add(self_: *mut AdwNavigationView, page: *mut AdwNavigationPage);
5087    #[cfg(feature = "v1_4")]
5088    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5089    pub fn adw_navigation_view_find_page(
5090        self_: *mut AdwNavigationView,
5091        tag: *const c_char,
5092    ) -> *mut AdwNavigationPage;
5093    #[cfg(feature = "v1_4")]
5094    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5095    pub fn adw_navigation_view_get_animate_transitions(self_: *mut AdwNavigationView) -> gboolean;
5096    #[cfg(feature = "v1_7")]
5097    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
5098    pub fn adw_navigation_view_get_hhomogeneous(self_: *mut AdwNavigationView) -> gboolean;
5099    #[cfg(feature = "v1_4")]
5100    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5101    pub fn adw_navigation_view_get_navigation_stack(
5102        self_: *mut AdwNavigationView,
5103    ) -> *mut gio::GListModel;
5104    #[cfg(feature = "v1_4")]
5105    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5106    pub fn adw_navigation_view_get_pop_on_escape(self_: *mut AdwNavigationView) -> gboolean;
5107    #[cfg(feature = "v1_4")]
5108    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5109    pub fn adw_navigation_view_get_previous_page(
5110        self_: *mut AdwNavigationView,
5111        page: *mut AdwNavigationPage,
5112    ) -> *mut AdwNavigationPage;
5113    #[cfg(feature = "v1_7")]
5114    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
5115    pub fn adw_navigation_view_get_vhomogeneous(self_: *mut AdwNavigationView) -> gboolean;
5116    #[cfg(feature = "v1_4")]
5117    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5118    pub fn adw_navigation_view_get_visible_page(
5119        self_: *mut AdwNavigationView,
5120    ) -> *mut AdwNavigationPage;
5121    #[cfg(feature = "v1_7")]
5122    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
5123    pub fn adw_navigation_view_get_visible_page_tag(self_: *mut AdwNavigationView)
5124    -> *const c_char;
5125    #[cfg(feature = "v1_4")]
5126    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5127    pub fn adw_navigation_view_pop(self_: *mut AdwNavigationView) -> gboolean;
5128    #[cfg(feature = "v1_4")]
5129    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5130    pub fn adw_navigation_view_pop_to_page(
5131        self_: *mut AdwNavigationView,
5132        page: *mut AdwNavigationPage,
5133    ) -> gboolean;
5134    #[cfg(feature = "v1_4")]
5135    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5136    pub fn adw_navigation_view_pop_to_tag(
5137        self_: *mut AdwNavigationView,
5138        tag: *const c_char,
5139    ) -> gboolean;
5140    #[cfg(feature = "v1_4")]
5141    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5142    pub fn adw_navigation_view_push(self_: *mut AdwNavigationView, page: *mut AdwNavigationPage);
5143    #[cfg(feature = "v1_4")]
5144    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5145    pub fn adw_navigation_view_push_by_tag(self_: *mut AdwNavigationView, tag: *const c_char);
5146    #[cfg(feature = "v1_4")]
5147    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5148    pub fn adw_navigation_view_remove(self_: *mut AdwNavigationView, page: *mut AdwNavigationPage);
5149    #[cfg(feature = "v1_4")]
5150    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5151    pub fn adw_navigation_view_replace(
5152        self_: *mut AdwNavigationView,
5153        pages: *mut *mut AdwNavigationPage,
5154        n_pages: c_int,
5155    );
5156    #[cfg(feature = "v1_4")]
5157    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5158    pub fn adw_navigation_view_replace_with_tags(
5159        self_: *mut AdwNavigationView,
5160        tags: *const *const c_char,
5161        n_tags: c_int,
5162    );
5163    #[cfg(feature = "v1_4")]
5164    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5165    pub fn adw_navigation_view_set_animate_transitions(
5166        self_: *mut AdwNavigationView,
5167        animate_transitions: gboolean,
5168    );
5169    #[cfg(feature = "v1_7")]
5170    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
5171    pub fn adw_navigation_view_set_hhomogeneous(
5172        self_: *mut AdwNavigationView,
5173        hhomogeneous: gboolean,
5174    );
5175    #[cfg(feature = "v1_4")]
5176    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5177    pub fn adw_navigation_view_set_pop_on_escape(
5178        self_: *mut AdwNavigationView,
5179        pop_on_escape: gboolean,
5180    );
5181    #[cfg(feature = "v1_7")]
5182    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
5183    pub fn adw_navigation_view_set_vhomogeneous(
5184        self_: *mut AdwNavigationView,
5185        vhomogeneous: gboolean,
5186    );
5187
5188    //=========================================================================
5189    // AdwNoneAnimationTarget
5190    //=========================================================================
5191    #[cfg(feature = "v1_9")]
5192    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5193    pub fn adw_none_animation_target_get_type() -> GType;
5194    #[cfg(feature = "v1_9")]
5195    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5196    pub fn adw_none_animation_target_new() -> *mut AdwAnimationTarget;
5197
5198    //=========================================================================
5199    // AdwOverlaySplitView
5200    //=========================================================================
5201    #[cfg(feature = "v1_4")]
5202    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5203    pub fn adw_overlay_split_view_get_type() -> GType;
5204    #[cfg(feature = "v1_4")]
5205    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5206    pub fn adw_overlay_split_view_new() -> *mut gtk::GtkWidget;
5207    #[cfg(feature = "v1_4")]
5208    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5209    pub fn adw_overlay_split_view_get_collapsed(self_: *mut AdwOverlaySplitView) -> gboolean;
5210    #[cfg(feature = "v1_4")]
5211    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5212    pub fn adw_overlay_split_view_get_content(
5213        self_: *mut AdwOverlaySplitView,
5214    ) -> *mut gtk::GtkWidget;
5215    #[cfg(feature = "v1_4")]
5216    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5217    pub fn adw_overlay_split_view_get_enable_hide_gesture(
5218        self_: *mut AdwOverlaySplitView,
5219    ) -> gboolean;
5220    #[cfg(feature = "v1_4")]
5221    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5222    pub fn adw_overlay_split_view_get_enable_show_gesture(
5223        self_: *mut AdwOverlaySplitView,
5224    ) -> gboolean;
5225    #[cfg(feature = "v1_4")]
5226    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5227    pub fn adw_overlay_split_view_get_max_sidebar_width(
5228        self_: *mut AdwOverlaySplitView,
5229    ) -> c_double;
5230    #[cfg(feature = "v1_4")]
5231    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5232    pub fn adw_overlay_split_view_get_min_sidebar_width(
5233        self_: *mut AdwOverlaySplitView,
5234    ) -> c_double;
5235    #[cfg(feature = "v1_4")]
5236    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5237    pub fn adw_overlay_split_view_get_pin_sidebar(self_: *mut AdwOverlaySplitView) -> gboolean;
5238    #[cfg(feature = "v1_4")]
5239    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5240    pub fn adw_overlay_split_view_get_show_sidebar(self_: *mut AdwOverlaySplitView) -> gboolean;
5241    #[cfg(feature = "v1_4")]
5242    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5243    pub fn adw_overlay_split_view_get_sidebar(
5244        self_: *mut AdwOverlaySplitView,
5245    ) -> *mut gtk::GtkWidget;
5246    #[cfg(feature = "v1_4")]
5247    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5248    pub fn adw_overlay_split_view_get_sidebar_position(
5249        self_: *mut AdwOverlaySplitView,
5250    ) -> gtk::GtkPackType;
5251    #[cfg(feature = "v1_4")]
5252    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5253    pub fn adw_overlay_split_view_get_sidebar_width_fraction(
5254        self_: *mut AdwOverlaySplitView,
5255    ) -> c_double;
5256    #[cfg(feature = "v1_4")]
5257    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5258    pub fn adw_overlay_split_view_get_sidebar_width_unit(
5259        self_: *mut AdwOverlaySplitView,
5260    ) -> AdwLengthUnit;
5261    #[cfg(feature = "v1_4")]
5262    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5263    pub fn adw_overlay_split_view_set_collapsed(
5264        self_: *mut AdwOverlaySplitView,
5265        collapsed: gboolean,
5266    );
5267    #[cfg(feature = "v1_4")]
5268    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5269    pub fn adw_overlay_split_view_set_content(
5270        self_: *mut AdwOverlaySplitView,
5271        content: *mut gtk::GtkWidget,
5272    );
5273    #[cfg(feature = "v1_4")]
5274    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5275    pub fn adw_overlay_split_view_set_enable_hide_gesture(
5276        self_: *mut AdwOverlaySplitView,
5277        enable_hide_gesture: gboolean,
5278    );
5279    #[cfg(feature = "v1_4")]
5280    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5281    pub fn adw_overlay_split_view_set_enable_show_gesture(
5282        self_: *mut AdwOverlaySplitView,
5283        enable_show_gesture: gboolean,
5284    );
5285    #[cfg(feature = "v1_4")]
5286    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5287    pub fn adw_overlay_split_view_set_max_sidebar_width(
5288        self_: *mut AdwOverlaySplitView,
5289        width: c_double,
5290    );
5291    #[cfg(feature = "v1_4")]
5292    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5293    pub fn adw_overlay_split_view_set_min_sidebar_width(
5294        self_: *mut AdwOverlaySplitView,
5295        width: c_double,
5296    );
5297    #[cfg(feature = "v1_4")]
5298    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5299    pub fn adw_overlay_split_view_set_pin_sidebar(
5300        self_: *mut AdwOverlaySplitView,
5301        pin_sidebar: gboolean,
5302    );
5303    #[cfg(feature = "v1_4")]
5304    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5305    pub fn adw_overlay_split_view_set_show_sidebar(
5306        self_: *mut AdwOverlaySplitView,
5307        show_sidebar: gboolean,
5308    );
5309    #[cfg(feature = "v1_4")]
5310    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5311    pub fn adw_overlay_split_view_set_sidebar(
5312        self_: *mut AdwOverlaySplitView,
5313        sidebar: *mut gtk::GtkWidget,
5314    );
5315    #[cfg(feature = "v1_4")]
5316    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5317    pub fn adw_overlay_split_view_set_sidebar_position(
5318        self_: *mut AdwOverlaySplitView,
5319        position: gtk::GtkPackType,
5320    );
5321    #[cfg(feature = "v1_4")]
5322    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5323    pub fn adw_overlay_split_view_set_sidebar_width_fraction(
5324        self_: *mut AdwOverlaySplitView,
5325        fraction: c_double,
5326    );
5327    #[cfg(feature = "v1_4")]
5328    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5329    pub fn adw_overlay_split_view_set_sidebar_width_unit(
5330        self_: *mut AdwOverlaySplitView,
5331        unit: AdwLengthUnit,
5332    );
5333
5334    //=========================================================================
5335    // AdwPasswordEntryRow
5336    //=========================================================================
5337    #[cfg(feature = "v1_2")]
5338    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
5339    pub fn adw_password_entry_row_get_type() -> GType;
5340    #[cfg(feature = "v1_2")]
5341    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
5342    pub fn adw_password_entry_row_new() -> *mut gtk::GtkWidget;
5343
5344    //=========================================================================
5345    // AdwPreferencesDialog
5346    //=========================================================================
5347    #[cfg(feature = "v1_5")]
5348    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
5349    pub fn adw_preferences_dialog_get_type() -> GType;
5350    #[cfg(feature = "v1_5")]
5351    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
5352    pub fn adw_preferences_dialog_new() -> *mut AdwDialog;
5353    #[cfg(feature = "v1_5")]
5354    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
5355    pub fn adw_preferences_dialog_add(
5356        self_: *mut AdwPreferencesDialog,
5357        page: *mut AdwPreferencesPage,
5358    );
5359    #[cfg(feature = "v1_5")]
5360    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
5361    pub fn adw_preferences_dialog_add_toast(self_: *mut AdwPreferencesDialog, toast: *mut AdwToast);
5362    #[cfg(feature = "v1_5")]
5363    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
5364    pub fn adw_preferences_dialog_get_search_enabled(self_: *mut AdwPreferencesDialog) -> gboolean;
5365    #[cfg(feature = "v1_5")]
5366    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
5367    pub fn adw_preferences_dialog_get_visible_page(
5368        self_: *mut AdwPreferencesDialog,
5369    ) -> *mut AdwPreferencesPage;
5370    #[cfg(feature = "v1_5")]
5371    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
5372    pub fn adw_preferences_dialog_get_visible_page_name(
5373        self_: *mut AdwPreferencesDialog,
5374    ) -> *const c_char;
5375    #[cfg(feature = "v1_5")]
5376    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
5377    pub fn adw_preferences_dialog_pop_subpage(self_: *mut AdwPreferencesDialog) -> gboolean;
5378    #[cfg(feature = "v1_5")]
5379    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
5380    pub fn adw_preferences_dialog_push_subpage(
5381        self_: *mut AdwPreferencesDialog,
5382        page: *mut AdwNavigationPage,
5383    );
5384    #[cfg(feature = "v1_5")]
5385    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
5386    pub fn adw_preferences_dialog_remove(
5387        self_: *mut AdwPreferencesDialog,
5388        page: *mut AdwPreferencesPage,
5389    );
5390    #[cfg(feature = "v1_5")]
5391    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
5392    pub fn adw_preferences_dialog_set_search_enabled(
5393        self_: *mut AdwPreferencesDialog,
5394        search_enabled: gboolean,
5395    );
5396    #[cfg(feature = "v1_5")]
5397    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
5398    pub fn adw_preferences_dialog_set_visible_page(
5399        self_: *mut AdwPreferencesDialog,
5400        page: *mut AdwPreferencesPage,
5401    );
5402    #[cfg(feature = "v1_5")]
5403    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
5404    pub fn adw_preferences_dialog_set_visible_page_name(
5405        self_: *mut AdwPreferencesDialog,
5406        name: *const c_char,
5407    );
5408
5409    //=========================================================================
5410    // AdwPreferencesGroup
5411    //=========================================================================
5412    pub fn adw_preferences_group_get_type() -> GType;
5413    pub fn adw_preferences_group_new() -> *mut gtk::GtkWidget;
5414    pub fn adw_preferences_group_add(self_: *mut AdwPreferencesGroup, child: *mut gtk::GtkWidget);
5415    #[cfg(feature = "v1_8")]
5416    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5417    pub fn adw_preferences_group_bind_model(
5418        self_: *mut AdwPreferencesGroup,
5419        model: *mut gio::GListModel,
5420        create_row_func: gtk::GtkListBoxCreateWidgetFunc,
5421        user_data: gpointer,
5422        user_data_free_func: glib::GDestroyNotify,
5423    );
5424    pub fn adw_preferences_group_get_description(self_: *mut AdwPreferencesGroup) -> *const c_char;
5425    #[cfg(feature = "v1_1")]
5426    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
5427    pub fn adw_preferences_group_get_header_suffix(
5428        self_: *mut AdwPreferencesGroup,
5429    ) -> *mut gtk::GtkWidget;
5430    #[cfg(feature = "v1_8")]
5431    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5432    pub fn adw_preferences_group_get_row(
5433        self_: *mut AdwPreferencesGroup,
5434        index: c_uint,
5435    ) -> *mut gtk::GtkWidget;
5436    #[cfg(feature = "v1_6")]
5437    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
5438    pub fn adw_preferences_group_get_separate_rows(self_: *mut AdwPreferencesGroup) -> gboolean;
5439    pub fn adw_preferences_group_get_title(self_: *mut AdwPreferencesGroup) -> *const c_char;
5440    pub fn adw_preferences_group_remove(
5441        self_: *mut AdwPreferencesGroup,
5442        child: *mut gtk::GtkWidget,
5443    );
5444    pub fn adw_preferences_group_set_description(
5445        self_: *mut AdwPreferencesGroup,
5446        description: *const c_char,
5447    );
5448    #[cfg(feature = "v1_1")]
5449    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
5450    pub fn adw_preferences_group_set_header_suffix(
5451        self_: *mut AdwPreferencesGroup,
5452        suffix: *mut gtk::GtkWidget,
5453    );
5454    #[cfg(feature = "v1_6")]
5455    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
5456    pub fn adw_preferences_group_set_separate_rows(
5457        self_: *mut AdwPreferencesGroup,
5458        separate_rows: gboolean,
5459    );
5460    pub fn adw_preferences_group_set_title(self_: *mut AdwPreferencesGroup, title: *const c_char);
5461
5462    //=========================================================================
5463    // AdwPreferencesPage
5464    //=========================================================================
5465    pub fn adw_preferences_page_get_type() -> GType;
5466    pub fn adw_preferences_page_new() -> *mut gtk::GtkWidget;
5467    pub fn adw_preferences_page_add(
5468        self_: *mut AdwPreferencesPage,
5469        group: *mut AdwPreferencesGroup,
5470    );
5471    #[cfg(feature = "v1_7")]
5472    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
5473    pub fn adw_preferences_page_get_banner(self_: *mut AdwPreferencesPage) -> *mut AdwBanner;
5474    #[cfg(feature = "v1_4")]
5475    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5476    pub fn adw_preferences_page_get_description(self_: *mut AdwPreferencesPage) -> *const c_char;
5477    #[cfg(feature = "v1_6")]
5478    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
5479    pub fn adw_preferences_page_get_description_centered(
5480        self_: *mut AdwPreferencesPage,
5481    ) -> gboolean;
5482    #[cfg(feature = "v1_8")]
5483    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5484    pub fn adw_preferences_page_get_group(
5485        self_: *mut AdwPreferencesPage,
5486        index: c_uint,
5487    ) -> *mut AdwPreferencesGroup;
5488    pub fn adw_preferences_page_get_icon_name(self_: *mut AdwPreferencesPage) -> *const c_char;
5489    pub fn adw_preferences_page_get_name(self_: *mut AdwPreferencesPage) -> *const c_char;
5490    pub fn adw_preferences_page_get_title(self_: *mut AdwPreferencesPage) -> *const c_char;
5491    pub fn adw_preferences_page_get_use_underline(self_: *mut AdwPreferencesPage) -> gboolean;
5492    #[cfg(feature = "v1_8")]
5493    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5494    pub fn adw_preferences_page_insert(
5495        self_: *mut AdwPreferencesPage,
5496        group: *mut AdwPreferencesGroup,
5497        index: c_int,
5498    );
5499    pub fn adw_preferences_page_remove(
5500        self_: *mut AdwPreferencesPage,
5501        group: *mut AdwPreferencesGroup,
5502    );
5503    #[cfg(feature = "v1_3")]
5504    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
5505    pub fn adw_preferences_page_scroll_to_top(self_: *mut AdwPreferencesPage);
5506    #[cfg(feature = "v1_7")]
5507    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
5508    pub fn adw_preferences_page_set_banner(self_: *mut AdwPreferencesPage, banner: *mut AdwBanner);
5509    #[cfg(feature = "v1_4")]
5510    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5511    pub fn adw_preferences_page_set_description(
5512        self_: *mut AdwPreferencesPage,
5513        description: *const c_char,
5514    );
5515    #[cfg(feature = "v1_6")]
5516    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
5517    pub fn adw_preferences_page_set_description_centered(
5518        self_: *mut AdwPreferencesPage,
5519        centered: gboolean,
5520    );
5521    pub fn adw_preferences_page_set_icon_name(
5522        self_: *mut AdwPreferencesPage,
5523        icon_name: *const c_char,
5524    );
5525    pub fn adw_preferences_page_set_name(self_: *mut AdwPreferencesPage, name: *const c_char);
5526    pub fn adw_preferences_page_set_title(self_: *mut AdwPreferencesPage, title: *const c_char);
5527    pub fn adw_preferences_page_set_use_underline(
5528        self_: *mut AdwPreferencesPage,
5529        use_underline: gboolean,
5530    );
5531
5532    //=========================================================================
5533    // AdwPreferencesRow
5534    //=========================================================================
5535    pub fn adw_preferences_row_get_type() -> GType;
5536    pub fn adw_preferences_row_new() -> *mut gtk::GtkWidget;
5537    pub fn adw_preferences_row_get_title(self_: *mut AdwPreferencesRow) -> *const c_char;
5538    #[cfg(feature = "v1_1")]
5539    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
5540    pub fn adw_preferences_row_get_title_selectable(self_: *mut AdwPreferencesRow) -> gboolean;
5541    #[cfg(feature = "v1_2")]
5542    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
5543    pub fn adw_preferences_row_get_use_markup(self_: *mut AdwPreferencesRow) -> gboolean;
5544    pub fn adw_preferences_row_get_use_underline(self_: *mut AdwPreferencesRow) -> gboolean;
5545    pub fn adw_preferences_row_set_title(self_: *mut AdwPreferencesRow, title: *const c_char);
5546    #[cfg(feature = "v1_1")]
5547    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
5548    pub fn adw_preferences_row_set_title_selectable(
5549        self_: *mut AdwPreferencesRow,
5550        title_selectable: gboolean,
5551    );
5552    #[cfg(feature = "v1_2")]
5553    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
5554    pub fn adw_preferences_row_set_use_markup(self_: *mut AdwPreferencesRow, use_markup: gboolean);
5555    pub fn adw_preferences_row_set_use_underline(
5556        self_: *mut AdwPreferencesRow,
5557        use_underline: gboolean,
5558    );
5559
5560    //=========================================================================
5561    // AdwPreferencesWindow
5562    //=========================================================================
5563    pub fn adw_preferences_window_get_type() -> GType;
5564    pub fn adw_preferences_window_new() -> *mut gtk::GtkWidget;
5565    pub fn adw_preferences_window_add(
5566        self_: *mut AdwPreferencesWindow,
5567        page: *mut AdwPreferencesPage,
5568    );
5569    pub fn adw_preferences_window_add_toast(self_: *mut AdwPreferencesWindow, toast: *mut AdwToast);
5570    pub fn adw_preferences_window_close_subpage(self_: *mut AdwPreferencesWindow);
5571    pub fn adw_preferences_window_get_can_navigate_back(
5572        self_: *mut AdwPreferencesWindow,
5573    ) -> gboolean;
5574    pub fn adw_preferences_window_get_search_enabled(self_: *mut AdwPreferencesWindow) -> gboolean;
5575    pub fn adw_preferences_window_get_visible_page(
5576        self_: *mut AdwPreferencesWindow,
5577    ) -> *mut AdwPreferencesPage;
5578    pub fn adw_preferences_window_get_visible_page_name(
5579        self_: *mut AdwPreferencesWindow,
5580    ) -> *const c_char;
5581    #[cfg(feature = "v1_4")]
5582    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5583    pub fn adw_preferences_window_pop_subpage(self_: *mut AdwPreferencesWindow) -> gboolean;
5584    pub fn adw_preferences_window_present_subpage(
5585        self_: *mut AdwPreferencesWindow,
5586        subpage: *mut gtk::GtkWidget,
5587    );
5588    #[cfg(feature = "v1_4")]
5589    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
5590    pub fn adw_preferences_window_push_subpage(
5591        self_: *mut AdwPreferencesWindow,
5592        page: *mut AdwNavigationPage,
5593    );
5594    pub fn adw_preferences_window_remove(
5595        self_: *mut AdwPreferencesWindow,
5596        page: *mut AdwPreferencesPage,
5597    );
5598    pub fn adw_preferences_window_set_can_navigate_back(
5599        self_: *mut AdwPreferencesWindow,
5600        can_navigate_back: gboolean,
5601    );
5602    pub fn adw_preferences_window_set_search_enabled(
5603        self_: *mut AdwPreferencesWindow,
5604        search_enabled: gboolean,
5605    );
5606    pub fn adw_preferences_window_set_visible_page(
5607        self_: *mut AdwPreferencesWindow,
5608        page: *mut AdwPreferencesPage,
5609    );
5610    pub fn adw_preferences_window_set_visible_page_name(
5611        self_: *mut AdwPreferencesWindow,
5612        name: *const c_char,
5613    );
5614
5615    //=========================================================================
5616    // AdwPropertyAnimationTarget
5617    //=========================================================================
5618    #[cfg(feature = "v1_2")]
5619    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
5620    pub fn adw_property_animation_target_get_type() -> GType;
5621    #[cfg(feature = "v1_2")]
5622    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
5623    pub fn adw_property_animation_target_new(
5624        object: *mut gobject::GObject,
5625        property_name: *const c_char,
5626    ) -> *mut AdwAnimationTarget;
5627    #[cfg(feature = "v1_2")]
5628    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
5629    pub fn adw_property_animation_target_new_for_pspec(
5630        object: *mut gobject::GObject,
5631        pspec: *mut gobject::GParamSpec,
5632    ) -> *mut AdwAnimationTarget;
5633    #[cfg(feature = "v1_2")]
5634    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
5635    pub fn adw_property_animation_target_get_object(
5636        self_: *mut AdwPropertyAnimationTarget,
5637    ) -> *mut gobject::GObject;
5638    #[cfg(feature = "v1_2")]
5639    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
5640    pub fn adw_property_animation_target_get_pspec(
5641        self_: *mut AdwPropertyAnimationTarget,
5642    ) -> *mut gobject::GParamSpec;
5643
5644    //=========================================================================
5645    // AdwShortcutLabel
5646    //=========================================================================
5647    #[cfg(feature = "v1_8")]
5648    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5649    pub fn adw_shortcut_label_get_type() -> GType;
5650    #[cfg(feature = "v1_8")]
5651    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5652    pub fn adw_shortcut_label_new(accelerator: *const c_char) -> *mut gtk::GtkWidget;
5653    #[cfg(feature = "v1_8")]
5654    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5655    pub fn adw_shortcut_label_get_accelerator(self_: *mut AdwShortcutLabel) -> *const c_char;
5656    #[cfg(feature = "v1_8")]
5657    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5658    pub fn adw_shortcut_label_get_disabled_text(self_: *mut AdwShortcutLabel) -> *const c_char;
5659    #[cfg(feature = "v1_8")]
5660    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5661    pub fn adw_shortcut_label_set_accelerator(
5662        self_: *mut AdwShortcutLabel,
5663        accelerator: *const c_char,
5664    );
5665    #[cfg(feature = "v1_8")]
5666    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5667    pub fn adw_shortcut_label_set_disabled_text(
5668        self_: *mut AdwShortcutLabel,
5669        disabled_text: *const c_char,
5670    );
5671
5672    //=========================================================================
5673    // AdwShortcutsDialog
5674    //=========================================================================
5675    #[cfg(feature = "v1_8")]
5676    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5677    pub fn adw_shortcuts_dialog_get_type() -> GType;
5678    #[cfg(feature = "v1_8")]
5679    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5680    pub fn adw_shortcuts_dialog_new() -> *mut AdwDialog;
5681    #[cfg(feature = "v1_8")]
5682    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5683    pub fn adw_shortcuts_dialog_add(
5684        self_: *mut AdwShortcutsDialog,
5685        section: *mut AdwShortcutsSection,
5686    );
5687
5688    //=========================================================================
5689    // AdwShortcutsItem
5690    //=========================================================================
5691    #[cfg(feature = "v1_8")]
5692    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5693    pub fn adw_shortcuts_item_get_type() -> GType;
5694    #[cfg(feature = "v1_8")]
5695    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5696    pub fn adw_shortcuts_item_new(
5697        title: *const c_char,
5698        accelerator: *const c_char,
5699    ) -> *mut AdwShortcutsItem;
5700    #[cfg(feature = "v1_8")]
5701    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5702    pub fn adw_shortcuts_item_new_from_action(
5703        title: *const c_char,
5704        action_name: *const c_char,
5705    ) -> *mut AdwShortcutsItem;
5706    #[cfg(feature = "v1_8")]
5707    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5708    pub fn adw_shortcuts_item_get_accelerator(self_: *mut AdwShortcutsItem) -> *const c_char;
5709    #[cfg(feature = "v1_8")]
5710    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5711    pub fn adw_shortcuts_item_get_action_name(self_: *mut AdwShortcutsItem) -> *const c_char;
5712    #[cfg(feature = "v1_8")]
5713    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5714    pub fn adw_shortcuts_item_get_direction(self_: *mut AdwShortcutsItem) -> gtk::GtkTextDirection;
5715    #[cfg(feature = "v1_8")]
5716    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5717    pub fn adw_shortcuts_item_get_subtitle(self_: *mut AdwShortcutsItem) -> *const c_char;
5718    #[cfg(feature = "v1_8")]
5719    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5720    pub fn adw_shortcuts_item_get_title(self_: *mut AdwShortcutsItem) -> *const c_char;
5721    #[cfg(feature = "v1_8")]
5722    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5723    pub fn adw_shortcuts_item_set_accelerator(
5724        self_: *mut AdwShortcutsItem,
5725        accelerator: *const c_char,
5726    );
5727    #[cfg(feature = "v1_8")]
5728    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5729    pub fn adw_shortcuts_item_set_action_name(
5730        self_: *mut AdwShortcutsItem,
5731        action_name: *const c_char,
5732    );
5733    #[cfg(feature = "v1_8")]
5734    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5735    pub fn adw_shortcuts_item_set_direction(
5736        self_: *mut AdwShortcutsItem,
5737        direction: gtk::GtkTextDirection,
5738    );
5739    #[cfg(feature = "v1_8")]
5740    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5741    pub fn adw_shortcuts_item_set_subtitle(self_: *mut AdwShortcutsItem, subtitle: *const c_char);
5742    #[cfg(feature = "v1_8")]
5743    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5744    pub fn adw_shortcuts_item_set_title(self_: *mut AdwShortcutsItem, title: *const c_char);
5745
5746    //=========================================================================
5747    // AdwShortcutsSection
5748    //=========================================================================
5749    #[cfg(feature = "v1_8")]
5750    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5751    pub fn adw_shortcuts_section_get_type() -> GType;
5752    #[cfg(feature = "v1_8")]
5753    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5754    pub fn adw_shortcuts_section_new(title: *const c_char) -> *mut AdwShortcutsSection;
5755    #[cfg(feature = "v1_8")]
5756    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5757    pub fn adw_shortcuts_section_add(self_: *mut AdwShortcutsSection, item: *mut AdwShortcutsItem);
5758    #[cfg(feature = "v1_8")]
5759    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5760    pub fn adw_shortcuts_section_get_title(self_: *mut AdwShortcutsSection) -> *const c_char;
5761    #[cfg(feature = "v1_8")]
5762    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
5763    pub fn adw_shortcuts_section_set_title(self_: *mut AdwShortcutsSection, title: *const c_char);
5764
5765    //=========================================================================
5766    // AdwSidebar
5767    //=========================================================================
5768    #[cfg(feature = "v1_9")]
5769    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5770    pub fn adw_sidebar_get_type() -> GType;
5771    #[cfg(feature = "v1_9")]
5772    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5773    pub fn adw_sidebar_new() -> *mut gtk::GtkWidget;
5774    #[cfg(feature = "v1_9")]
5775    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5776    pub fn adw_sidebar_append(self_: *mut AdwSidebar, section: *mut AdwSidebarSection);
5777    #[cfg(feature = "v1_9")]
5778    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5779    pub fn adw_sidebar_get_drop_preload(self_: *mut AdwSidebar) -> gboolean;
5780    #[cfg(feature = "v1_9")]
5781    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5782    pub fn adw_sidebar_get_filter(self_: *mut AdwSidebar) -> *mut gtk::GtkFilter;
5783    #[cfg(feature = "v1_9")]
5784    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5785    pub fn adw_sidebar_get_item(self_: *mut AdwSidebar, index: c_uint) -> *mut AdwSidebarItem;
5786    #[cfg(feature = "v1_9")]
5787    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5788    pub fn adw_sidebar_get_items(self_: *mut AdwSidebar) -> *mut gtk::GtkSelectionModel;
5789    #[cfg(feature = "v1_9")]
5790    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5791    pub fn adw_sidebar_get_menu_model(self_: *mut AdwSidebar) -> *mut gio::GMenuModel;
5792    #[cfg(feature = "v1_9")]
5793    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5794    pub fn adw_sidebar_get_mode(self_: *mut AdwSidebar) -> AdwSidebarMode;
5795    #[cfg(feature = "v1_9")]
5796    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5797    pub fn adw_sidebar_get_placeholder(self_: *mut AdwSidebar) -> *mut gtk::GtkWidget;
5798    #[cfg(feature = "v1_9")]
5799    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5800    pub fn adw_sidebar_get_section(self_: *mut AdwSidebar, index: c_uint)
5801    -> *mut AdwSidebarSection;
5802    #[cfg(feature = "v1_9")]
5803    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5804    pub fn adw_sidebar_get_sections(self_: *mut AdwSidebar) -> *mut gio::GListModel;
5805    #[cfg(feature = "v1_9")]
5806    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5807    pub fn adw_sidebar_get_selected(self_: *mut AdwSidebar) -> c_uint;
5808    #[cfg(feature = "v1_9")]
5809    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5810    pub fn adw_sidebar_get_selected_item(self_: *mut AdwSidebar) -> *mut AdwSidebarItem;
5811    #[cfg(feature = "v1_9")]
5812    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5813    pub fn adw_sidebar_insert(
5814        self_: *mut AdwSidebar,
5815        section: *mut AdwSidebarSection,
5816        position: c_int,
5817    );
5818    #[cfg(feature = "v1_9")]
5819    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5820    pub fn adw_sidebar_prepend(self_: *mut AdwSidebar, section: *mut AdwSidebarSection);
5821    #[cfg(feature = "v1_9")]
5822    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5823    pub fn adw_sidebar_remove(self_: *mut AdwSidebar, section: *mut AdwSidebarSection);
5824    #[cfg(feature = "v1_9")]
5825    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5826    pub fn adw_sidebar_remove_all(self_: *mut AdwSidebar);
5827    #[cfg(feature = "v1_9")]
5828    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5829    pub fn adw_sidebar_set_drop_preload(self_: *mut AdwSidebar, preload: gboolean);
5830    #[cfg(feature = "v1_9")]
5831    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5832    pub fn adw_sidebar_set_filter(self_: *mut AdwSidebar, filter: *mut gtk::GtkFilter);
5833    #[cfg(feature = "v1_9")]
5834    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5835    pub fn adw_sidebar_set_menu_model(self_: *mut AdwSidebar, menu_model: *mut gio::GMenuModel);
5836    #[cfg(feature = "v1_9")]
5837    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5838    pub fn adw_sidebar_set_mode(self_: *mut AdwSidebar, mode: AdwSidebarMode);
5839    #[cfg(feature = "v1_9")]
5840    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5841    pub fn adw_sidebar_set_placeholder(self_: *mut AdwSidebar, placeholder: *mut gtk::GtkWidget);
5842    #[cfg(feature = "v1_9")]
5843    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5844    pub fn adw_sidebar_set_selected(self_: *mut AdwSidebar, selected: c_uint);
5845    #[cfg(feature = "v1_9")]
5846    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5847    pub fn adw_sidebar_setup_drop_target(
5848        self_: *mut AdwSidebar,
5849        actions: gdk::GdkDragAction,
5850        types: *mut GType,
5851        n_types: size_t,
5852    );
5853
5854    //=========================================================================
5855    // AdwSidebarItem
5856    //=========================================================================
5857    #[cfg(feature = "v1_9")]
5858    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5859    pub fn adw_sidebar_item_get_type() -> GType;
5860    #[cfg(feature = "v1_9")]
5861    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5862    pub fn adw_sidebar_item_new(title: *const c_char) -> *mut AdwSidebarItem;
5863    #[cfg(feature = "v1_9")]
5864    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5865    pub fn adw_sidebar_item_get_drag_motion_activate(self_: *mut AdwSidebarItem) -> gboolean;
5866    #[cfg(feature = "v1_9")]
5867    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5868    pub fn adw_sidebar_item_get_enabled(self_: *mut AdwSidebarItem) -> gboolean;
5869    #[cfg(feature = "v1_9")]
5870    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5871    pub fn adw_sidebar_item_get_icon_name(self_: *mut AdwSidebarItem) -> *const c_char;
5872    #[cfg(feature = "v1_9")]
5873    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5874    pub fn adw_sidebar_item_get_icon_paintable(
5875        self_: *mut AdwSidebarItem,
5876    ) -> *mut gdk::GdkPaintable;
5877    #[cfg(feature = "v1_9")]
5878    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5879    pub fn adw_sidebar_item_get_index(self_: *mut AdwSidebarItem) -> c_uint;
5880    #[cfg(feature = "v1_9")]
5881    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5882    pub fn adw_sidebar_item_get_section(self_: *mut AdwSidebarItem) -> *mut AdwSidebarSection;
5883    #[cfg(feature = "v1_9")]
5884    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5885    pub fn adw_sidebar_item_get_section_index(self_: *mut AdwSidebarItem) -> c_uint;
5886    #[cfg(feature = "v1_9")]
5887    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5888    pub fn adw_sidebar_item_get_subtitle(self_: *mut AdwSidebarItem) -> *const c_char;
5889    #[cfg(feature = "v1_9")]
5890    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5891    pub fn adw_sidebar_item_get_suffix(self_: *mut AdwSidebarItem) -> *mut gtk::GtkWidget;
5892    #[cfg(feature = "v1_9")]
5893    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5894    pub fn adw_sidebar_item_get_title(self_: *mut AdwSidebarItem) -> *const c_char;
5895    #[cfg(feature = "v1_9")]
5896    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5897    pub fn adw_sidebar_item_get_tooltip(self_: *mut AdwSidebarItem) -> *const c_char;
5898    #[cfg(feature = "v1_9")]
5899    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5900    pub fn adw_sidebar_item_get_use_underline(self_: *mut AdwSidebarItem) -> gboolean;
5901    #[cfg(feature = "v1_9")]
5902    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5903    pub fn adw_sidebar_item_get_visible(self_: *mut AdwSidebarItem) -> gboolean;
5904    #[cfg(feature = "v1_9")]
5905    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5906    pub fn adw_sidebar_item_set_drag_motion_activate(
5907        self_: *mut AdwSidebarItem,
5908        drag_motion_activate: gboolean,
5909    );
5910    #[cfg(feature = "v1_9")]
5911    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5912    pub fn adw_sidebar_item_set_enabled(self_: *mut AdwSidebarItem, enabled: gboolean);
5913    #[cfg(feature = "v1_9")]
5914    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5915    pub fn adw_sidebar_item_set_icon_name(self_: *mut AdwSidebarItem, icon_name: *const c_char);
5916    #[cfg(feature = "v1_9")]
5917    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5918    pub fn adw_sidebar_item_set_icon_paintable(
5919        self_: *mut AdwSidebarItem,
5920        paintable: *mut gdk::GdkPaintable,
5921    );
5922    #[cfg(feature = "v1_9")]
5923    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5924    pub fn adw_sidebar_item_set_subtitle(self_: *mut AdwSidebarItem, subtitle: *const c_char);
5925    #[cfg(feature = "v1_9")]
5926    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5927    pub fn adw_sidebar_item_set_suffix(self_: *mut AdwSidebarItem, suffix: *mut gtk::GtkWidget);
5928    #[cfg(feature = "v1_9")]
5929    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5930    pub fn adw_sidebar_item_set_title(self_: *mut AdwSidebarItem, title: *const c_char);
5931    #[cfg(feature = "v1_9")]
5932    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5933    pub fn adw_sidebar_item_set_tooltip(self_: *mut AdwSidebarItem, tooltip: *const c_char);
5934    #[cfg(feature = "v1_9")]
5935    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5936    pub fn adw_sidebar_item_set_use_underline(self_: *mut AdwSidebarItem, use_underline: gboolean);
5937    #[cfg(feature = "v1_9")]
5938    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5939    pub fn adw_sidebar_item_set_visible(self_: *mut AdwSidebarItem, visible: gboolean);
5940
5941    //=========================================================================
5942    // AdwSidebarSection
5943    //=========================================================================
5944    #[cfg(feature = "v1_9")]
5945    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5946    pub fn adw_sidebar_section_get_type() -> GType;
5947    #[cfg(feature = "v1_9")]
5948    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5949    pub fn adw_sidebar_section_new() -> *mut AdwSidebarSection;
5950    #[cfg(feature = "v1_9")]
5951    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5952    pub fn adw_sidebar_section_append(self_: *mut AdwSidebarSection, item: *mut AdwSidebarItem);
5953    #[cfg(feature = "v1_9")]
5954    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5955    pub fn adw_sidebar_section_bind_model(
5956        self_: *mut AdwSidebarSection,
5957        model: *mut gio::GListModel,
5958        create_item_func: AdwSidebarSectionCreateItemFunc,
5959        user_data: gpointer,
5960        user_data_free_func: glib::GDestroyNotify,
5961    );
5962    #[cfg(feature = "v1_9")]
5963    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5964    pub fn adw_sidebar_section_get_item(
5965        self_: *mut AdwSidebarSection,
5966        index: c_uint,
5967    ) -> *mut AdwSidebarItem;
5968    #[cfg(feature = "v1_9")]
5969    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5970    pub fn adw_sidebar_section_get_items(self_: *mut AdwSidebarSection) -> *mut gio::GListModel;
5971    #[cfg(feature = "v1_9")]
5972    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5973    pub fn adw_sidebar_section_get_menu_model(
5974        self_: *mut AdwSidebarSection,
5975    ) -> *mut gio::GMenuModel;
5976    #[cfg(feature = "v1_9")]
5977    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5978    pub fn adw_sidebar_section_get_sidebar(self_: *mut AdwSidebarSection) -> *mut AdwSidebar;
5979    #[cfg(feature = "v1_9")]
5980    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5981    pub fn adw_sidebar_section_get_title(self_: *mut AdwSidebarSection) -> *const c_char;
5982    #[cfg(feature = "v1_9")]
5983    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5984    pub fn adw_sidebar_section_insert(
5985        self_: *mut AdwSidebarSection,
5986        item: *mut AdwSidebarItem,
5987        position: c_int,
5988    );
5989    #[cfg(feature = "v1_9")]
5990    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5991    pub fn adw_sidebar_section_prepend(self_: *mut AdwSidebarSection, item: *mut AdwSidebarItem);
5992    #[cfg(feature = "v1_9")]
5993    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5994    pub fn adw_sidebar_section_remove(self_: *mut AdwSidebarSection, item: *mut AdwSidebarItem);
5995    #[cfg(feature = "v1_9")]
5996    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
5997    pub fn adw_sidebar_section_remove_all(self_: *mut AdwSidebarSection);
5998    #[cfg(feature = "v1_9")]
5999    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
6000    pub fn adw_sidebar_section_set_menu_model(
6001        self_: *mut AdwSidebarSection,
6002        menu_model: *mut gio::GMenuModel,
6003    );
6004    #[cfg(feature = "v1_9")]
6005    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
6006    pub fn adw_sidebar_section_set_title(self_: *mut AdwSidebarSection, title: *const c_char);
6007
6008    //=========================================================================
6009    // AdwSpinRow
6010    //=========================================================================
6011    #[cfg(feature = "v1_4")]
6012    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6013    pub fn adw_spin_row_get_type() -> GType;
6014    #[cfg(feature = "v1_4")]
6015    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6016    pub fn adw_spin_row_new(
6017        adjustment: *mut gtk::GtkAdjustment,
6018        climb_rate: c_double,
6019        digits: c_uint,
6020    ) -> *mut gtk::GtkWidget;
6021    #[cfg(feature = "v1_4")]
6022    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6023    pub fn adw_spin_row_new_with_range(
6024        min: c_double,
6025        max: c_double,
6026        step: c_double,
6027    ) -> *mut gtk::GtkWidget;
6028    #[cfg(feature = "v1_4")]
6029    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6030    pub fn adw_spin_row_configure(
6031        self_: *mut AdwSpinRow,
6032        adjustment: *mut gtk::GtkAdjustment,
6033        climb_rate: c_double,
6034        digits: c_uint,
6035    );
6036    #[cfg(feature = "v1_4")]
6037    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6038    pub fn adw_spin_row_get_adjustment(self_: *mut AdwSpinRow) -> *mut gtk::GtkAdjustment;
6039    #[cfg(feature = "v1_4")]
6040    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6041    pub fn adw_spin_row_get_climb_rate(self_: *mut AdwSpinRow) -> c_double;
6042    #[cfg(feature = "v1_4")]
6043    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6044    pub fn adw_spin_row_get_digits(self_: *mut AdwSpinRow) -> c_uint;
6045    #[cfg(feature = "v1_4")]
6046    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6047    pub fn adw_spin_row_get_numeric(self_: *mut AdwSpinRow) -> gboolean;
6048    #[cfg(feature = "v1_4")]
6049    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6050    pub fn adw_spin_row_get_snap_to_ticks(self_: *mut AdwSpinRow) -> gboolean;
6051    #[cfg(feature = "v1_4")]
6052    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6053    pub fn adw_spin_row_get_update_policy(self_: *mut AdwSpinRow)
6054    -> gtk::GtkSpinButtonUpdatePolicy;
6055    #[cfg(feature = "v1_4")]
6056    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6057    pub fn adw_spin_row_get_value(self_: *mut AdwSpinRow) -> c_double;
6058    #[cfg(feature = "v1_4")]
6059    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6060    pub fn adw_spin_row_get_wrap(self_: *mut AdwSpinRow) -> gboolean;
6061    #[cfg(feature = "v1_4")]
6062    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6063    pub fn adw_spin_row_set_adjustment(self_: *mut AdwSpinRow, adjustment: *mut gtk::GtkAdjustment);
6064    #[cfg(feature = "v1_4")]
6065    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6066    pub fn adw_spin_row_set_climb_rate(self_: *mut AdwSpinRow, climb_rate: c_double);
6067    #[cfg(feature = "v1_4")]
6068    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6069    pub fn adw_spin_row_set_digits(self_: *mut AdwSpinRow, digits: c_uint);
6070    #[cfg(feature = "v1_4")]
6071    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6072    pub fn adw_spin_row_set_numeric(self_: *mut AdwSpinRow, numeric: gboolean);
6073    #[cfg(feature = "v1_4")]
6074    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6075    pub fn adw_spin_row_set_range(self_: *mut AdwSpinRow, min: c_double, max: c_double);
6076    #[cfg(feature = "v1_4")]
6077    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6078    pub fn adw_spin_row_set_snap_to_ticks(self_: *mut AdwSpinRow, snap_to_ticks: gboolean);
6079    #[cfg(feature = "v1_4")]
6080    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6081    pub fn adw_spin_row_set_update_policy(
6082        self_: *mut AdwSpinRow,
6083        policy: gtk::GtkSpinButtonUpdatePolicy,
6084    );
6085    #[cfg(feature = "v1_4")]
6086    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6087    pub fn adw_spin_row_set_value(self_: *mut AdwSpinRow, value: c_double);
6088    #[cfg(feature = "v1_4")]
6089    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6090    pub fn adw_spin_row_set_wrap(self_: *mut AdwSpinRow, wrap: gboolean);
6091    #[cfg(feature = "v1_4")]
6092    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6093    pub fn adw_spin_row_update(self_: *mut AdwSpinRow);
6094
6095    //=========================================================================
6096    // AdwSpinner
6097    //=========================================================================
6098    #[cfg(feature = "v1_6")]
6099    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
6100    pub fn adw_spinner_get_type() -> GType;
6101    #[cfg(feature = "v1_6")]
6102    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
6103    pub fn adw_spinner_new() -> *mut gtk::GtkWidget;
6104
6105    //=========================================================================
6106    // AdwSpinnerPaintable
6107    //=========================================================================
6108    #[cfg(feature = "v1_6")]
6109    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
6110    pub fn adw_spinner_paintable_get_type() -> GType;
6111    #[cfg(feature = "v1_6")]
6112    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
6113    pub fn adw_spinner_paintable_new(widget: *mut gtk::GtkWidget) -> *mut AdwSpinnerPaintable;
6114    #[cfg(feature = "v1_6")]
6115    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
6116    pub fn adw_spinner_paintable_get_widget(self_: *mut AdwSpinnerPaintable)
6117    -> *mut gtk::GtkWidget;
6118    #[cfg(feature = "v1_6")]
6119    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
6120    pub fn adw_spinner_paintable_set_widget(
6121        self_: *mut AdwSpinnerPaintable,
6122        widget: *mut gtk::GtkWidget,
6123    );
6124
6125    //=========================================================================
6126    // AdwSplitButton
6127    //=========================================================================
6128    pub fn adw_split_button_get_type() -> GType;
6129    pub fn adw_split_button_new() -> *mut gtk::GtkWidget;
6130    #[cfg(feature = "v1_4")]
6131    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6132    pub fn adw_split_button_get_can_shrink(self_: *mut AdwSplitButton) -> gboolean;
6133    pub fn adw_split_button_get_child(self_: *mut AdwSplitButton) -> *mut gtk::GtkWidget;
6134    pub fn adw_split_button_get_direction(self_: *mut AdwSplitButton) -> gtk::GtkArrowType;
6135    #[cfg(feature = "v1_2")]
6136    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
6137    pub fn adw_split_button_get_dropdown_tooltip(self_: *mut AdwSplitButton) -> *const c_char;
6138    pub fn adw_split_button_get_icon_name(self_: *mut AdwSplitButton) -> *const c_char;
6139    pub fn adw_split_button_get_label(self_: *mut AdwSplitButton) -> *const c_char;
6140    pub fn adw_split_button_get_menu_model(self_: *mut AdwSplitButton) -> *mut gio::GMenuModel;
6141    pub fn adw_split_button_get_popover(self_: *mut AdwSplitButton) -> *mut gtk::GtkPopover;
6142    pub fn adw_split_button_get_use_underline(self_: *mut AdwSplitButton) -> gboolean;
6143    pub fn adw_split_button_popdown(self_: *mut AdwSplitButton);
6144    pub fn adw_split_button_popup(self_: *mut AdwSplitButton);
6145    #[cfg(feature = "v1_4")]
6146    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6147    pub fn adw_split_button_set_can_shrink(self_: *mut AdwSplitButton, can_shrink: gboolean);
6148    pub fn adw_split_button_set_child(self_: *mut AdwSplitButton, child: *mut gtk::GtkWidget);
6149    pub fn adw_split_button_set_direction(self_: *mut AdwSplitButton, direction: gtk::GtkArrowType);
6150    #[cfg(feature = "v1_2")]
6151    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
6152    pub fn adw_split_button_set_dropdown_tooltip(
6153        self_: *mut AdwSplitButton,
6154        tooltip: *const c_char,
6155    );
6156    pub fn adw_split_button_set_icon_name(self_: *mut AdwSplitButton, icon_name: *const c_char);
6157    pub fn adw_split_button_set_label(self_: *mut AdwSplitButton, label: *const c_char);
6158    pub fn adw_split_button_set_menu_model(
6159        self_: *mut AdwSplitButton,
6160        menu_model: *mut gio::GMenuModel,
6161    );
6162    pub fn adw_split_button_set_popover(self_: *mut AdwSplitButton, popover: *mut gtk::GtkPopover);
6163    pub fn adw_split_button_set_use_underline(self_: *mut AdwSplitButton, use_underline: gboolean);
6164
6165    //=========================================================================
6166    // AdwSpringAnimation
6167    //=========================================================================
6168    pub fn adw_spring_animation_get_type() -> GType;
6169    pub fn adw_spring_animation_new(
6170        widget: *mut gtk::GtkWidget,
6171        from: c_double,
6172        to: c_double,
6173        spring_params: *mut AdwSpringParams,
6174        target: *mut AdwAnimationTarget,
6175    ) -> *mut AdwAnimation;
6176    #[cfg(feature = "v1_3")]
6177    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6178    pub fn adw_spring_animation_calculate_value(
6179        self_: *mut AdwSpringAnimation,
6180        time: c_uint,
6181    ) -> c_double;
6182    #[cfg(feature = "v1_3")]
6183    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6184    pub fn adw_spring_animation_calculate_velocity(
6185        self_: *mut AdwSpringAnimation,
6186        time: c_uint,
6187    ) -> c_double;
6188    pub fn adw_spring_animation_get_clamp(self_: *mut AdwSpringAnimation) -> gboolean;
6189    pub fn adw_spring_animation_get_epsilon(self_: *mut AdwSpringAnimation) -> c_double;
6190    pub fn adw_spring_animation_get_estimated_duration(self_: *mut AdwSpringAnimation) -> c_uint;
6191    pub fn adw_spring_animation_get_initial_velocity(self_: *mut AdwSpringAnimation) -> c_double;
6192    pub fn adw_spring_animation_get_spring_params(
6193        self_: *mut AdwSpringAnimation,
6194    ) -> *mut AdwSpringParams;
6195    pub fn adw_spring_animation_get_value_from(self_: *mut AdwSpringAnimation) -> c_double;
6196    pub fn adw_spring_animation_get_value_to(self_: *mut AdwSpringAnimation) -> c_double;
6197    pub fn adw_spring_animation_get_velocity(self_: *mut AdwSpringAnimation) -> c_double;
6198    pub fn adw_spring_animation_set_clamp(self_: *mut AdwSpringAnimation, clamp: gboolean);
6199    pub fn adw_spring_animation_set_epsilon(self_: *mut AdwSpringAnimation, epsilon: c_double);
6200    pub fn adw_spring_animation_set_initial_velocity(
6201        self_: *mut AdwSpringAnimation,
6202        velocity: c_double,
6203    );
6204    pub fn adw_spring_animation_set_spring_params(
6205        self_: *mut AdwSpringAnimation,
6206        spring_params: *mut AdwSpringParams,
6207    );
6208    pub fn adw_spring_animation_set_value_from(self_: *mut AdwSpringAnimation, value: c_double);
6209    pub fn adw_spring_animation_set_value_to(self_: *mut AdwSpringAnimation, value: c_double);
6210
6211    //=========================================================================
6212    // AdwSqueezer
6213    //=========================================================================
6214    pub fn adw_squeezer_get_type() -> GType;
6215    pub fn adw_squeezer_new() -> *mut gtk::GtkWidget;
6216    pub fn adw_squeezer_add(
6217        self_: *mut AdwSqueezer,
6218        child: *mut gtk::GtkWidget,
6219    ) -> *mut AdwSqueezerPage;
6220    pub fn adw_squeezer_get_allow_none(self_: *mut AdwSqueezer) -> gboolean;
6221    pub fn adw_squeezer_get_homogeneous(self_: *mut AdwSqueezer) -> gboolean;
6222    pub fn adw_squeezer_get_interpolate_size(self_: *mut AdwSqueezer) -> gboolean;
6223    pub fn adw_squeezer_get_page(
6224        self_: *mut AdwSqueezer,
6225        child: *mut gtk::GtkWidget,
6226    ) -> *mut AdwSqueezerPage;
6227    pub fn adw_squeezer_get_pages(self_: *mut AdwSqueezer) -> *mut gtk::GtkSelectionModel;
6228    pub fn adw_squeezer_get_switch_threshold_policy(
6229        self_: *mut AdwSqueezer,
6230    ) -> AdwFoldThresholdPolicy;
6231    pub fn adw_squeezer_get_transition_duration(self_: *mut AdwSqueezer) -> c_uint;
6232    pub fn adw_squeezer_get_transition_running(self_: *mut AdwSqueezer) -> gboolean;
6233    pub fn adw_squeezer_get_transition_type(self_: *mut AdwSqueezer) -> AdwSqueezerTransitionType;
6234    pub fn adw_squeezer_get_visible_child(self_: *mut AdwSqueezer) -> *mut gtk::GtkWidget;
6235    pub fn adw_squeezer_get_xalign(self_: *mut AdwSqueezer) -> c_float;
6236    pub fn adw_squeezer_get_yalign(self_: *mut AdwSqueezer) -> c_float;
6237    pub fn adw_squeezer_remove(self_: *mut AdwSqueezer, child: *mut gtk::GtkWidget);
6238    pub fn adw_squeezer_set_allow_none(self_: *mut AdwSqueezer, allow_none: gboolean);
6239    pub fn adw_squeezer_set_homogeneous(self_: *mut AdwSqueezer, homogeneous: gboolean);
6240    pub fn adw_squeezer_set_interpolate_size(self_: *mut AdwSqueezer, interpolate_size: gboolean);
6241    pub fn adw_squeezer_set_switch_threshold_policy(
6242        self_: *mut AdwSqueezer,
6243        policy: AdwFoldThresholdPolicy,
6244    );
6245    pub fn adw_squeezer_set_transition_duration(self_: *mut AdwSqueezer, duration: c_uint);
6246    pub fn adw_squeezer_set_transition_type(
6247        self_: *mut AdwSqueezer,
6248        transition: AdwSqueezerTransitionType,
6249    );
6250    pub fn adw_squeezer_set_xalign(self_: *mut AdwSqueezer, xalign: c_float);
6251    pub fn adw_squeezer_set_yalign(self_: *mut AdwSqueezer, yalign: c_float);
6252
6253    //=========================================================================
6254    // AdwSqueezerPage
6255    //=========================================================================
6256    pub fn adw_squeezer_page_get_type() -> GType;
6257    pub fn adw_squeezer_page_get_child(self_: *mut AdwSqueezerPage) -> *mut gtk::GtkWidget;
6258    pub fn adw_squeezer_page_get_enabled(self_: *mut AdwSqueezerPage) -> gboolean;
6259    pub fn adw_squeezer_page_set_enabled(self_: *mut AdwSqueezerPage, enabled: gboolean);
6260
6261    //=========================================================================
6262    // AdwStatusPage
6263    //=========================================================================
6264    pub fn adw_status_page_get_type() -> GType;
6265    pub fn adw_status_page_new() -> *mut gtk::GtkWidget;
6266    pub fn adw_status_page_get_child(self_: *mut AdwStatusPage) -> *mut gtk::GtkWidget;
6267    pub fn adw_status_page_get_description(self_: *mut AdwStatusPage) -> *const c_char;
6268    pub fn adw_status_page_get_icon_name(self_: *mut AdwStatusPage) -> *const c_char;
6269    pub fn adw_status_page_get_paintable(self_: *mut AdwStatusPage) -> *mut gdk::GdkPaintable;
6270    pub fn adw_status_page_get_title(self_: *mut AdwStatusPage) -> *const c_char;
6271    pub fn adw_status_page_set_child(self_: *mut AdwStatusPage, child: *mut gtk::GtkWidget);
6272    pub fn adw_status_page_set_description(self_: *mut AdwStatusPage, description: *const c_char);
6273    pub fn adw_status_page_set_icon_name(self_: *mut AdwStatusPage, icon_name: *const c_char);
6274    pub fn adw_status_page_set_paintable(
6275        self_: *mut AdwStatusPage,
6276        paintable: *mut gdk::GdkPaintable,
6277    );
6278    pub fn adw_status_page_set_title(self_: *mut AdwStatusPage, title: *const c_char);
6279
6280    //=========================================================================
6281    // AdwStyleManager
6282    //=========================================================================
6283    pub fn adw_style_manager_get_type() -> GType;
6284    pub fn adw_style_manager_get_default() -> *mut AdwStyleManager;
6285    pub fn adw_style_manager_get_for_display(display: *mut gdk::GdkDisplay)
6286    -> *mut AdwStyleManager;
6287    #[cfg(feature = "v1_6")]
6288    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
6289    pub fn adw_style_manager_get_accent_color(self_: *mut AdwStyleManager) -> AdwAccentColor;
6290    #[cfg(feature = "v1_6")]
6291    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
6292    pub fn adw_style_manager_get_accent_color_rgba(
6293        self_: *mut AdwStyleManager,
6294    ) -> *mut gdk::GdkRGBA;
6295    pub fn adw_style_manager_get_color_scheme(self_: *mut AdwStyleManager) -> AdwColorScheme;
6296    pub fn adw_style_manager_get_dark(self_: *mut AdwStyleManager) -> gboolean;
6297    pub fn adw_style_manager_get_display(self_: *mut AdwStyleManager) -> *mut gdk::GdkDisplay;
6298    #[cfg(feature = "v1_7")]
6299    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6300    pub fn adw_style_manager_get_document_font_name(self_: *mut AdwStyleManager) -> *const c_char;
6301    pub fn adw_style_manager_get_high_contrast(self_: *mut AdwStyleManager) -> gboolean;
6302    #[cfg(feature = "v1_7")]
6303    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6304    pub fn adw_style_manager_get_monospace_font_name(self_: *mut AdwStyleManager) -> *const c_char;
6305    #[cfg(feature = "v1_6")]
6306    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
6307    pub fn adw_style_manager_get_system_supports_accent_colors(
6308        self_: *mut AdwStyleManager,
6309    ) -> gboolean;
6310    pub fn adw_style_manager_get_system_supports_color_schemes(
6311        self_: *mut AdwStyleManager,
6312    ) -> gboolean;
6313    pub fn adw_style_manager_set_color_scheme(
6314        self_: *mut AdwStyleManager,
6315        color_scheme: AdwColorScheme,
6316    );
6317
6318    //=========================================================================
6319    // AdwSwipeTracker
6320    //=========================================================================
6321    pub fn adw_swipe_tracker_get_type() -> GType;
6322    pub fn adw_swipe_tracker_new(swipeable: *mut AdwSwipeable) -> *mut AdwSwipeTracker;
6323    pub fn adw_swipe_tracker_get_allow_long_swipes(self_: *mut AdwSwipeTracker) -> gboolean;
6324    pub fn adw_swipe_tracker_get_allow_mouse_drag(self_: *mut AdwSwipeTracker) -> gboolean;
6325    #[cfg(feature = "v1_5")]
6326    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
6327    pub fn adw_swipe_tracker_get_allow_window_handle(self_: *mut AdwSwipeTracker) -> gboolean;
6328    pub fn adw_swipe_tracker_get_enabled(self_: *mut AdwSwipeTracker) -> gboolean;
6329    #[cfg(feature = "v1_4")]
6330    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6331    pub fn adw_swipe_tracker_get_lower_overshoot(self_: *mut AdwSwipeTracker) -> gboolean;
6332    pub fn adw_swipe_tracker_get_reversed(self_: *mut AdwSwipeTracker) -> gboolean;
6333    pub fn adw_swipe_tracker_get_swipeable(self_: *mut AdwSwipeTracker) -> *mut AdwSwipeable;
6334    #[cfg(feature = "v1_4")]
6335    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6336    pub fn adw_swipe_tracker_get_upper_overshoot(self_: *mut AdwSwipeTracker) -> gboolean;
6337    pub fn adw_swipe_tracker_set_allow_long_swipes(
6338        self_: *mut AdwSwipeTracker,
6339        allow_long_swipes: gboolean,
6340    );
6341    pub fn adw_swipe_tracker_set_allow_mouse_drag(
6342        self_: *mut AdwSwipeTracker,
6343        allow_mouse_drag: gboolean,
6344    );
6345    #[cfg(feature = "v1_5")]
6346    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
6347    pub fn adw_swipe_tracker_set_allow_window_handle(
6348        self_: *mut AdwSwipeTracker,
6349        allow_window_handle: gboolean,
6350    );
6351    pub fn adw_swipe_tracker_set_enabled(self_: *mut AdwSwipeTracker, enabled: gboolean);
6352    #[cfg(feature = "v1_4")]
6353    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6354    pub fn adw_swipe_tracker_set_lower_overshoot(self_: *mut AdwSwipeTracker, overshoot: gboolean);
6355    pub fn adw_swipe_tracker_set_reversed(self_: *mut AdwSwipeTracker, reversed: gboolean);
6356    #[cfg(feature = "v1_4")]
6357    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6358    pub fn adw_swipe_tracker_set_upper_overshoot(self_: *mut AdwSwipeTracker, overshoot: gboolean);
6359    pub fn adw_swipe_tracker_shift_position(self_: *mut AdwSwipeTracker, delta: c_double);
6360
6361    //=========================================================================
6362    // AdwSwitchRow
6363    //=========================================================================
6364    #[cfg(feature = "v1_4")]
6365    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6366    pub fn adw_switch_row_get_type() -> GType;
6367    #[cfg(feature = "v1_4")]
6368    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6369    pub fn adw_switch_row_new() -> *mut gtk::GtkWidget;
6370    #[cfg(feature = "v1_4")]
6371    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6372    pub fn adw_switch_row_get_active(self_: *mut AdwSwitchRow) -> gboolean;
6373    #[cfg(feature = "v1_4")]
6374    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6375    pub fn adw_switch_row_set_active(self_: *mut AdwSwitchRow, is_active: gboolean);
6376
6377    //=========================================================================
6378    // AdwTabBar
6379    //=========================================================================
6380    pub fn adw_tab_bar_get_type() -> GType;
6381    pub fn adw_tab_bar_new() -> *mut AdwTabBar;
6382    pub fn adw_tab_bar_get_autohide(self_: *mut AdwTabBar) -> gboolean;
6383    pub fn adw_tab_bar_get_end_action_widget(self_: *mut AdwTabBar) -> *mut gtk::GtkWidget;
6384    pub fn adw_tab_bar_get_expand_tabs(self_: *mut AdwTabBar) -> gboolean;
6385    #[cfg(feature = "v1_4")]
6386    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6387    pub fn adw_tab_bar_get_extra_drag_preferred_action(self_: *mut AdwTabBar)
6388    -> gdk::GdkDragAction;
6389    #[cfg(feature = "v1_3")]
6390    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6391    pub fn adw_tab_bar_get_extra_drag_preload(self_: *mut AdwTabBar) -> gboolean;
6392    pub fn adw_tab_bar_get_inverted(self_: *mut AdwTabBar) -> gboolean;
6393    pub fn adw_tab_bar_get_is_overflowing(self_: *mut AdwTabBar) -> gboolean;
6394    pub fn adw_tab_bar_get_start_action_widget(self_: *mut AdwTabBar) -> *mut gtk::GtkWidget;
6395    pub fn adw_tab_bar_get_tabs_revealed(self_: *mut AdwTabBar) -> gboolean;
6396    pub fn adw_tab_bar_get_view(self_: *mut AdwTabBar) -> *mut AdwTabView;
6397    pub fn adw_tab_bar_set_autohide(self_: *mut AdwTabBar, autohide: gboolean);
6398    pub fn adw_tab_bar_set_end_action_widget(self_: *mut AdwTabBar, widget: *mut gtk::GtkWidget);
6399    pub fn adw_tab_bar_set_expand_tabs(self_: *mut AdwTabBar, expand_tabs: gboolean);
6400    #[cfg(feature = "v1_3")]
6401    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6402    pub fn adw_tab_bar_set_extra_drag_preload(self_: *mut AdwTabBar, preload: gboolean);
6403    pub fn adw_tab_bar_set_inverted(self_: *mut AdwTabBar, inverted: gboolean);
6404    pub fn adw_tab_bar_set_start_action_widget(self_: *mut AdwTabBar, widget: *mut gtk::GtkWidget);
6405    pub fn adw_tab_bar_set_view(self_: *mut AdwTabBar, view: *mut AdwTabView);
6406    pub fn adw_tab_bar_setup_extra_drop_target(
6407        self_: *mut AdwTabBar,
6408        actions: gdk::GdkDragAction,
6409        types: *mut GType,
6410        n_types: size_t,
6411    );
6412
6413    //=========================================================================
6414    // AdwTabButton
6415    //=========================================================================
6416    #[cfg(feature = "v1_3")]
6417    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6418    pub fn adw_tab_button_get_type() -> GType;
6419    #[cfg(feature = "v1_3")]
6420    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6421    pub fn adw_tab_button_new() -> *mut gtk::GtkWidget;
6422    #[cfg(feature = "v1_3")]
6423    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6424    pub fn adw_tab_button_get_view(self_: *mut AdwTabButton) -> *mut AdwTabView;
6425    #[cfg(feature = "v1_3")]
6426    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6427    pub fn adw_tab_button_set_view(self_: *mut AdwTabButton, view: *mut AdwTabView);
6428
6429    //=========================================================================
6430    // AdwTabOverview
6431    //=========================================================================
6432    #[cfg(feature = "v1_3")]
6433    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6434    pub fn adw_tab_overview_get_type() -> GType;
6435    #[cfg(feature = "v1_3")]
6436    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6437    pub fn adw_tab_overview_new() -> *mut gtk::GtkWidget;
6438    #[cfg(feature = "v1_3")]
6439    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6440    pub fn adw_tab_overview_get_child(self_: *mut AdwTabOverview) -> *mut gtk::GtkWidget;
6441    #[cfg(feature = "v1_3")]
6442    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6443    pub fn adw_tab_overview_get_enable_new_tab(self_: *mut AdwTabOverview) -> gboolean;
6444    #[cfg(feature = "v1_3")]
6445    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6446    pub fn adw_tab_overview_get_enable_search(self_: *mut AdwTabOverview) -> gboolean;
6447    #[cfg(feature = "v1_4")]
6448    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6449    pub fn adw_tab_overview_get_extra_drag_preferred_action(
6450        self_: *mut AdwTabOverview,
6451    ) -> gdk::GdkDragAction;
6452    #[cfg(feature = "v1_3")]
6453    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6454    pub fn adw_tab_overview_get_extra_drag_preload(self_: *mut AdwTabOverview) -> gboolean;
6455    #[cfg(feature = "v1_3")]
6456    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6457    pub fn adw_tab_overview_get_inverted(self_: *mut AdwTabOverview) -> gboolean;
6458    #[cfg(feature = "v1_3")]
6459    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6460    pub fn adw_tab_overview_get_open(self_: *mut AdwTabOverview) -> gboolean;
6461    #[cfg(feature = "v1_3")]
6462    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6463    pub fn adw_tab_overview_get_search_active(self_: *mut AdwTabOverview) -> gboolean;
6464    #[cfg(feature = "v1_3")]
6465    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6466    pub fn adw_tab_overview_get_secondary_menu(self_: *mut AdwTabOverview) -> *mut gio::GMenuModel;
6467    #[cfg(feature = "v1_3")]
6468    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6469    pub fn adw_tab_overview_get_show_end_title_buttons(self_: *mut AdwTabOverview) -> gboolean;
6470    #[cfg(feature = "v1_3")]
6471    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6472    pub fn adw_tab_overview_get_show_start_title_buttons(self_: *mut AdwTabOverview) -> gboolean;
6473    #[cfg(feature = "v1_3")]
6474    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6475    pub fn adw_tab_overview_get_view(self_: *mut AdwTabOverview) -> *mut AdwTabView;
6476    #[cfg(feature = "v1_3")]
6477    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6478    pub fn adw_tab_overview_set_child(self_: *mut AdwTabOverview, child: *mut gtk::GtkWidget);
6479    #[cfg(feature = "v1_3")]
6480    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6481    pub fn adw_tab_overview_set_enable_new_tab(
6482        self_: *mut AdwTabOverview,
6483        enable_new_tab: gboolean,
6484    );
6485    #[cfg(feature = "v1_3")]
6486    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6487    pub fn adw_tab_overview_set_enable_search(self_: *mut AdwTabOverview, enable_search: gboolean);
6488    #[cfg(feature = "v1_3")]
6489    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6490    pub fn adw_tab_overview_set_extra_drag_preload(self_: *mut AdwTabOverview, preload: gboolean);
6491    #[cfg(feature = "v1_3")]
6492    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6493    pub fn adw_tab_overview_set_inverted(self_: *mut AdwTabOverview, inverted: gboolean);
6494    #[cfg(feature = "v1_3")]
6495    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6496    pub fn adw_tab_overview_set_open(self_: *mut AdwTabOverview, open: gboolean);
6497    #[cfg(feature = "v1_3")]
6498    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6499    pub fn adw_tab_overview_set_secondary_menu(
6500        self_: *mut AdwTabOverview,
6501        secondary_menu: *mut gio::GMenuModel,
6502    );
6503    #[cfg(feature = "v1_3")]
6504    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6505    pub fn adw_tab_overview_set_show_end_title_buttons(
6506        self_: *mut AdwTabOverview,
6507        show_end_title_buttons: gboolean,
6508    );
6509    #[cfg(feature = "v1_3")]
6510    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6511    pub fn adw_tab_overview_set_show_start_title_buttons(
6512        self_: *mut AdwTabOverview,
6513        show_start_title_buttons: gboolean,
6514    );
6515    #[cfg(feature = "v1_3")]
6516    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6517    pub fn adw_tab_overview_set_view(self_: *mut AdwTabOverview, view: *mut AdwTabView);
6518    #[cfg(feature = "v1_3")]
6519    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6520    pub fn adw_tab_overview_setup_extra_drop_target(
6521        self_: *mut AdwTabOverview,
6522        actions: gdk::GdkDragAction,
6523        types: *mut GType,
6524        n_types: size_t,
6525    );
6526
6527    //=========================================================================
6528    // AdwTabPage
6529    //=========================================================================
6530    pub fn adw_tab_page_get_type() -> GType;
6531    pub fn adw_tab_page_get_child(self_: *mut AdwTabPage) -> *mut gtk::GtkWidget;
6532    pub fn adw_tab_page_get_icon(self_: *mut AdwTabPage) -> *mut gio::GIcon;
6533    pub fn adw_tab_page_get_indicator_activatable(self_: *mut AdwTabPage) -> gboolean;
6534    pub fn adw_tab_page_get_indicator_icon(self_: *mut AdwTabPage) -> *mut gio::GIcon;
6535    #[cfg(feature = "v1_2")]
6536    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
6537    pub fn adw_tab_page_get_indicator_tooltip(self_: *mut AdwTabPage) -> *const c_char;
6538    #[cfg(feature = "v1_3")]
6539    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6540    pub fn adw_tab_page_get_keyword(self_: *mut AdwTabPage) -> *const c_char;
6541    #[cfg(feature = "v1_3")]
6542    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6543    pub fn adw_tab_page_get_live_thumbnail(self_: *mut AdwTabPage) -> gboolean;
6544    pub fn adw_tab_page_get_loading(self_: *mut AdwTabPage) -> gboolean;
6545    pub fn adw_tab_page_get_needs_attention(self_: *mut AdwTabPage) -> gboolean;
6546    pub fn adw_tab_page_get_parent(self_: *mut AdwTabPage) -> *mut AdwTabPage;
6547    pub fn adw_tab_page_get_pinned(self_: *mut AdwTabPage) -> gboolean;
6548    pub fn adw_tab_page_get_selected(self_: *mut AdwTabPage) -> gboolean;
6549    #[cfg(feature = "v1_3")]
6550    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6551    pub fn adw_tab_page_get_thumbnail_xalign(self_: *mut AdwTabPage) -> c_float;
6552    #[cfg(feature = "v1_3")]
6553    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6554    pub fn adw_tab_page_get_thumbnail_yalign(self_: *mut AdwTabPage) -> c_float;
6555    pub fn adw_tab_page_get_title(self_: *mut AdwTabPage) -> *const c_char;
6556    pub fn adw_tab_page_get_tooltip(self_: *mut AdwTabPage) -> *const c_char;
6557    #[cfg(feature = "v1_3")]
6558    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6559    pub fn adw_tab_page_invalidate_thumbnail(self_: *mut AdwTabPage);
6560    pub fn adw_tab_page_set_icon(self_: *mut AdwTabPage, icon: *mut gio::GIcon);
6561    pub fn adw_tab_page_set_indicator_activatable(self_: *mut AdwTabPage, activatable: gboolean);
6562    pub fn adw_tab_page_set_indicator_icon(self_: *mut AdwTabPage, indicator_icon: *mut gio::GIcon);
6563    #[cfg(feature = "v1_2")]
6564    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
6565    pub fn adw_tab_page_set_indicator_tooltip(self_: *mut AdwTabPage, tooltip: *const c_char);
6566    #[cfg(feature = "v1_3")]
6567    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6568    pub fn adw_tab_page_set_keyword(self_: *mut AdwTabPage, keyword: *const c_char);
6569    #[cfg(feature = "v1_3")]
6570    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6571    pub fn adw_tab_page_set_live_thumbnail(self_: *mut AdwTabPage, live_thumbnail: gboolean);
6572    pub fn adw_tab_page_set_loading(self_: *mut AdwTabPage, loading: gboolean);
6573    pub fn adw_tab_page_set_needs_attention(self_: *mut AdwTabPage, needs_attention: gboolean);
6574    #[cfg(feature = "v1_3")]
6575    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6576    pub fn adw_tab_page_set_thumbnail_xalign(self_: *mut AdwTabPage, xalign: c_float);
6577    #[cfg(feature = "v1_3")]
6578    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6579    pub fn adw_tab_page_set_thumbnail_yalign(self_: *mut AdwTabPage, yalign: c_float);
6580    pub fn adw_tab_page_set_title(self_: *mut AdwTabPage, title: *const c_char);
6581    pub fn adw_tab_page_set_tooltip(self_: *mut AdwTabPage, tooltip: *const c_char);
6582
6583    //=========================================================================
6584    // AdwTabView
6585    //=========================================================================
6586    pub fn adw_tab_view_get_type() -> GType;
6587    pub fn adw_tab_view_new() -> *mut AdwTabView;
6588    pub fn adw_tab_view_add_page(
6589        self_: *mut AdwTabView,
6590        child: *mut gtk::GtkWidget,
6591        parent: *mut AdwTabPage,
6592    ) -> *mut AdwTabPage;
6593    #[cfg(feature = "v1_2")]
6594    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
6595    pub fn adw_tab_view_add_shortcuts(self_: *mut AdwTabView, shortcuts: AdwTabViewShortcuts);
6596    pub fn adw_tab_view_append(
6597        self_: *mut AdwTabView,
6598        child: *mut gtk::GtkWidget,
6599    ) -> *mut AdwTabPage;
6600    pub fn adw_tab_view_append_pinned(
6601        self_: *mut AdwTabView,
6602        child: *mut gtk::GtkWidget,
6603    ) -> *mut AdwTabPage;
6604    pub fn adw_tab_view_close_other_pages(self_: *mut AdwTabView, page: *mut AdwTabPage);
6605    pub fn adw_tab_view_close_page(self_: *mut AdwTabView, page: *mut AdwTabPage);
6606    pub fn adw_tab_view_close_page_finish(
6607        self_: *mut AdwTabView,
6608        page: *mut AdwTabPage,
6609        confirm: gboolean,
6610    );
6611    pub fn adw_tab_view_close_pages_after(self_: *mut AdwTabView, page: *mut AdwTabPage);
6612    pub fn adw_tab_view_close_pages_before(self_: *mut AdwTabView, page: *mut AdwTabPage);
6613    pub fn adw_tab_view_get_default_icon(self_: *mut AdwTabView) -> *mut gio::GIcon;
6614    pub fn adw_tab_view_get_is_transferring_page(self_: *mut AdwTabView) -> gboolean;
6615    pub fn adw_tab_view_get_menu_model(self_: *mut AdwTabView) -> *mut gio::GMenuModel;
6616    pub fn adw_tab_view_get_n_pages(self_: *mut AdwTabView) -> c_int;
6617    pub fn adw_tab_view_get_n_pinned_pages(self_: *mut AdwTabView) -> c_int;
6618    pub fn adw_tab_view_get_nth_page(self_: *mut AdwTabView, position: c_int) -> *mut AdwTabPage;
6619    pub fn adw_tab_view_get_page(
6620        self_: *mut AdwTabView,
6621        child: *mut gtk::GtkWidget,
6622    ) -> *mut AdwTabPage;
6623    pub fn adw_tab_view_get_page_position(self_: *mut AdwTabView, page: *mut AdwTabPage) -> c_int;
6624    pub fn adw_tab_view_get_pages(self_: *mut AdwTabView) -> *mut gtk::GtkSelectionModel;
6625    pub fn adw_tab_view_get_selected_page(self_: *mut AdwTabView) -> *mut AdwTabPage;
6626    #[cfg(feature = "v1_2")]
6627    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
6628    pub fn adw_tab_view_get_shortcuts(self_: *mut AdwTabView) -> AdwTabViewShortcuts;
6629    pub fn adw_tab_view_insert(
6630        self_: *mut AdwTabView,
6631        child: *mut gtk::GtkWidget,
6632        position: c_int,
6633    ) -> *mut AdwTabPage;
6634    pub fn adw_tab_view_insert_pinned(
6635        self_: *mut AdwTabView,
6636        child: *mut gtk::GtkWidget,
6637        position: c_int,
6638    ) -> *mut AdwTabPage;
6639    #[cfg(feature = "v1_3")]
6640    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
6641    pub fn adw_tab_view_invalidate_thumbnails(self_: *mut AdwTabView);
6642    pub fn adw_tab_view_prepend(
6643        self_: *mut AdwTabView,
6644        child: *mut gtk::GtkWidget,
6645    ) -> *mut AdwTabPage;
6646    pub fn adw_tab_view_prepend_pinned(
6647        self_: *mut AdwTabView,
6648        child: *mut gtk::GtkWidget,
6649    ) -> *mut AdwTabPage;
6650    #[cfg(feature = "v1_2")]
6651    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
6652    pub fn adw_tab_view_remove_shortcuts(self_: *mut AdwTabView, shortcuts: AdwTabViewShortcuts);
6653    pub fn adw_tab_view_reorder_backward(self_: *mut AdwTabView, page: *mut AdwTabPage)
6654    -> gboolean;
6655    pub fn adw_tab_view_reorder_first(self_: *mut AdwTabView, page: *mut AdwTabPage) -> gboolean;
6656    pub fn adw_tab_view_reorder_forward(self_: *mut AdwTabView, page: *mut AdwTabPage) -> gboolean;
6657    pub fn adw_tab_view_reorder_last(self_: *mut AdwTabView, page: *mut AdwTabPage) -> gboolean;
6658    pub fn adw_tab_view_reorder_page(
6659        self_: *mut AdwTabView,
6660        page: *mut AdwTabPage,
6661        position: c_int,
6662    ) -> gboolean;
6663    pub fn adw_tab_view_select_next_page(self_: *mut AdwTabView) -> gboolean;
6664    pub fn adw_tab_view_select_previous_page(self_: *mut AdwTabView) -> gboolean;
6665    pub fn adw_tab_view_set_default_icon(self_: *mut AdwTabView, default_icon: *mut gio::GIcon);
6666    pub fn adw_tab_view_set_menu_model(self_: *mut AdwTabView, menu_model: *mut gio::GMenuModel);
6667    pub fn adw_tab_view_set_page_pinned(
6668        self_: *mut AdwTabView,
6669        page: *mut AdwTabPage,
6670        pinned: gboolean,
6671    );
6672    pub fn adw_tab_view_set_selected_page(self_: *mut AdwTabView, selected_page: *mut AdwTabPage);
6673    #[cfg(feature = "v1_2")]
6674    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
6675    pub fn adw_tab_view_set_shortcuts(self_: *mut AdwTabView, shortcuts: AdwTabViewShortcuts);
6676    pub fn adw_tab_view_transfer_page(
6677        self_: *mut AdwTabView,
6678        page: *mut AdwTabPage,
6679        other_view: *mut AdwTabView,
6680        position: c_int,
6681    );
6682
6683    //=========================================================================
6684    // AdwTimedAnimation
6685    //=========================================================================
6686    pub fn adw_timed_animation_get_type() -> GType;
6687    pub fn adw_timed_animation_new(
6688        widget: *mut gtk::GtkWidget,
6689        from: c_double,
6690        to: c_double,
6691        duration: c_uint,
6692        target: *mut AdwAnimationTarget,
6693    ) -> *mut AdwAnimation;
6694    pub fn adw_timed_animation_get_alternate(self_: *mut AdwTimedAnimation) -> gboolean;
6695    pub fn adw_timed_animation_get_duration(self_: *mut AdwTimedAnimation) -> c_uint;
6696    pub fn adw_timed_animation_get_easing(self_: *mut AdwTimedAnimation) -> AdwEasing;
6697    pub fn adw_timed_animation_get_repeat_count(self_: *mut AdwTimedAnimation) -> c_uint;
6698    pub fn adw_timed_animation_get_reverse(self_: *mut AdwTimedAnimation) -> gboolean;
6699    pub fn adw_timed_animation_get_value_from(self_: *mut AdwTimedAnimation) -> c_double;
6700    pub fn adw_timed_animation_get_value_to(self_: *mut AdwTimedAnimation) -> c_double;
6701    pub fn adw_timed_animation_set_alternate(self_: *mut AdwTimedAnimation, alternate: gboolean);
6702    pub fn adw_timed_animation_set_duration(self_: *mut AdwTimedAnimation, duration: c_uint);
6703    pub fn adw_timed_animation_set_easing(self_: *mut AdwTimedAnimation, easing: AdwEasing);
6704    pub fn adw_timed_animation_set_repeat_count(
6705        self_: *mut AdwTimedAnimation,
6706        repeat_count: c_uint,
6707    );
6708    pub fn adw_timed_animation_set_reverse(self_: *mut AdwTimedAnimation, reverse: gboolean);
6709    pub fn adw_timed_animation_set_value_from(self_: *mut AdwTimedAnimation, value: c_double);
6710    pub fn adw_timed_animation_set_value_to(self_: *mut AdwTimedAnimation, value: c_double);
6711
6712    //=========================================================================
6713    // AdwToast
6714    //=========================================================================
6715    pub fn adw_toast_get_type() -> GType;
6716    pub fn adw_toast_new(title: *const c_char) -> *mut AdwToast;
6717    #[cfg(feature = "v1_2")]
6718    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
6719    pub fn adw_toast_new_format(format: *const c_char, ...) -> *mut AdwToast;
6720    pub fn adw_toast_dismiss(self_: *mut AdwToast);
6721    pub fn adw_toast_get_action_name(self_: *mut AdwToast) -> *const c_char;
6722    pub fn adw_toast_get_action_target_value(self_: *mut AdwToast) -> *mut glib::GVariant;
6723    pub fn adw_toast_get_button_label(self_: *mut AdwToast) -> *const c_char;
6724    #[cfg(feature = "v1_2")]
6725    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
6726    pub fn adw_toast_get_custom_title(self_: *mut AdwToast) -> *mut gtk::GtkWidget;
6727    pub fn adw_toast_get_priority(self_: *mut AdwToast) -> AdwToastPriority;
6728    pub fn adw_toast_get_timeout(self_: *mut AdwToast) -> c_uint;
6729    pub fn adw_toast_get_title(self_: *mut AdwToast) -> *const c_char;
6730    #[cfg(feature = "v1_4")]
6731    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6732    pub fn adw_toast_get_use_markup(self_: *mut AdwToast) -> gboolean;
6733    pub fn adw_toast_set_action_name(self_: *mut AdwToast, action_name: *const c_char);
6734    pub fn adw_toast_set_action_target(self_: *mut AdwToast, format_string: *const c_char, ...);
6735    pub fn adw_toast_set_action_target_value(
6736        self_: *mut AdwToast,
6737        action_target: *mut glib::GVariant,
6738    );
6739    pub fn adw_toast_set_button_label(self_: *mut AdwToast, button_label: *const c_char);
6740    #[cfg(feature = "v1_2")]
6741    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
6742    pub fn adw_toast_set_custom_title(self_: *mut AdwToast, widget: *mut gtk::GtkWidget);
6743    pub fn adw_toast_set_detailed_action_name(
6744        self_: *mut AdwToast,
6745        detailed_action_name: *const c_char,
6746    );
6747    pub fn adw_toast_set_priority(self_: *mut AdwToast, priority: AdwToastPriority);
6748    pub fn adw_toast_set_timeout(self_: *mut AdwToast, timeout: c_uint);
6749    pub fn adw_toast_set_title(self_: *mut AdwToast, title: *const c_char);
6750    #[cfg(feature = "v1_4")]
6751    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6752    pub fn adw_toast_set_use_markup(self_: *mut AdwToast, use_markup: gboolean);
6753
6754    //=========================================================================
6755    // AdwToastOverlay
6756    //=========================================================================
6757    pub fn adw_toast_overlay_get_type() -> GType;
6758    pub fn adw_toast_overlay_new() -> *mut gtk::GtkWidget;
6759    pub fn adw_toast_overlay_add_toast(self_: *mut AdwToastOverlay, toast: *mut AdwToast);
6760    #[cfg(feature = "v1_7")]
6761    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6762    pub fn adw_toast_overlay_dismiss_all(self_: *mut AdwToastOverlay);
6763    pub fn adw_toast_overlay_get_child(self_: *mut AdwToastOverlay) -> *mut gtk::GtkWidget;
6764    pub fn adw_toast_overlay_set_child(self_: *mut AdwToastOverlay, child: *mut gtk::GtkWidget);
6765
6766    //=========================================================================
6767    // AdwToggle
6768    //=========================================================================
6769    #[cfg(feature = "v1_7")]
6770    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6771    pub fn adw_toggle_get_type() -> GType;
6772    #[cfg(feature = "v1_7")]
6773    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6774    pub fn adw_toggle_new() -> *mut AdwToggle;
6775    #[cfg(feature = "v1_7")]
6776    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6777    pub fn adw_toggle_get_child(self_: *mut AdwToggle) -> *mut gtk::GtkWidget;
6778    #[cfg(feature = "v1_9")]
6779    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
6780    pub fn adw_toggle_get_description(self_: *mut AdwToggle) -> *const c_char;
6781    #[cfg(feature = "v1_7")]
6782    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6783    pub fn adw_toggle_get_enabled(self_: *mut AdwToggle) -> gboolean;
6784    #[cfg(feature = "v1_7")]
6785    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6786    pub fn adw_toggle_get_icon_name(self_: *mut AdwToggle) -> *const c_char;
6787    #[cfg(feature = "v1_7")]
6788    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6789    pub fn adw_toggle_get_index(self_: *mut AdwToggle) -> c_uint;
6790    #[cfg(feature = "v1_7")]
6791    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6792    pub fn adw_toggle_get_label(self_: *mut AdwToggle) -> *const c_char;
6793    #[cfg(feature = "v1_7")]
6794    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6795    pub fn adw_toggle_get_name(self_: *mut AdwToggle) -> *const c_char;
6796    #[cfg(feature = "v1_7")]
6797    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6798    pub fn adw_toggle_get_tooltip(self_: *mut AdwToggle) -> *const c_char;
6799    #[cfg(feature = "v1_7")]
6800    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6801    pub fn adw_toggle_get_use_underline(self_: *mut AdwToggle) -> gboolean;
6802    #[cfg(feature = "v1_7")]
6803    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6804    pub fn adw_toggle_set_child(self_: *mut AdwToggle, child: *mut gtk::GtkWidget);
6805    #[cfg(feature = "v1_9")]
6806    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
6807    pub fn adw_toggle_set_description(self_: *mut AdwToggle, description: *const c_char);
6808    #[cfg(feature = "v1_7")]
6809    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6810    pub fn adw_toggle_set_enabled(self_: *mut AdwToggle, enabled: gboolean);
6811    #[cfg(feature = "v1_7")]
6812    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6813    pub fn adw_toggle_set_icon_name(self_: *mut AdwToggle, icon_name: *const c_char);
6814    #[cfg(feature = "v1_7")]
6815    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6816    pub fn adw_toggle_set_label(self_: *mut AdwToggle, label: *const c_char);
6817    #[cfg(feature = "v1_7")]
6818    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6819    pub fn adw_toggle_set_name(self_: *mut AdwToggle, name: *const c_char);
6820    #[cfg(feature = "v1_7")]
6821    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6822    pub fn adw_toggle_set_tooltip(self_: *mut AdwToggle, tooltip: *const c_char);
6823    #[cfg(feature = "v1_7")]
6824    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6825    pub fn adw_toggle_set_use_underline(self_: *mut AdwToggle, use_underline: gboolean);
6826
6827    //=========================================================================
6828    // AdwToggleGroup
6829    //=========================================================================
6830    #[cfg(feature = "v1_7")]
6831    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6832    pub fn adw_toggle_group_get_type() -> GType;
6833    #[cfg(feature = "v1_7")]
6834    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6835    pub fn adw_toggle_group_new() -> *mut gtk::GtkWidget;
6836    #[cfg(feature = "v1_7")]
6837    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6838    pub fn adw_toggle_group_add(self_: *mut AdwToggleGroup, toggle: *mut AdwToggle);
6839    #[cfg(feature = "v1_7")]
6840    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6841    pub fn adw_toggle_group_get_active(self_: *mut AdwToggleGroup) -> c_uint;
6842    #[cfg(feature = "v1_7")]
6843    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6844    pub fn adw_toggle_group_get_active_name(self_: *mut AdwToggleGroup) -> *const c_char;
6845    #[cfg(feature = "v1_7")]
6846    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6847    pub fn adw_toggle_group_get_can_shrink(self_: *mut AdwToggleGroup) -> gboolean;
6848    #[cfg(feature = "v1_7")]
6849    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6850    pub fn adw_toggle_group_get_homogeneous(self_: *mut AdwToggleGroup) -> gboolean;
6851    #[cfg(feature = "v1_7")]
6852    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6853    pub fn adw_toggle_group_get_n_toggles(self_: *mut AdwToggleGroup) -> c_uint;
6854    #[cfg(feature = "v1_7")]
6855    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6856    pub fn adw_toggle_group_get_toggle(self_: *mut AdwToggleGroup, index: c_uint)
6857    -> *mut AdwToggle;
6858    #[cfg(feature = "v1_7")]
6859    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6860    pub fn adw_toggle_group_get_toggle_by_name(
6861        self_: *mut AdwToggleGroup,
6862        name: *const c_char,
6863    ) -> *mut AdwToggle;
6864    #[cfg(feature = "v1_7")]
6865    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6866    pub fn adw_toggle_group_get_toggles(self_: *mut AdwToggleGroup) -> *mut gtk::GtkSelectionModel;
6867    #[cfg(feature = "v1_7")]
6868    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6869    pub fn adw_toggle_group_remove(self_: *mut AdwToggleGroup, toggle: *mut AdwToggle);
6870    #[cfg(feature = "v1_7")]
6871    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6872    pub fn adw_toggle_group_remove_all(self_: *mut AdwToggleGroup);
6873    #[cfg(feature = "v1_7")]
6874    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6875    pub fn adw_toggle_group_set_active(self_: *mut AdwToggleGroup, active: c_uint);
6876    #[cfg(feature = "v1_7")]
6877    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6878    pub fn adw_toggle_group_set_active_name(self_: *mut AdwToggleGroup, name: *const c_char);
6879    #[cfg(feature = "v1_7")]
6880    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6881    pub fn adw_toggle_group_set_can_shrink(self_: *mut AdwToggleGroup, can_shrink: gboolean);
6882    #[cfg(feature = "v1_7")]
6883    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6884    pub fn adw_toggle_group_set_homogeneous(self_: *mut AdwToggleGroup, homogeneous: gboolean);
6885
6886    //=========================================================================
6887    // AdwToolbarView
6888    //=========================================================================
6889    #[cfg(feature = "v1_4")]
6890    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6891    pub fn adw_toolbar_view_get_type() -> GType;
6892    #[cfg(feature = "v1_4")]
6893    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6894    pub fn adw_toolbar_view_new() -> *mut gtk::GtkWidget;
6895    #[cfg(feature = "v1_4")]
6896    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6897    pub fn adw_toolbar_view_add_bottom_bar(self_: *mut AdwToolbarView, widget: *mut gtk::GtkWidget);
6898    #[cfg(feature = "v1_4")]
6899    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6900    pub fn adw_toolbar_view_add_top_bar(self_: *mut AdwToolbarView, widget: *mut gtk::GtkWidget);
6901    #[cfg(feature = "v1_4")]
6902    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6903    pub fn adw_toolbar_view_get_bottom_bar_height(self_: *mut AdwToolbarView) -> c_int;
6904    #[cfg(feature = "v1_4")]
6905    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6906    pub fn adw_toolbar_view_get_bottom_bar_style(self_: *mut AdwToolbarView) -> AdwToolbarStyle;
6907    #[cfg(feature = "v1_4")]
6908    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6909    pub fn adw_toolbar_view_get_content(self_: *mut AdwToolbarView) -> *mut gtk::GtkWidget;
6910    #[cfg(feature = "v1_4")]
6911    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6912    pub fn adw_toolbar_view_get_extend_content_to_bottom_edge(
6913        self_: *mut AdwToolbarView,
6914    ) -> gboolean;
6915    #[cfg(feature = "v1_4")]
6916    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6917    pub fn adw_toolbar_view_get_extend_content_to_top_edge(self_: *mut AdwToolbarView) -> gboolean;
6918    #[cfg(feature = "v1_4")]
6919    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6920    pub fn adw_toolbar_view_get_reveal_bottom_bars(self_: *mut AdwToolbarView) -> gboolean;
6921    #[cfg(feature = "v1_4")]
6922    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6923    pub fn adw_toolbar_view_get_reveal_top_bars(self_: *mut AdwToolbarView) -> gboolean;
6924    #[cfg(feature = "v1_4")]
6925    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6926    pub fn adw_toolbar_view_get_top_bar_height(self_: *mut AdwToolbarView) -> c_int;
6927    #[cfg(feature = "v1_4")]
6928    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6929    pub fn adw_toolbar_view_get_top_bar_style(self_: *mut AdwToolbarView) -> AdwToolbarStyle;
6930    #[cfg(feature = "v1_4")]
6931    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6932    pub fn adw_toolbar_view_remove(self_: *mut AdwToolbarView, widget: *mut gtk::GtkWidget);
6933    #[cfg(feature = "v1_4")]
6934    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6935    pub fn adw_toolbar_view_set_bottom_bar_style(
6936        self_: *mut AdwToolbarView,
6937        style: AdwToolbarStyle,
6938    );
6939    #[cfg(feature = "v1_4")]
6940    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6941    pub fn adw_toolbar_view_set_content(self_: *mut AdwToolbarView, content: *mut gtk::GtkWidget);
6942    #[cfg(feature = "v1_4")]
6943    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6944    pub fn adw_toolbar_view_set_extend_content_to_bottom_edge(
6945        self_: *mut AdwToolbarView,
6946        extend: gboolean,
6947    );
6948    #[cfg(feature = "v1_4")]
6949    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6950    pub fn adw_toolbar_view_set_extend_content_to_top_edge(
6951        self_: *mut AdwToolbarView,
6952        extend: gboolean,
6953    );
6954    #[cfg(feature = "v1_4")]
6955    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6956    pub fn adw_toolbar_view_set_reveal_bottom_bars(self_: *mut AdwToolbarView, reveal: gboolean);
6957    #[cfg(feature = "v1_4")]
6958    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6959    pub fn adw_toolbar_view_set_reveal_top_bars(self_: *mut AdwToolbarView, reveal: gboolean);
6960    #[cfg(feature = "v1_4")]
6961    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
6962    pub fn adw_toolbar_view_set_top_bar_style(self_: *mut AdwToolbarView, style: AdwToolbarStyle);
6963
6964    //=========================================================================
6965    // AdwViewStack
6966    //=========================================================================
6967    pub fn adw_view_stack_get_type() -> GType;
6968    pub fn adw_view_stack_new() -> *mut gtk::GtkWidget;
6969    pub fn adw_view_stack_add(
6970        self_: *mut AdwViewStack,
6971        child: *mut gtk::GtkWidget,
6972    ) -> *mut AdwViewStackPage;
6973    pub fn adw_view_stack_add_named(
6974        self_: *mut AdwViewStack,
6975        child: *mut gtk::GtkWidget,
6976        name: *const c_char,
6977    ) -> *mut AdwViewStackPage;
6978    pub fn adw_view_stack_add_titled(
6979        self_: *mut AdwViewStack,
6980        child: *mut gtk::GtkWidget,
6981        name: *const c_char,
6982        title: *const c_char,
6983    ) -> *mut AdwViewStackPage;
6984    #[cfg(feature = "v1_2")]
6985    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
6986    pub fn adw_view_stack_add_titled_with_icon(
6987        self_: *mut AdwViewStack,
6988        child: *mut gtk::GtkWidget,
6989        name: *const c_char,
6990        title: *const c_char,
6991        icon_name: *const c_char,
6992    ) -> *mut AdwViewStackPage;
6993    pub fn adw_view_stack_get_child_by_name(
6994        self_: *mut AdwViewStack,
6995        name: *const c_char,
6996    ) -> *mut gtk::GtkWidget;
6997    #[cfg(feature = "v1_7")]
6998    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
6999    pub fn adw_view_stack_get_enable_transitions(self_: *mut AdwViewStack) -> gboolean;
7000    pub fn adw_view_stack_get_hhomogeneous(self_: *mut AdwViewStack) -> gboolean;
7001    pub fn adw_view_stack_get_page(
7002        self_: *mut AdwViewStack,
7003        child: *mut gtk::GtkWidget,
7004    ) -> *mut AdwViewStackPage;
7005    pub fn adw_view_stack_get_pages(self_: *mut AdwViewStack) -> *mut gtk::GtkSelectionModel;
7006    #[cfg(feature = "v1_7")]
7007    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7008    pub fn adw_view_stack_get_transition_duration(self_: *mut AdwViewStack) -> c_uint;
7009    #[cfg(feature = "v1_7")]
7010    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7011    pub fn adw_view_stack_get_transition_running(self_: *mut AdwViewStack) -> gboolean;
7012    pub fn adw_view_stack_get_vhomogeneous(self_: *mut AdwViewStack) -> gboolean;
7013    pub fn adw_view_stack_get_visible_child(self_: *mut AdwViewStack) -> *mut gtk::GtkWidget;
7014    pub fn adw_view_stack_get_visible_child_name(self_: *mut AdwViewStack) -> *const c_char;
7015    pub fn adw_view_stack_remove(self_: *mut AdwViewStack, child: *mut gtk::GtkWidget);
7016    #[cfg(feature = "v1_7")]
7017    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7018    pub fn adw_view_stack_set_enable_transitions(
7019        self_: *mut AdwViewStack,
7020        enable_transitions: gboolean,
7021    );
7022    pub fn adw_view_stack_set_hhomogeneous(self_: *mut AdwViewStack, hhomogeneous: gboolean);
7023    #[cfg(feature = "v1_7")]
7024    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7025    pub fn adw_view_stack_set_transition_duration(self_: *mut AdwViewStack, duration: c_uint);
7026    pub fn adw_view_stack_set_vhomogeneous(self_: *mut AdwViewStack, vhomogeneous: gboolean);
7027    pub fn adw_view_stack_set_visible_child(self_: *mut AdwViewStack, child: *mut gtk::GtkWidget);
7028    pub fn adw_view_stack_set_visible_child_name(self_: *mut AdwViewStack, name: *const c_char);
7029
7030    //=========================================================================
7031    // AdwViewStackPage
7032    //=========================================================================
7033    pub fn adw_view_stack_page_get_type() -> GType;
7034    pub fn adw_view_stack_page_get_badge_number(self_: *mut AdwViewStackPage) -> c_uint;
7035    pub fn adw_view_stack_page_get_child(self_: *mut AdwViewStackPage) -> *mut gtk::GtkWidget;
7036    pub fn adw_view_stack_page_get_icon_name(self_: *mut AdwViewStackPage) -> *const c_char;
7037    pub fn adw_view_stack_page_get_name(self_: *mut AdwViewStackPage) -> *const c_char;
7038    pub fn adw_view_stack_page_get_needs_attention(self_: *mut AdwViewStackPage) -> gboolean;
7039    #[cfg(feature = "v1_9")]
7040    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
7041    pub fn adw_view_stack_page_get_section_title(self_: *mut AdwViewStackPage) -> *const c_char;
7042    #[cfg(feature = "v1_9")]
7043    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
7044    pub fn adw_view_stack_page_get_starts_section(self_: *mut AdwViewStackPage) -> gboolean;
7045    pub fn adw_view_stack_page_get_title(self_: *mut AdwViewStackPage) -> *const c_char;
7046    pub fn adw_view_stack_page_get_use_underline(self_: *mut AdwViewStackPage) -> gboolean;
7047    pub fn adw_view_stack_page_get_visible(self_: *mut AdwViewStackPage) -> gboolean;
7048    pub fn adw_view_stack_page_set_badge_number(self_: *mut AdwViewStackPage, badge_number: c_uint);
7049    pub fn adw_view_stack_page_set_icon_name(
7050        self_: *mut AdwViewStackPage,
7051        icon_name: *const c_char,
7052    );
7053    pub fn adw_view_stack_page_set_name(self_: *mut AdwViewStackPage, name: *const c_char);
7054    pub fn adw_view_stack_page_set_needs_attention(
7055        self_: *mut AdwViewStackPage,
7056        needs_attention: gboolean,
7057    );
7058    #[cfg(feature = "v1_9")]
7059    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
7060    pub fn adw_view_stack_page_set_section_title(
7061        self_: *mut AdwViewStackPage,
7062        section_title: *const c_char,
7063    );
7064    #[cfg(feature = "v1_9")]
7065    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
7066    pub fn adw_view_stack_page_set_starts_section(
7067        self_: *mut AdwViewStackPage,
7068        starts_section: gboolean,
7069    );
7070    pub fn adw_view_stack_page_set_title(self_: *mut AdwViewStackPage, title: *const c_char);
7071    pub fn adw_view_stack_page_set_use_underline(
7072        self_: *mut AdwViewStackPage,
7073        use_underline: gboolean,
7074    );
7075    pub fn adw_view_stack_page_set_visible(self_: *mut AdwViewStackPage, visible: gboolean);
7076
7077    //=========================================================================
7078    // AdwViewStackPages
7079    //=========================================================================
7080    #[cfg(feature = "v1_4")]
7081    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
7082    pub fn adw_view_stack_pages_get_type() -> GType;
7083    #[cfg(feature = "v1_4")]
7084    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
7085    pub fn adw_view_stack_pages_get_selected_page(
7086        self_: *mut AdwViewStackPages,
7087    ) -> *mut AdwViewStackPage;
7088    #[cfg(feature = "v1_4")]
7089    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
7090    pub fn adw_view_stack_pages_set_selected_page(
7091        self_: *mut AdwViewStackPages,
7092        page: *mut AdwViewStackPage,
7093    );
7094
7095    //=========================================================================
7096    // AdwViewSwitcher
7097    //=========================================================================
7098    pub fn adw_view_switcher_get_type() -> GType;
7099    pub fn adw_view_switcher_new() -> *mut gtk::GtkWidget;
7100    pub fn adw_view_switcher_get_policy(self_: *mut AdwViewSwitcher) -> AdwViewSwitcherPolicy;
7101    pub fn adw_view_switcher_get_stack(self_: *mut AdwViewSwitcher) -> *mut AdwViewStack;
7102    pub fn adw_view_switcher_set_policy(self_: *mut AdwViewSwitcher, policy: AdwViewSwitcherPolicy);
7103    pub fn adw_view_switcher_set_stack(self_: *mut AdwViewSwitcher, stack: *mut AdwViewStack);
7104
7105    //=========================================================================
7106    // AdwViewSwitcherBar
7107    //=========================================================================
7108    pub fn adw_view_switcher_bar_get_type() -> GType;
7109    pub fn adw_view_switcher_bar_new() -> *mut gtk::GtkWidget;
7110    pub fn adw_view_switcher_bar_get_reveal(self_: *mut AdwViewSwitcherBar) -> gboolean;
7111    pub fn adw_view_switcher_bar_get_stack(self_: *mut AdwViewSwitcherBar) -> *mut AdwViewStack;
7112    pub fn adw_view_switcher_bar_set_reveal(self_: *mut AdwViewSwitcherBar, reveal: gboolean);
7113    pub fn adw_view_switcher_bar_set_stack(
7114        self_: *mut AdwViewSwitcherBar,
7115        stack: *mut AdwViewStack,
7116    );
7117
7118    //=========================================================================
7119    // AdwViewSwitcherSidebar
7120    //=========================================================================
7121    #[cfg(feature = "v1_9")]
7122    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
7123    pub fn adw_view_switcher_sidebar_get_type() -> GType;
7124    #[cfg(feature = "v1_9")]
7125    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
7126    pub fn adw_view_switcher_sidebar_new() -> *mut gtk::GtkWidget;
7127    #[cfg(feature = "v1_9")]
7128    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
7129    pub fn adw_view_switcher_sidebar_get_filter(
7130        self_: *mut AdwViewSwitcherSidebar,
7131    ) -> *mut gtk::GtkFilter;
7132    #[cfg(feature = "v1_9")]
7133    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
7134    pub fn adw_view_switcher_sidebar_get_mode(self_: *mut AdwViewSwitcherSidebar)
7135    -> AdwSidebarMode;
7136    #[cfg(feature = "v1_9")]
7137    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
7138    pub fn adw_view_switcher_sidebar_get_placeholder(
7139        self_: *mut AdwViewSwitcherSidebar,
7140    ) -> *mut gtk::GtkWidget;
7141    #[cfg(feature = "v1_9")]
7142    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
7143    pub fn adw_view_switcher_sidebar_get_stack(
7144        self_: *mut AdwViewSwitcherSidebar,
7145    ) -> *mut AdwViewStack;
7146    #[cfg(feature = "v1_9")]
7147    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
7148    pub fn adw_view_switcher_sidebar_set_filter(
7149        self_: *mut AdwViewSwitcherSidebar,
7150        filter: *mut gtk::GtkFilter,
7151    );
7152    #[cfg(feature = "v1_9")]
7153    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
7154    pub fn adw_view_switcher_sidebar_set_mode(
7155        self_: *mut AdwViewSwitcherSidebar,
7156        mode: AdwSidebarMode,
7157    );
7158    #[cfg(feature = "v1_9")]
7159    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
7160    pub fn adw_view_switcher_sidebar_set_placeholder(
7161        self_: *mut AdwViewSwitcherSidebar,
7162        placeholder: *mut gtk::GtkWidget,
7163    );
7164    #[cfg(feature = "v1_9")]
7165    #[cfg_attr(docsrs, doc(cfg(feature = "v1_9")))]
7166    pub fn adw_view_switcher_sidebar_set_stack(
7167        self_: *mut AdwViewSwitcherSidebar,
7168        stack: *mut AdwViewStack,
7169    );
7170
7171    //=========================================================================
7172    // AdwViewSwitcherTitle
7173    //=========================================================================
7174    pub fn adw_view_switcher_title_get_type() -> GType;
7175    pub fn adw_view_switcher_title_new() -> *mut gtk::GtkWidget;
7176    pub fn adw_view_switcher_title_get_stack(self_: *mut AdwViewSwitcherTitle)
7177    -> *mut AdwViewStack;
7178    pub fn adw_view_switcher_title_get_subtitle(self_: *mut AdwViewSwitcherTitle) -> *const c_char;
7179    pub fn adw_view_switcher_title_get_title(self_: *mut AdwViewSwitcherTitle) -> *const c_char;
7180    pub fn adw_view_switcher_title_get_title_visible(self_: *mut AdwViewSwitcherTitle) -> gboolean;
7181    pub fn adw_view_switcher_title_get_view_switcher_enabled(
7182        self_: *mut AdwViewSwitcherTitle,
7183    ) -> gboolean;
7184    pub fn adw_view_switcher_title_set_stack(
7185        self_: *mut AdwViewSwitcherTitle,
7186        stack: *mut AdwViewStack,
7187    );
7188    pub fn adw_view_switcher_title_set_subtitle(
7189        self_: *mut AdwViewSwitcherTitle,
7190        subtitle: *const c_char,
7191    );
7192    pub fn adw_view_switcher_title_set_title(
7193        self_: *mut AdwViewSwitcherTitle,
7194        title: *const c_char,
7195    );
7196    pub fn adw_view_switcher_title_set_view_switcher_enabled(
7197        self_: *mut AdwViewSwitcherTitle,
7198        enabled: gboolean,
7199    );
7200
7201    //=========================================================================
7202    // AdwWindow
7203    //=========================================================================
7204    pub fn adw_window_get_type() -> GType;
7205    pub fn adw_window_new() -> *mut gtk::GtkWidget;
7206    #[cfg(feature = "v1_4")]
7207    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
7208    pub fn adw_window_add_breakpoint(self_: *mut AdwWindow, breakpoint: *mut AdwBreakpoint);
7209    #[cfg(feature = "v1_7")]
7210    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7211    pub fn adw_window_get_adaptive_preview(self_: *mut AdwWindow) -> gboolean;
7212    pub fn adw_window_get_content(self_: *mut AdwWindow) -> *mut gtk::GtkWidget;
7213    #[cfg(feature = "v1_4")]
7214    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
7215    pub fn adw_window_get_current_breakpoint(self_: *mut AdwWindow) -> *mut AdwBreakpoint;
7216    #[cfg(feature = "v1_5")]
7217    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
7218    pub fn adw_window_get_dialogs(self_: *mut AdwWindow) -> *mut gio::GListModel;
7219    #[cfg(feature = "v1_5")]
7220    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
7221    pub fn adw_window_get_visible_dialog(self_: *mut AdwWindow) -> *mut AdwDialog;
7222    #[cfg(feature = "v1_7")]
7223    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7224    pub fn adw_window_set_adaptive_preview(self_: *mut AdwWindow, adaptive_preview: gboolean);
7225    pub fn adw_window_set_content(self_: *mut AdwWindow, content: *mut gtk::GtkWidget);
7226
7227    //=========================================================================
7228    // AdwWindowTitle
7229    //=========================================================================
7230    pub fn adw_window_title_get_type() -> GType;
7231    pub fn adw_window_title_new(
7232        title: *const c_char,
7233        subtitle: *const c_char,
7234    ) -> *mut gtk::GtkWidget;
7235    pub fn adw_window_title_get_subtitle(self_: *mut AdwWindowTitle) -> *const c_char;
7236    pub fn adw_window_title_get_title(self_: *mut AdwWindowTitle) -> *const c_char;
7237    pub fn adw_window_title_set_subtitle(self_: *mut AdwWindowTitle, subtitle: *const c_char);
7238    pub fn adw_window_title_set_title(self_: *mut AdwWindowTitle, title: *const c_char);
7239
7240    //=========================================================================
7241    // AdwWrapBox
7242    //=========================================================================
7243    #[cfg(feature = "v1_7")]
7244    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7245    pub fn adw_wrap_box_get_type() -> GType;
7246    #[cfg(feature = "v1_7")]
7247    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7248    pub fn adw_wrap_box_new() -> *mut gtk::GtkWidget;
7249    #[cfg(feature = "v1_7")]
7250    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7251    pub fn adw_wrap_box_append(self_: *mut AdwWrapBox, child: *mut gtk::GtkWidget);
7252    #[cfg(feature = "v1_7")]
7253    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7254    pub fn adw_wrap_box_get_align(self_: *mut AdwWrapBox) -> c_float;
7255    #[cfg(feature = "v1_7")]
7256    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7257    pub fn adw_wrap_box_get_child_spacing(self_: *mut AdwWrapBox) -> c_int;
7258    #[cfg(feature = "v1_7")]
7259    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7260    pub fn adw_wrap_box_get_child_spacing_unit(self_: *mut AdwWrapBox) -> AdwLengthUnit;
7261    #[cfg(feature = "v1_7")]
7262    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7263    pub fn adw_wrap_box_get_justify(self_: *mut AdwWrapBox) -> AdwJustifyMode;
7264    #[cfg(feature = "v1_7")]
7265    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7266    pub fn adw_wrap_box_get_justify_last_line(self_: *mut AdwWrapBox) -> gboolean;
7267    #[cfg(feature = "v1_7")]
7268    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7269    pub fn adw_wrap_box_get_line_homogeneous(self_: *mut AdwWrapBox) -> gboolean;
7270    #[cfg(feature = "v1_7")]
7271    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7272    pub fn adw_wrap_box_get_line_spacing(self_: *mut AdwWrapBox) -> c_int;
7273    #[cfg(feature = "v1_7")]
7274    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7275    pub fn adw_wrap_box_get_line_spacing_unit(self_: *mut AdwWrapBox) -> AdwLengthUnit;
7276    #[cfg(feature = "v1_7")]
7277    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7278    pub fn adw_wrap_box_get_natural_line_length(self_: *mut AdwWrapBox) -> c_int;
7279    #[cfg(feature = "v1_7")]
7280    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7281    pub fn adw_wrap_box_get_natural_line_length_unit(self_: *mut AdwWrapBox) -> AdwLengthUnit;
7282    #[cfg(feature = "v1_7")]
7283    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7284    pub fn adw_wrap_box_get_pack_direction(self_: *mut AdwWrapBox) -> AdwPackDirection;
7285    #[cfg(feature = "v1_7")]
7286    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7287    pub fn adw_wrap_box_get_wrap_policy(self_: *mut AdwWrapBox) -> AdwWrapPolicy;
7288    #[cfg(feature = "v1_7")]
7289    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7290    pub fn adw_wrap_box_get_wrap_reverse(self_: *mut AdwWrapBox) -> gboolean;
7291    #[cfg(feature = "v1_7")]
7292    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7293    pub fn adw_wrap_box_insert_child_after(
7294        self_: *mut AdwWrapBox,
7295        child: *mut gtk::GtkWidget,
7296        sibling: *mut gtk::GtkWidget,
7297    );
7298    #[cfg(feature = "v1_7")]
7299    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7300    pub fn adw_wrap_box_prepend(self_: *mut AdwWrapBox, child: *mut gtk::GtkWidget);
7301    #[cfg(feature = "v1_7")]
7302    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7303    pub fn adw_wrap_box_remove(self_: *mut AdwWrapBox, child: *mut gtk::GtkWidget);
7304    #[cfg(feature = "v1_8")]
7305    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
7306    pub fn adw_wrap_box_remove_all(self_: *mut AdwWrapBox);
7307    #[cfg(feature = "v1_7")]
7308    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7309    pub fn adw_wrap_box_reorder_child_after(
7310        self_: *mut AdwWrapBox,
7311        child: *mut gtk::GtkWidget,
7312        sibling: *mut gtk::GtkWidget,
7313    );
7314    #[cfg(feature = "v1_7")]
7315    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7316    pub fn adw_wrap_box_set_align(self_: *mut AdwWrapBox, align: c_float);
7317    #[cfg(feature = "v1_7")]
7318    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7319    pub fn adw_wrap_box_set_child_spacing(self_: *mut AdwWrapBox, child_spacing: c_int);
7320    #[cfg(feature = "v1_7")]
7321    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7322    pub fn adw_wrap_box_set_child_spacing_unit(self_: *mut AdwWrapBox, unit: AdwLengthUnit);
7323    #[cfg(feature = "v1_7")]
7324    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7325    pub fn adw_wrap_box_set_justify(self_: *mut AdwWrapBox, justify: AdwJustifyMode);
7326    #[cfg(feature = "v1_7")]
7327    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7328    pub fn adw_wrap_box_set_justify_last_line(self_: *mut AdwWrapBox, justify_last_line: gboolean);
7329    #[cfg(feature = "v1_7")]
7330    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7331    pub fn adw_wrap_box_set_line_homogeneous(self_: *mut AdwWrapBox, homogeneous: gboolean);
7332    #[cfg(feature = "v1_7")]
7333    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7334    pub fn adw_wrap_box_set_line_spacing(self_: *mut AdwWrapBox, line_spacing: c_int);
7335    #[cfg(feature = "v1_7")]
7336    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7337    pub fn adw_wrap_box_set_line_spacing_unit(self_: *mut AdwWrapBox, unit: AdwLengthUnit);
7338    #[cfg(feature = "v1_7")]
7339    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7340    pub fn adw_wrap_box_set_natural_line_length(self_: *mut AdwWrapBox, natural_line_length: c_int);
7341    #[cfg(feature = "v1_7")]
7342    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7343    pub fn adw_wrap_box_set_natural_line_length_unit(self_: *mut AdwWrapBox, unit: AdwLengthUnit);
7344    #[cfg(feature = "v1_7")]
7345    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7346    pub fn adw_wrap_box_set_pack_direction(
7347        self_: *mut AdwWrapBox,
7348        pack_direction: AdwPackDirection,
7349    );
7350    #[cfg(feature = "v1_7")]
7351    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7352    pub fn adw_wrap_box_set_wrap_policy(self_: *mut AdwWrapBox, wrap_policy: AdwWrapPolicy);
7353    #[cfg(feature = "v1_7")]
7354    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7355    pub fn adw_wrap_box_set_wrap_reverse(self_: *mut AdwWrapBox, wrap_reverse: gboolean);
7356
7357    //=========================================================================
7358    // AdwWrapLayout
7359    //=========================================================================
7360    #[cfg(feature = "v1_7")]
7361    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7362    pub fn adw_wrap_layout_get_type() -> GType;
7363    #[cfg(feature = "v1_7")]
7364    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7365    pub fn adw_wrap_layout_new() -> *mut gtk::GtkLayoutManager;
7366    #[cfg(feature = "v1_7")]
7367    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7368    pub fn adw_wrap_layout_get_align(self_: *mut AdwWrapLayout) -> c_float;
7369    #[cfg(feature = "v1_7")]
7370    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7371    pub fn adw_wrap_layout_get_child_spacing(self_: *mut AdwWrapLayout) -> c_int;
7372    #[cfg(feature = "v1_7")]
7373    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7374    pub fn adw_wrap_layout_get_child_spacing_unit(self_: *mut AdwWrapLayout) -> AdwLengthUnit;
7375    #[cfg(feature = "v1_7")]
7376    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7377    pub fn adw_wrap_layout_get_justify(self_: *mut AdwWrapLayout) -> AdwJustifyMode;
7378    #[cfg(feature = "v1_7")]
7379    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7380    pub fn adw_wrap_layout_get_justify_last_line(self_: *mut AdwWrapLayout) -> gboolean;
7381    #[cfg(feature = "v1_7")]
7382    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7383    pub fn adw_wrap_layout_get_line_homogeneous(self_: *mut AdwWrapLayout) -> gboolean;
7384    #[cfg(feature = "v1_7")]
7385    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7386    pub fn adw_wrap_layout_get_line_spacing(self_: *mut AdwWrapLayout) -> c_int;
7387    #[cfg(feature = "v1_7")]
7388    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7389    pub fn adw_wrap_layout_get_line_spacing_unit(self_: *mut AdwWrapLayout) -> AdwLengthUnit;
7390    #[cfg(feature = "v1_7")]
7391    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7392    pub fn adw_wrap_layout_get_natural_line_length(self_: *mut AdwWrapLayout) -> c_int;
7393    #[cfg(feature = "v1_7")]
7394    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7395    pub fn adw_wrap_layout_get_natural_line_length_unit(self_: *mut AdwWrapLayout)
7396    -> AdwLengthUnit;
7397    #[cfg(feature = "v1_7")]
7398    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7399    pub fn adw_wrap_layout_get_pack_direction(self_: *mut AdwWrapLayout) -> AdwPackDirection;
7400    #[cfg(feature = "v1_7")]
7401    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7402    pub fn adw_wrap_layout_get_wrap_policy(self_: *mut AdwWrapLayout) -> AdwWrapPolicy;
7403    #[cfg(feature = "v1_7")]
7404    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7405    pub fn adw_wrap_layout_get_wrap_reverse(self_: *mut AdwWrapLayout) -> gboolean;
7406    #[cfg(feature = "v1_7")]
7407    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7408    pub fn adw_wrap_layout_set_align(self_: *mut AdwWrapLayout, align: c_float);
7409    #[cfg(feature = "v1_7")]
7410    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7411    pub fn adw_wrap_layout_set_child_spacing(self_: *mut AdwWrapLayout, child_spacing: c_int);
7412    #[cfg(feature = "v1_7")]
7413    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7414    pub fn adw_wrap_layout_set_child_spacing_unit(self_: *mut AdwWrapLayout, unit: AdwLengthUnit);
7415    #[cfg(feature = "v1_7")]
7416    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7417    pub fn adw_wrap_layout_set_justify(self_: *mut AdwWrapLayout, justify: AdwJustifyMode);
7418    #[cfg(feature = "v1_7")]
7419    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7420    pub fn adw_wrap_layout_set_justify_last_line(
7421        self_: *mut AdwWrapLayout,
7422        justify_last_line: gboolean,
7423    );
7424    #[cfg(feature = "v1_7")]
7425    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7426    pub fn adw_wrap_layout_set_line_homogeneous(self_: *mut AdwWrapLayout, homogeneous: gboolean);
7427    #[cfg(feature = "v1_7")]
7428    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7429    pub fn adw_wrap_layout_set_line_spacing(self_: *mut AdwWrapLayout, line_spacing: c_int);
7430    #[cfg(feature = "v1_7")]
7431    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7432    pub fn adw_wrap_layout_set_line_spacing_unit(self_: *mut AdwWrapLayout, unit: AdwLengthUnit);
7433    #[cfg(feature = "v1_7")]
7434    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7435    pub fn adw_wrap_layout_set_natural_line_length(
7436        self_: *mut AdwWrapLayout,
7437        natural_line_length: c_int,
7438    );
7439    #[cfg(feature = "v1_7")]
7440    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7441    pub fn adw_wrap_layout_set_natural_line_length_unit(
7442        self_: *mut AdwWrapLayout,
7443        unit: AdwLengthUnit,
7444    );
7445    #[cfg(feature = "v1_7")]
7446    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7447    pub fn adw_wrap_layout_set_pack_direction(
7448        self_: *mut AdwWrapLayout,
7449        pack_direction: AdwPackDirection,
7450    );
7451    #[cfg(feature = "v1_7")]
7452    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7453    pub fn adw_wrap_layout_set_wrap_policy(self_: *mut AdwWrapLayout, wrap_policy: AdwWrapPolicy);
7454    #[cfg(feature = "v1_7")]
7455    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
7456    pub fn adw_wrap_layout_set_wrap_reverse(self_: *mut AdwWrapLayout, wrap_reverse: gboolean);
7457
7458    //=========================================================================
7459    // AdwSwipeable
7460    //=========================================================================
7461    pub fn adw_swipeable_get_type() -> GType;
7462    pub fn adw_swipeable_get_cancel_progress(self_: *mut AdwSwipeable) -> c_double;
7463    pub fn adw_swipeable_get_distance(self_: *mut AdwSwipeable) -> c_double;
7464    pub fn adw_swipeable_get_progress(self_: *mut AdwSwipeable) -> c_double;
7465    pub fn adw_swipeable_get_snap_points(
7466        self_: *mut AdwSwipeable,
7467        n_snap_points: *mut c_int,
7468    ) -> *mut c_double;
7469    pub fn adw_swipeable_get_swipe_area(
7470        self_: *mut AdwSwipeable,
7471        navigation_direction: AdwNavigationDirection,
7472        is_drag: gboolean,
7473        rect: *mut gdk::GdkRectangle,
7474    );
7475
7476    //=========================================================================
7477    // Other functions
7478    //=========================================================================
7479    pub fn adw_get_enable_animations(widget: *mut gtk::GtkWidget) -> gboolean;
7480    pub fn adw_get_major_version() -> c_uint;
7481    pub fn adw_get_micro_version() -> c_uint;
7482    pub fn adw_get_minor_version() -> c_uint;
7483    pub fn adw_init();
7484    pub fn adw_is_initialized() -> gboolean;
7485    pub fn adw_lerp(a: c_double, b: c_double, t: c_double) -> c_double;
7486    #[cfg(feature = "v1_6")]
7487    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
7488    pub fn adw_rgba_to_standalone(
7489        rgba: *const gdk::GdkRGBA,
7490        dark: gboolean,
7491        standalone_rgba: *mut gdk::GdkRGBA,
7492    );
7493    #[cfg(feature = "v1_5")]
7494    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
7495    pub fn adw_show_about_dialog(
7496        parent: *mut gtk::GtkWidget,
7497        first_property_name: *const c_char,
7498        ...
7499    );
7500    #[cfg(feature = "v1_5")]
7501    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
7502    pub fn adw_show_about_dialog_from_appdata(
7503        parent: *mut gtk::GtkWidget,
7504        resource_path: *const c_char,
7505        release_notes_version: *const c_char,
7506        first_property_name: *const c_char,
7507        ...
7508    );
7509    #[cfg(feature = "v1_2")]
7510    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
7511    pub fn adw_show_about_window(
7512        parent: *mut gtk::GtkWindow,
7513        first_property_name: *const c_char,
7514        ...
7515    );
7516    #[cfg(feature = "v1_4")]
7517    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
7518    pub fn adw_show_about_window_from_appdata(
7519        parent: *mut gtk::GtkWindow,
7520        resource_path: *const c_char,
7521        release_notes_version: *const c_char,
7522        first_property_name: *const c_char,
7523        ...
7524    );
7525
7526}
libadwaita_sys/lib.rs

libadwaita_sys/
lib.rs
