#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(clippy::approx_constant, clippy::type_complexity, clippy::unreadable_literal, clippy::upper_case_acronyms)]
#![cfg_attr(docsrs, feature(doc_cfg))]
use glib_sys as glib;
use gobject_sys as gobject;
use gdk_sys as gdk;
use gio_sys as gio;
use gtk_sys as gtk;
use pango_sys as pango;
#[allow(unused_imports)]
use libc::{c_int, c_char, c_uchar, c_float, c_uint, c_double,
c_short, c_ushort, c_long, c_ulong,
c_void, size_t, ssize_t, time_t, off_t, intptr_t, uintptr_t, FILE};
#[cfg(unix)]
#[allow(unused_imports)]
use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};
pub type HeAboutWindowLicenses = c_int;
pub const HE_ABOUT_WINDOW_LICENSES_GPLV3: HeAboutWindowLicenses = 0;
pub const HE_ABOUT_WINDOW_LICENSES_MIT: HeAboutWindowLicenses = 1;
pub const HE_ABOUT_WINDOW_LICENSES_MPLV2: HeAboutWindowLicenses = 2;
pub const HE_ABOUT_WINDOW_LICENSES_UNLICENSE: HeAboutWindowLicenses = 3;
pub const HE_ABOUT_WINDOW_LICENSES_APACHEV2: HeAboutWindowLicenses = 4;
pub const HE_ABOUT_WINDOW_LICENSES_WTFPL: HeAboutWindowLicenses = 5;
pub const HE_ABOUT_WINDOW_LICENSES_PROPRIETARY: HeAboutWindowLicenses = 6;
pub type HeBannerStyle = c_int;
pub const HE_BANNER_STYLE_INFO: HeBannerStyle = 0;
pub const HE_BANNER_STYLE_WARNING: HeBannerStyle = 1;
pub const HE_BANNER_STYLE_ERROR: HeBannerStyle = 2;
pub type HeBottomBarPosition = c_int;
pub const HE_BOTTOM_BAR_POSITION_LEFT: HeBottomBarPosition = 0;
pub const HE_BOTTOM_BAR_POSITION_RIGHT: HeBottomBarPosition = 1;
pub type HeColors = c_int;
pub const HE_COLORS_NONE: HeColors = 0;
pub const HE_COLORS_RED: HeColors = 1;
pub const HE_COLORS_ORANGE: HeColors = 2;
pub const HE_COLORS_YELLOW: HeColors = 3;
pub const HE_COLORS_GREEN: HeColors = 4;
pub const HE_COLORS_BLUE: HeColors = 5;
pub const HE_COLORS_INDIGO: HeColors = 6;
pub const HE_COLORS_PURPLE: HeColors = 7;
pub const HE_COLORS_PINK: HeColors = 8;
pub const HE_COLORS_MINT: HeColors = 9;
pub const HE_COLORS_BROWN: HeColors = 10;
pub const HE_COLORS_LIGHT: HeColors = 11;
pub const HE_COLORS_DARK: HeColors = 12;
pub type HeContentBlockImageClusterImagePosition = c_int;
pub const HE_CONTENT_BLOCK_IMAGE_CLUSTER_IMAGE_POSITION_TOP_LEFT: HeContentBlockImageClusterImagePosition = 0;
pub const HE_CONTENT_BLOCK_IMAGE_CLUSTER_IMAGE_POSITION_BOTTOM_LEFT: HeContentBlockImageClusterImagePosition = 1;
pub const HE_CONTENT_BLOCK_IMAGE_CLUSTER_IMAGE_POSITION_TOP_RIGHT: HeContentBlockImageClusterImagePosition = 2;
pub const HE_CONTENT_BLOCK_IMAGE_CLUSTER_IMAGE_POSITION_BOTTOM_RIGHT: HeContentBlockImageClusterImagePosition = 3;
pub type HeDesktopColorScheme = c_int;
pub const HE_DESKTOP_COLOR_SCHEME_NO_PREFERENCE: HeDesktopColorScheme = 0;
pub const HE_DESKTOP_COLOR_SCHEME_DARK: HeDesktopColorScheme = 1;
pub const HE_DESKTOP_COLOR_SCHEME_LIGHT: HeDesktopColorScheme = 2;
pub type HeDesktopContrastScheme = c_int;
pub const HE_DESKTOP_CONTRAST_SCHEME_DEFAULT: HeDesktopContrastScheme = 0;
pub const HE_DESKTOP_CONTRAST_SCHEME_HIGH: HeDesktopContrastScheme = 1;
pub const HE_DESKTOP_CONTRAST_SCHEME_LOW: HeDesktopContrastScheme = 2;
pub type HeDesktopEnsorScheme = c_int;
pub const HE_DESKTOP_ENSOR_SCHEME_DEFAULT: HeDesktopEnsorScheme = 0;
pub const HE_DESKTOP_ENSOR_SCHEME_VIBRANT: HeDesktopEnsorScheme = 1;
pub const HE_DESKTOP_ENSOR_SCHEME_MUTED: HeDesktopEnsorScheme = 2;
pub const HE_DESKTOP_ENSOR_SCHEME_MONOCHROMATIC: HeDesktopEnsorScheme = 3;
pub const HE_DESKTOP_ENSOR_SCHEME_SALAD: HeDesktopEnsorScheme = 4;
pub type HeModifierBadgeAlignment = c_int;
pub const HE_MODIFIER_BADGE_ALIGNMENT_LEFT: HeModifierBadgeAlignment = 0;
pub const HE_MODIFIER_BADGE_ALIGNMENT_CENTER: HeModifierBadgeAlignment = 1;
pub const HE_MODIFIER_BADGE_ALIGNMENT_RIGHT: HeModifierBadgeAlignment = 2;
pub type HeOverlayButtonAlignment = c_int;
pub const HE_OVERLAY_BUTTON_ALIGNMENT_LEFT: HeOverlayButtonAlignment = 0;
pub const HE_OVERLAY_BUTTON_ALIGNMENT_CENTER: HeOverlayButtonAlignment = 1;
pub const HE_OVERLAY_BUTTON_ALIGNMENT_RIGHT: HeOverlayButtonAlignment = 2;
pub type HeOverlayButtonSize = c_int;
pub const HE_OVERLAY_BUTTON_SIZE_SMALL: HeOverlayButtonSize = 0;
pub const HE_OVERLAY_BUTTON_SIZE_MEDIUM: HeOverlayButtonSize = 1;
pub const HE_OVERLAY_BUTTON_SIZE_LARGE: HeOverlayButtonSize = 2;
pub type HeOverlayButtonTypeButton = c_int;
pub const HE_OVERLAY_BUTTON_TYPE_BUTTON_SURFACE: HeOverlayButtonTypeButton = 0;
pub const HE_OVERLAY_BUTTON_TYPE_BUTTON_PRIMARY: HeOverlayButtonTypeButton = 1;
pub const HE_OVERLAY_BUTTON_TYPE_BUTTON_SECONDARY: HeOverlayButtonTypeButton = 2;
pub const HE_OVERLAY_BUTTON_TYPE_BUTTON_TERTIARY: HeOverlayButtonTypeButton = 3;
pub type HeTabSwitcherTabBarBehavior = c_int;
pub const HE_TAB_SWITCHER_TAB_BAR_BEHAVIOR_ALWAYS: HeTabSwitcherTabBarBehavior = 0;
pub const HE_TAB_SWITCHER_TAB_BAR_BEHAVIOR_SINGLE: HeTabSwitcherTabBarBehavior = 1;
pub const HE_TAB_SWITCHER_TAB_BAR_BEHAVIOR_NEVER: HeTabSwitcherTabBarBehavior = 2;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeAboutWindowClass {
pub parent_class: HeWindowClass,
}
impl ::std::fmt::Debug for HeAboutWindowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeAboutWindowClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeAboutWindowPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeAboutWindowPrivate = _HeAboutWindowPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeAppBarClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeAppBarClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeAppBarClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeAppBarPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeAppBarPrivate = _HeAppBarPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeApplicationClass {
pub parent_class: gtk::GtkApplicationClass,
}
impl ::std::fmt::Debug for HeApplicationClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeApplicationClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeApplicationPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeApplicationPrivate = _HeApplicationPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeApplicationWindowClass {
pub parent_class: gtk::GtkApplicationWindowClass,
}
impl ::std::fmt::Debug for HeApplicationWindowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeApplicationWindowClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeApplicationWindowPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeApplicationWindowPrivate = _HeApplicationWindowPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeAvatarClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeAvatarClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeAvatarClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeAvatarPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeAvatarPrivate = _HeAvatarPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeBadgeClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeBadgeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeBadgeClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeBadgePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeBadgePrivate = _HeBadgePrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeBannerClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeBannerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeBannerClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeBannerPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeBannerPrivate = _HeBannerPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeBinClass {
pub parent_class: gtk::GtkWidgetClass,
pub add_child: Option<unsafe extern "C" fn(*mut HeBin, *mut gtk::GtkBuilder, *mut gobject::GObject, *const c_char)>,
}
impl ::std::fmt::Debug for HeBinClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeBinClass @ {self:p}"))
.field("add_child", &self.add_child)
.finish()
}
}
#[repr(C)]
pub struct _HeBinPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeBinPrivate = _HeBinPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeBottomBarClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeBottomBarClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeBottomBarClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeBottomBarPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeBottomBarPrivate = _HeBottomBarPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeButtonClass {
pub parent_class: gtk::GtkButtonClass,
}
impl ::std::fmt::Debug for HeButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeButtonClass @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeButtonContentClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for HeButtonContentClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeButtonContentClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeButtonContentPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeButtonContentPrivate = _HeButtonContentPrivate;
#[repr(C)]
pub struct _HeButtonPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeButtonPrivate = _HeButtonPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeChipClass {
pub parent_class: gtk::GtkToggleButtonClass,
}
impl ::std::fmt::Debug for HeChipClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeChipClass @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeChipGroupClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeChipGroupClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeChipGroupClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeChipGroupPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeChipGroupPrivate = _HeChipGroupPrivate;
#[repr(C)]
pub struct _HeChipPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeChipPrivate = _HeChipPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeColorCAM16Color {
pub j: c_double,
pub a: c_double,
pub b: c_double,
pub c: c_double,
pub h: c_double,
pub m: c_double,
pub s: c_double,
}
impl ::std::fmt::Debug for HeColorCAM16Color {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeColorCAM16Color @ {self:p}"))
.field("j", &self.j)
.field("a", &self.a)
.field("b", &self.b)
.field("c", &self.c)
.field("h", &self.h)
.field("m", &self.m)
.field("s", &self.s)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeColorHCTColor {
pub h: c_double,
pub c: c_double,
pub t: c_double,
pub a: c_int,
}
impl ::std::fmt::Debug for HeColorHCTColor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeColorHCTColor @ {self:p}"))
.field("h", &self.h)
.field("c", &self.c)
.field("t", &self.t)
.field("a", &self.a)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeColorLABColor {
pub l: c_double,
pub a: c_double,
pub b: c_double,
}
impl ::std::fmt::Debug for HeColorLABColor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeColorLABColor @ {self:p}"))
.field("l", &self.l)
.field("a", &self.a)
.field("b", &self.b)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeColorLCHColor {
pub l: c_double,
pub c: c_double,
pub h: c_double,
}
impl ::std::fmt::Debug for HeColorLCHColor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeColorLCHColor @ {self:p}"))
.field("l", &self.l)
.field("c", &self.c)
.field("h", &self.h)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeColorRGBColor {
pub r: c_double,
pub g: c_double,
pub b: c_double,
}
impl ::std::fmt::Debug for HeColorRGBColor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeColorRGBColor @ {self:p}"))
.field("r", &self.r)
.field("g", &self.g)
.field("b", &self.b)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeColorXYZColor {
pub x: c_double,
pub y: c_double,
pub z: c_double,
}
impl ::std::fmt::Debug for HeColorXYZColor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeColorXYZColor @ {self:p}"))
.field("x", &self.x)
.field("y", &self.y)
.field("z", &self.z)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContentBlockClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeContentBlockClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeContentBlockClass @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContentBlockImageClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeContentBlockImageClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeContentBlockImageClass @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContentBlockImageClusterClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeContentBlockImageClusterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeContentBlockImageClusterClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeContentBlockImageClusterPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeContentBlockImageClusterPrivate = _HeContentBlockImageClusterPrivate;
#[repr(C)]
pub struct _HeContentBlockImagePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeContentBlockImagePrivate = _HeContentBlockImagePrivate;
#[repr(C)]
pub struct _HeContentBlockPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeContentBlockPrivate = _HeContentBlockPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContentListClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeContentListClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeContentListClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeContentListPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeContentListPrivate = _HeContentListPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContentSchemeClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for HeContentSchemeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeContentSchemeClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeContentSchemePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeContentSchemePrivate = _HeContentSchemePrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDatePickerClass {
pub parent_class: gtk::GtkEntryClass,
}
impl ::std::fmt::Debug for HeDatePickerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeDatePickerClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeDatePickerPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeDatePickerPrivate = _HeDatePickerPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDefaultSchemeClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for HeDefaultSchemeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeDefaultSchemeClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeDefaultSchemePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeDefaultSchemePrivate = _HeDefaultSchemePrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDesktopClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for HeDesktopClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeDesktopClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeDesktopPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeDesktopPrivate = _HeDesktopPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDialogClass {
pub parent_class: HeWindowClass,
}
impl ::std::fmt::Debug for HeDialogClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeDialogClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeDialogPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeDialogPrivate = _HeDialogPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDisclosureButtonClass {
pub parent_class: HeButtonClass,
}
impl ::std::fmt::Debug for HeDisclosureButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeDisclosureButtonClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeDisclosureButtonPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeDisclosureButtonPrivate = _HeDisclosureButtonPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDividerClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeDividerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeDividerClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeDividerPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeDividerPrivate = _HeDividerPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeEmptyPageClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeEmptyPageClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeEmptyPageClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeEmptyPagePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeEmptyPagePrivate = _HeEmptyPagePrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeFillButtonClass {
pub parent_class: HeButtonClass,
}
impl ::std::fmt::Debug for HeFillButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeFillButtonClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeFillButtonPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeFillButtonPrivate = _HeFillButtonPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeIconicButtonClass {
pub parent_class: HeButtonClass,
}
impl ::std::fmt::Debug for HeIconicButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeIconicButtonClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeIconicButtonPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeIconicButtonPrivate = _HeIconicButtonPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeMiniContentBlockClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeMiniContentBlockClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeMiniContentBlockClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeMiniContentBlockPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeMiniContentBlockPrivate = _HeMiniContentBlockPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeModifierBadgeClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeModifierBadgeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeModifierBadgeClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeModifierBadgePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeModifierBadgePrivate = _HeModifierBadgePrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeMonochromaticSchemeClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for HeMonochromaticSchemeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeMonochromaticSchemeClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeMonochromaticSchemePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeMonochromaticSchemePrivate = _HeMonochromaticSchemePrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeMutedSchemeClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for HeMutedSchemeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeMutedSchemeClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeMutedSchemePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeMutedSchemePrivate = _HeMutedSchemePrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeNavigationRailClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeNavigationRailClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeNavigationRailClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeNavigationRailPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeNavigationRailPrivate = _HeNavigationRailPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeNavigationSectionClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeNavigationSectionClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeNavigationSectionClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeNavigationSectionPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeNavigationSectionPrivate = _HeNavigationSectionPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeOutlineButtonClass {
pub parent_class: HeButtonClass,
}
impl ::std::fmt::Debug for HeOutlineButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeOutlineButtonClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeOutlineButtonPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeOutlineButtonPrivate = _HeOutlineButtonPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeOverlayButtonClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeOverlayButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeOverlayButtonClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeOverlayButtonPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeOverlayButtonPrivate = _HeOverlayButtonPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HePillButtonClass {
pub parent_class: HeButtonClass,
}
impl ::std::fmt::Debug for HePillButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HePillButtonClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HePillButtonPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HePillButtonPrivate = _HePillButtonPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeProgressBarClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeProgressBarClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeProgressBarClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeProgressBarPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeProgressBarPrivate = _HeProgressBarPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerCelebiClass {
pub parent_class: gobject::GTypeClass,
}
impl ::std::fmt::Debug for HeQuantizerCelebiClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeQuantizerCelebiClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeQuantizerCelebiPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeQuantizerCelebiPrivate = _HeQuantizerCelebiPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerClass {
pub parent_class: gobject::GObjectClass,
pub quantize: Option<unsafe extern "C" fn(*mut HeQuantizer, *mut c_int, c_int, c_int) -> *mut HeQuantizerResult>,
}
impl ::std::fmt::Debug for HeQuantizerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeQuantizerClass @ {self:p}"))
.field("quantize", &self.quantize)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerMapClass {
pub parent_class: HeQuantizerClass,
}
impl ::std::fmt::Debug for HeQuantizerMapClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeQuantizerMapClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeQuantizerMapPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeQuantizerMapPrivate = _HeQuantizerMapPrivate;
#[repr(C)]
pub struct _HeQuantizerPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeQuantizerPrivate = _HeQuantizerPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerResultClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for HeQuantizerResultClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeQuantizerResultClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeQuantizerResultPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeQuantizerResultPrivate = _HeQuantizerResultPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerWsmeansClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for HeQuantizerWsmeansClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeQuantizerWsmeansClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeQuantizerWsmeansPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeQuantizerWsmeansPrivate = _HeQuantizerWsmeansPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerWuClass {
pub parent_class: HeQuantizerClass,
}
impl ::std::fmt::Debug for HeQuantizerWuClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeQuantizerWuClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeQuantizerWuPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeQuantizerWuPrivate = _HeQuantizerWuPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSaladSchemeClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for HeSaladSchemeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSaladSchemeClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeSaladSchemePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeSaladSchemePrivate = _HeSaladSchemePrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeScheme {
pub surface_bg_hex: *mut c_char,
pub surface_bg_variant_hex: *mut c_char,
pub surface_fg_hex: *mut c_char,
pub surface_fg_variant_hex: *mut c_char,
pub inverse_surface_bg_hex: *mut c_char,
pub inverse_surface_fg_hex: *mut c_char,
pub surface_bright_bg_hex: *mut c_char,
pub surface_dim_bg_hex: *mut c_char,
pub surface_container_lowest_bg_hex: *mut c_char,
pub surface_container_low_bg_hex: *mut c_char,
pub surface_container_bg_hex: *mut c_char,
pub surface_container_high_bg_hex: *mut c_char,
pub surface_container_highest_bg_hex: *mut c_char,
pub primary_hex: *mut c_char,
pub on_primary_hex: *mut c_char,
pub primary_container_hex: *mut c_char,
pub on_primary_container_hex: *mut c_char,
pub inverse_primary_hex: *mut c_char,
pub error_hex: *mut c_char,
pub on_error_hex: *mut c_char,
pub secondary_hex: *mut c_char,
pub on_secondary_hex: *mut c_char,
pub secondary_container_hex: *mut c_char,
pub on_secondary_container_hex: *mut c_char,
pub tertiary_hex: *mut c_char,
pub on_tertiary_hex: *mut c_char,
pub tertiary_container_hex: *mut c_char,
pub on_tertiary_container_hex: *mut c_char,
pub outline_hex: *mut c_char,
pub outline_variant_hex: *mut c_char,
pub shadow_hex: *mut c_char,
pub scrim_hex: *mut c_char,
}
impl ::std::fmt::Debug for HeScheme {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeScheme @ {self:p}"))
.field("surface_bg_hex", &self.surface_bg_hex)
.field("surface_bg_variant_hex", &self.surface_bg_variant_hex)
.field("surface_fg_hex", &self.surface_fg_hex)
.field("surface_fg_variant_hex", &self.surface_fg_variant_hex)
.field("inverse_surface_bg_hex", &self.inverse_surface_bg_hex)
.field("inverse_surface_fg_hex", &self.inverse_surface_fg_hex)
.field("surface_bright_bg_hex", &self.surface_bright_bg_hex)
.field("surface_dim_bg_hex", &self.surface_dim_bg_hex)
.field("surface_container_lowest_bg_hex", &self.surface_container_lowest_bg_hex)
.field("surface_container_low_bg_hex", &self.surface_container_low_bg_hex)
.field("surface_container_bg_hex", &self.surface_container_bg_hex)
.field("surface_container_high_bg_hex", &self.surface_container_high_bg_hex)
.field("surface_container_highest_bg_hex", &self.surface_container_highest_bg_hex)
.field("primary_hex", &self.primary_hex)
.field("on_primary_hex", &self.on_primary_hex)
.field("primary_container_hex", &self.primary_container_hex)
.field("on_primary_container_hex", &self.on_primary_container_hex)
.field("inverse_primary_hex", &self.inverse_primary_hex)
.field("error_hex", &self.error_hex)
.field("on_error_hex", &self.on_error_hex)
.field("secondary_hex", &self.secondary_hex)
.field("on_secondary_hex", &self.on_secondary_hex)
.field("secondary_container_hex", &self.secondary_container_hex)
.field("on_secondary_container_hex", &self.on_secondary_container_hex)
.field("tertiary_hex", &self.tertiary_hex)
.field("on_tertiary_hex", &self.on_tertiary_hex)
.field("tertiary_container_hex", &self.tertiary_container_hex)
.field("on_tertiary_container_hex", &self.on_tertiary_container_hex)
.field("outline_hex", &self.outline_hex)
.field("outline_variant_hex", &self.outline_variant_hex)
.field("shadow_hex", &self.shadow_hex)
.field("scrim_hex", &self.scrim_hex)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSchemeFactoryIface {
pub parent_iface: gobject::GTypeInterface,
pub generate: Option<unsafe extern "C" fn(*mut HeSchemeFactory, *mut HeColorCAM16Color, gboolean, gboolean, *mut HeScheme)>,
}
impl ::std::fmt::Debug for HeSchemeFactoryIface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSchemeFactoryIface @ {self:p}"))
.field("generate", &self.generate)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeScoreAnnotatedColorClass {
pub parent_class: gobject::GTypeClass,
}
impl ::std::fmt::Debug for HeScoreAnnotatedColorClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeScoreAnnotatedColorClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeScoreAnnotatedColorPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeScoreAnnotatedColorPrivate = _HeScoreAnnotatedColorPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeScoreClass {
pub parent_class: gobject::GTypeClass,
}
impl ::std::fmt::Debug for HeScoreClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeScoreClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeScorePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeScorePrivate = _HeScorePrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSegmentedButtonClass {
pub parent_class: gtk::GtkBoxClass,
}
impl ::std::fmt::Debug for HeSegmentedButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSegmentedButtonClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeSegmentedButtonPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeSegmentedButtonPrivate = _HeSegmentedButtonPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSettingsListClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeSettingsListClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSettingsListClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeSettingsListPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeSettingsListPrivate = _HeSettingsListPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSettingsPageClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeSettingsPageClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSettingsPageClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeSettingsPagePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeSettingsPagePrivate = _HeSettingsPagePrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSettingsRowClass {
pub parent_class: gtk::GtkListBoxRowClass,
}
impl ::std::fmt::Debug for HeSettingsRowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSettingsRowClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeSettingsRowPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeSettingsRowPrivate = _HeSettingsRowPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSettingsWindowClass {
pub parent_class: HeWindowClass,
}
impl ::std::fmt::Debug for HeSettingsWindowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSettingsWindowClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeSettingsWindowPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeSettingsWindowPrivate = _HeSettingsWindowPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSideBarClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeSideBarClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSideBarClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeSideBarPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeSideBarPrivate = _HeSideBarPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSliderClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeSliderClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSliderClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeSliderPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeSliderPrivate = _HeSliderPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeStyleManagerClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for HeStyleManagerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeStyleManagerClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeStyleManagerPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeStyleManagerPrivate = _HeStyleManagerPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSwitchBarClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeSwitchBarClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSwitchBarClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeSwitchBarPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeSwitchBarPrivate = _HeSwitchBarPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSwitchClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeSwitchClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSwitchClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeSwitchPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeSwitchPrivate = _HeSwitchPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTabClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeTabClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeTabClass @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTabPageClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeTabPageClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeTabPageClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeTabPagePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeTabPagePrivate = _HeTabPagePrivate;
#[repr(C)]
pub struct _HeTabPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeTabPrivate = _HeTabPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTabSwitcherClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeTabSwitcherClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeTabSwitcherClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeTabSwitcherPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeTabSwitcherPrivate = _HeTabSwitcherPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTextButtonClass {
pub parent_class: HeButtonClass,
}
impl ::std::fmt::Debug for HeTextButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeTextButtonClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeTextButtonPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeTextButtonPrivate = _HeTextButtonPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTextFieldClass {
pub parent_class: gtk::GtkListBoxRowClass,
}
impl ::std::fmt::Debug for HeTextFieldClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeTextFieldClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeTextFieldPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeTextFieldPrivate = _HeTextFieldPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTimePickerClass {
pub parent_class: gtk::GtkEntryClass,
}
impl ::std::fmt::Debug for HeTimePickerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeTimePickerClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeTimePickerPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeTimePickerPrivate = _HeTimePickerPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTintButtonClass {
pub parent_class: HeButtonClass,
}
impl ::std::fmt::Debug for HeTintButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeTintButtonClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeTintButtonPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeTintButtonPrivate = _HeTintButtonPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeToastClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeToastClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeToastClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeToastPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeToastPrivate = _HeToastPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeVibrantSchemeClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for HeVibrantSchemeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeVibrantSchemeClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeVibrantSchemePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeVibrantSchemePrivate = _HeVibrantSchemePrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewAuxClass {
pub parent_class: HeViewClass,
}
impl ::std::fmt::Debug for HeViewAuxClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewAuxClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeViewAuxPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeViewAuxPrivate = _HeViewAuxPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewChooserClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeViewChooserClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewChooserClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeViewChooserPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeViewChooserPrivate = _HeViewChooserPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewClass {
pub parent_class: gtk::GtkWidgetClass,
pub add_child: Option<unsafe extern "C" fn(*mut HeView, *mut gtk::GtkBuilder, *mut gobject::GObject, *const c_char)>,
}
impl ::std::fmt::Debug for HeViewClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewClass @ {self:p}"))
.field("add_child", &self.add_child)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewDualClass {
pub parent_class: HeViewClass,
}
impl ::std::fmt::Debug for HeViewDualClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewDualClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeViewDualPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeViewDualPrivate = _HeViewDualPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewMonoClass {
pub parent_class: HeViewClass,
}
impl ::std::fmt::Debug for HeViewMonoClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewMonoClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeViewMonoPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeViewMonoPrivate = _HeViewMonoPrivate;
#[repr(C)]
pub struct _HeViewPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeViewPrivate = _HeViewPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewSubTitleClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeViewSubTitleClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewSubTitleClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeViewSubTitlePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeViewSubTitlePrivate = _HeViewSubTitlePrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewSwitcherClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeViewSwitcherClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewSwitcherClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeViewSwitcherPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeViewSwitcherPrivate = _HeViewSwitcherPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewTitleClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeViewTitleClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewTitleClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeViewTitlePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeViewTitlePrivate = _HeViewTitlePrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewingConditionsClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for HeViewingConditionsClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewingConditionsClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeViewingConditionsPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeViewingConditionsPrivate = _HeViewingConditionsPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeWelcomeScreenClass {
pub parent_class: HeBinClass,
}
impl ::std::fmt::Debug for HeWelcomeScreenClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeWelcomeScreenClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeWelcomeScreenPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeWelcomeScreenPrivate = _HeWelcomeScreenPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeWindowClass {
pub parent_class: gtk::GtkWindowClass,
}
impl ::std::fmt::Debug for HeWindowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeWindowClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _HeWindowPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type HeWindowPrivate = _HeWindowPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeAboutWindow {
pub parent_instance: HeWindow,
pub priv_: *mut HeAboutWindowPrivate,
}
impl ::std::fmt::Debug for HeAboutWindow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeAboutWindow @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeAppBar {
pub parent_instance: HeBin,
pub priv_: *mut HeAppBarPrivate,
pub flat: gboolean,
pub back_button: *mut gtk::GtkButton,
pub btn_box: *mut gtk::GtkBox,
}
impl ::std::fmt::Debug for HeAppBar {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeAppBar @ {self:p}"))
.field("flat", &self.flat)
.field("back_button", &self.back_button)
.field("btn_box", &self.btn_box)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeApplication {
pub parent_instance: gtk::GtkApplication,
pub priv_: *mut HeApplicationPrivate,
}
impl ::std::fmt::Debug for HeApplication {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeApplication @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeApplicationWindow {
pub parent_instance: gtk::GtkApplicationWindow,
pub priv_: *mut HeApplicationWindowPrivate,
}
impl ::std::fmt::Debug for HeApplicationWindow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeApplicationWindow @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeAvatar {
pub parent_instance: HeBin,
pub priv_: *mut HeAvatarPrivate,
}
impl ::std::fmt::Debug for HeAvatar {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeAvatar @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeBadge {
pub parent_instance: HeBin,
pub priv_: *mut HeBadgePrivate,
}
impl ::std::fmt::Debug for HeBadge {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeBadge @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeBanner {
pub parent_instance: HeBin,
pub priv_: *mut HeBannerPrivate,
}
impl ::std::fmt::Debug for HeBanner {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeBanner @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeBin {
pub parent_instance: gtk::GtkWidget,
pub priv_: *mut HeBinPrivate,
}
impl ::std::fmt::Debug for HeBin {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeBin @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeBottomBar {
pub parent_instance: HeBin,
pub priv_: *mut HeBottomBarPrivate,
}
impl ::std::fmt::Debug for HeBottomBar {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeBottomBar @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeButton {
pub parent_instance: gtk::GtkButton,
pub priv_: *mut HeButtonPrivate,
}
impl ::std::fmt::Debug for HeButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeButton @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeButtonContent {
pub parent_instance: gtk::GtkWidget,
pub priv_: *mut HeButtonContentPrivate,
pub image: *mut gtk::GtkImage,
}
impl ::std::fmt::Debug for HeButtonContent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeButtonContent @ {self:p}"))
.field("image", &self.image)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeChip {
pub parent_instance: gtk::GtkToggleButton,
pub priv_: *mut HeChipPrivate,
}
impl ::std::fmt::Debug for HeChip {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeChip @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeChipGroup {
pub parent_instance: HeBin,
pub priv_: *mut HeChipGroupPrivate,
}
impl ::std::fmt::Debug for HeChipGroup {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeChipGroup @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContentBlock {
pub parent_instance: HeBin,
pub priv_: *mut HeContentBlockPrivate,
}
impl ::std::fmt::Debug for HeContentBlock {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeContentBlock @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContentBlockImage {
pub parent_instance: HeBin,
pub priv_: *mut HeContentBlockImagePrivate,
}
impl ::std::fmt::Debug for HeContentBlockImage {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeContentBlockImage @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContentBlockImageCluster {
pub parent_instance: HeBin,
pub priv_: *mut HeContentBlockImageClusterPrivate,
}
impl ::std::fmt::Debug for HeContentBlockImageCluster {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeContentBlockImageCluster @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContentList {
pub parent_instance: HeBin,
pub priv_: *mut HeContentListPrivate,
pub children: *mut glib::GList,
}
impl ::std::fmt::Debug for HeContentList {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeContentList @ {self:p}"))
.field("children", &self.children)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeContentScheme {
pub parent_instance: gobject::GObject,
pub priv_: *mut HeContentSchemePrivate,
}
impl ::std::fmt::Debug for HeContentScheme {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeContentScheme @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDatePicker {
pub parent_instance: gtk::GtkEntry,
pub priv_: *mut HeDatePickerPrivate,
}
impl ::std::fmt::Debug for HeDatePicker {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeDatePicker @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDefaultScheme {
pub parent_instance: gobject::GObject,
pub priv_: *mut HeDefaultSchemePrivate,
}
impl ::std::fmt::Debug for HeDefaultScheme {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeDefaultScheme @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDesktop {
pub parent_instance: gobject::GObject,
pub priv_: *mut HeDesktopPrivate,
}
impl ::std::fmt::Debug for HeDesktop {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeDesktop @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDialog {
pub parent_instance: HeWindow,
pub priv_: *mut HeDialogPrivate,
pub cancel_button: *mut HeTextButton,
}
impl ::std::fmt::Debug for HeDialog {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeDialog @ {self:p}"))
.field("cancel_button", &self.cancel_button)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDisclosureButton {
pub parent_instance: HeButton,
pub priv_: *mut HeDisclosureButtonPrivate,
}
impl ::std::fmt::Debug for HeDisclosureButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeDisclosureButton @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeDivider {
pub parent_instance: HeBin,
pub priv_: *mut HeDividerPrivate,
}
impl ::std::fmt::Debug for HeDivider {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeDivider @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeEmptyPage {
pub parent_instance: HeBin,
pub priv_: *mut HeEmptyPagePrivate,
pub action_button: *mut HePillButton,
}
impl ::std::fmt::Debug for HeEmptyPage {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeEmptyPage @ {self:p}"))
.field("action_button", &self.action_button)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeFillButton {
pub parent_instance: HeButton,
pub priv_: *mut HeFillButtonPrivate,
}
impl ::std::fmt::Debug for HeFillButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeFillButton @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeIconicButton {
pub parent_instance: HeButton,
pub priv_: *mut HeIconicButtonPrivate,
}
impl ::std::fmt::Debug for HeIconicButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeIconicButton @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeMiniContentBlock {
pub parent_instance: HeBin,
pub priv_: *mut HeMiniContentBlockPrivate,
}
impl ::std::fmt::Debug for HeMiniContentBlock {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeMiniContentBlock @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeModifierBadge {
pub parent_instance: HeBin,
pub priv_: *mut HeModifierBadgePrivate,
}
impl ::std::fmt::Debug for HeModifierBadge {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeModifierBadge @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeMonochromaticScheme {
pub parent_instance: gobject::GObject,
pub priv_: *mut HeMonochromaticSchemePrivate,
}
impl ::std::fmt::Debug for HeMonochromaticScheme {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeMonochromaticScheme @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeMutedScheme {
pub parent_instance: gobject::GObject,
pub priv_: *mut HeMutedSchemePrivate,
}
impl ::std::fmt::Debug for HeMutedScheme {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeMutedScheme @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeNavigationRail {
pub parent_instance: HeBin,
pub priv_: *mut HeNavigationRailPrivate,
}
impl ::std::fmt::Debug for HeNavigationRail {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeNavigationRail @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeNavigationSection {
pub parent_instance: HeBin,
pub priv_: *mut HeNavigationSectionPrivate,
}
impl ::std::fmt::Debug for HeNavigationSection {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeNavigationSection @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeOutlineButton {
pub parent_instance: HeButton,
pub priv_: *mut HeOutlineButtonPrivate,
}
impl ::std::fmt::Debug for HeOutlineButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeOutlineButton @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeOverlayButton {
pub parent_instance: HeBin,
pub priv_: *mut HeOverlayButtonPrivate,
}
impl ::std::fmt::Debug for HeOverlayButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeOverlayButton @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HePillButton {
pub parent_instance: HeButton,
pub priv_: *mut HePillButtonPrivate,
}
impl ::std::fmt::Debug for HePillButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HePillButton @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeProgressBar {
pub parent_instance: HeBin,
pub priv_: *mut HeProgressBarPrivate,
pub progressbar: *mut gtk::GtkProgressBar,
}
impl ::std::fmt::Debug for HeProgressBar {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeProgressBar @ {self:p}"))
.field("progressbar", &self.progressbar)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizer {
pub parent_instance: gobject::GObject,
pub priv_: *mut HeQuantizerPrivate,
}
impl ::std::fmt::Debug for HeQuantizer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeQuantizer @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerCelebi {
pub parent_instance: gobject::GTypeInstance,
pub ref_count: c_int,
pub priv_: *mut HeQuantizerCelebiPrivate,
}
impl ::std::fmt::Debug for HeQuantizerCelebi {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeQuantizerCelebi @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerMap {
pub parent_instance: HeQuantizer,
pub priv_: *mut HeQuantizerMapPrivate,
}
impl ::std::fmt::Debug for HeQuantizerMap {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeQuantizerMap @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerResult {
pub parent_instance: gobject::GObject,
pub priv_: *mut HeQuantizerResultPrivate,
pub color_to_count: *mut glib::GHashTable,
}
impl ::std::fmt::Debug for HeQuantizerResult {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeQuantizerResult @ {self:p}"))
.field("color_to_count", &self.color_to_count)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerWsmeans {
pub parent_instance: gobject::GObject,
pub priv_: *mut HeQuantizerWsmeansPrivate,
}
impl ::std::fmt::Debug for HeQuantizerWsmeans {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeQuantizerWsmeans @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeQuantizerWu {
pub parent_instance: HeQuantizer,
pub priv_: *mut HeQuantizerWuPrivate,
}
impl ::std::fmt::Debug for HeQuantizerWu {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeQuantizerWu @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSaladScheme {
pub parent_instance: gobject::GObject,
pub priv_: *mut HeSaladSchemePrivate,
}
impl ::std::fmt::Debug for HeSaladScheme {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSaladScheme @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeScore {
pub parent_instance: gobject::GTypeInstance,
pub ref_count: c_int,
pub priv_: *mut HeScorePrivate,
}
impl ::std::fmt::Debug for HeScore {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeScore @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeScoreAnnotatedColor {
pub parent_instance: gobject::GTypeInstance,
pub ref_count: c_int,
pub priv_: *mut HeScoreAnnotatedColorPrivate,
pub argb: c_int,
pub cam_hue: c_double,
pub cam_chroma: c_double,
pub excited_proportion: c_double,
pub score: c_double,
pub he_score_annotated_color_cmp: glib::GCompareFunc,
}
impl ::std::fmt::Debug for HeScoreAnnotatedColor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeScoreAnnotatedColor @ {self:p}"))
.field("argb", &self.argb)
.field("cam_hue", &self.cam_hue)
.field("cam_chroma", &self.cam_chroma)
.field("excited_proportion", &self.excited_proportion)
.field("score", &self.score)
.field("he_score_annotated_color_cmp", &self.he_score_annotated_color_cmp)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSegmentedButton {
pub parent_instance: gtk::GtkBox,
pub priv_: *mut HeSegmentedButtonPrivate,
}
impl ::std::fmt::Debug for HeSegmentedButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSegmentedButton @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSettingsList {
pub parent_instance: HeBin,
pub priv_: *mut HeSettingsListPrivate,
pub children: *mut glib::GList,
}
impl ::std::fmt::Debug for HeSettingsList {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSettingsList @ {self:p}"))
.field("children", &self.children)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSettingsPage {
pub parent_instance: HeBin,
pub priv_: *mut HeSettingsPagePrivate,
}
impl ::std::fmt::Debug for HeSettingsPage {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSettingsPage @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSettingsRow {
pub parent_instance: gtk::GtkListBoxRow,
pub priv_: *mut HeSettingsRowPrivate,
}
impl ::std::fmt::Debug for HeSettingsRow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSettingsRow @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSettingsWindow {
pub parent_instance: HeWindow,
pub priv_: *mut HeSettingsWindowPrivate,
}
impl ::std::fmt::Debug for HeSettingsWindow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSettingsWindow @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSideBar {
pub parent_instance: HeBin,
pub priv_: *mut HeSideBarPrivate,
}
impl ::std::fmt::Debug for HeSideBar {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSideBar @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSlider {
pub parent_instance: HeBin,
pub priv_: *mut HeSliderPrivate,
pub scale: *mut gtk::GtkScale,
}
impl ::std::fmt::Debug for HeSlider {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSlider @ {self:p}"))
.field("scale", &self.scale)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeStyleManager {
pub parent_instance: gobject::GObject,
pub priv_: *mut HeStyleManagerPrivate,
pub accent_color: *mut HeColorRGBColor,
pub font_weight: c_double,
pub roundness: c_double,
pub is_dark: gboolean,
pub is_contrast: gboolean,
pub scheme_factory: *mut HeSchemeFactory,
}
impl ::std::fmt::Debug for HeStyleManager {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeStyleManager @ {self:p}"))
.field("accent_color", &self.accent_color)
.field("font_weight", &self.font_weight)
.field("roundness", &self.roundness)
.field("is_dark", &self.is_dark)
.field("is_contrast", &self.is_contrast)
.field("scheme_factory", &self.scheme_factory)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSwitch {
pub parent_instance: HeBin,
pub priv_: *mut HeSwitchPrivate,
pub iswitch: *mut gtk::GtkSwitch,
}
impl ::std::fmt::Debug for HeSwitch {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSwitch @ {self:p}"))
.field("iswitch", &self.iswitch)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeSwitchBar {
pub parent_instance: HeBin,
pub priv_: *mut HeSwitchBarPrivate,
pub main_switch: *mut HeSwitch,
}
impl ::std::fmt::Debug for HeSwitchBar {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeSwitchBar @ {self:p}"))
.field("main_switch", &self.main_switch)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTab {
pub parent_instance: HeBin,
pub priv_: *mut HeTabPrivate,
pub page_container: *mut HeTabPage,
}
impl ::std::fmt::Debug for HeTab {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeTab @ {self:p}"))
.field("page_container", &self.page_container)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTabPage {
pub parent_instance: HeBin,
pub priv_: *mut HeTabPagePrivate,
}
impl ::std::fmt::Debug for HeTabPage {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeTabPage @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTabSwitcher {
pub parent_instance: HeBin,
pub priv_: *mut HeTabSwitcherPrivate,
pub notebook: *mut gtk::GtkNotebook,
}
impl ::std::fmt::Debug for HeTabSwitcher {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeTabSwitcher @ {self:p}"))
.field("notebook", &self.notebook)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTextButton {
pub parent_instance: HeButton,
pub priv_: *mut HeTextButtonPrivate,
}
impl ::std::fmt::Debug for HeTextButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeTextButton @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTextField {
pub parent_instance: gtk::GtkListBoxRow,
pub priv_: *mut HeTextFieldPrivate,
}
impl ::std::fmt::Debug for HeTextField {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeTextField @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTimePicker {
pub parent_instance: gtk::GtkEntry,
pub priv_: *mut HeTimePickerPrivate,
}
impl ::std::fmt::Debug for HeTimePicker {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeTimePicker @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeTintButton {
pub parent_instance: HeButton,
pub priv_: *mut HeTintButtonPrivate,
}
impl ::std::fmt::Debug for HeTintButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeTintButton @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeToast {
pub parent_instance: HeBin,
pub priv_: *mut HeToastPrivate,
}
impl ::std::fmt::Debug for HeToast {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeToast @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeVibrantScheme {
pub parent_instance: gobject::GObject,
pub priv_: *mut HeVibrantSchemePrivate,
}
impl ::std::fmt::Debug for HeVibrantScheme {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeVibrantScheme @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeView {
pub parent_instance: gtk::GtkWidget,
pub priv_: *mut HeViewPrivate,
}
impl ::std::fmt::Debug for HeView {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeView @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewAux {
pub parent_instance: HeView,
pub priv_: *mut HeViewAuxPrivate,
}
impl ::std::fmt::Debug for HeViewAux {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewAux @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewChooser {
pub parent_instance: HeBin,
pub priv_: *mut HeViewChooserPrivate,
}
impl ::std::fmt::Debug for HeViewChooser {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewChooser @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewDual {
pub parent_instance: HeView,
pub priv_: *mut HeViewDualPrivate,
}
impl ::std::fmt::Debug for HeViewDual {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewDual @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewMono {
pub parent_instance: HeView,
pub priv_: *mut HeViewMonoPrivate,
}
impl ::std::fmt::Debug for HeViewMono {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewMono @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewSubTitle {
pub parent_instance: HeBin,
pub priv_: *mut HeViewSubTitlePrivate,
}
impl ::std::fmt::Debug for HeViewSubTitle {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewSubTitle @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewSwitcher {
pub parent_instance: HeBin,
pub priv_: *mut HeViewSwitcherPrivate,
}
impl ::std::fmt::Debug for HeViewSwitcher {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewSwitcher @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewTitle {
pub parent_instance: HeBin,
pub priv_: *mut HeViewTitlePrivate,
}
impl ::std::fmt::Debug for HeViewTitle {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewTitle @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeViewingConditions {
pub parent_instance: gobject::GObject,
pub priv_: *mut HeViewingConditionsPrivate,
pub he_viewing_conditions_default_conditions: *mut HeViewingConditions,
pub rgb_d: *mut c_double,
pub rgb_d_length1: c_int,
}
impl ::std::fmt::Debug for HeViewingConditions {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeViewingConditions @ {self:p}"))
.field("he_viewing_conditions_default_conditions", &self.he_viewing_conditions_default_conditions)
.field("rgb_d", &self.rgb_d)
.field("rgb_d_length1", &self.rgb_d_length1)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeWelcomeScreen {
pub parent_instance: HeBin,
pub priv_: *mut HeWelcomeScreenPrivate,
}
impl ::std::fmt::Debug for HeWelcomeScreen {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeWelcomeScreen @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HeWindow {
pub parent_instance: gtk::GtkWindow,
pub priv_: *mut HeWindowPrivate,
}
impl ::std::fmt::Debug for HeWindow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("HeWindow @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct HeSchemeFactory {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for HeSchemeFactory {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "HeSchemeFactory @ {self:p}")
}
}
#[link(name = "helium-1")]
extern "C" {
pub fn he_about_window_licenses_get_type() -> GType;
pub fn he_banner_style_get_type() -> GType;
pub fn he_bottom_bar_position_get_type() -> GType;
pub fn he_colors_get_type() -> GType;
pub fn he_content_block_image_cluster_image_position_get_type() -> GType;
pub fn he_desktop_color_scheme_get_type() -> GType;
pub fn he_desktop_contrast_scheme_get_type() -> GType;
pub fn he_desktop_ensor_scheme_get_type() -> GType;
pub fn he_modifier_badge_alignment_get_type() -> GType;
pub fn he_overlay_button_alignment_get_type() -> GType;
pub fn he_overlay_button_size_get_type() -> GType;
pub fn he_overlay_button_type_button_get_type() -> GType;
pub fn he_tab_switcher_tab_bar_behavior_get_type() -> GType;
pub fn he_color_ca_m16_color_get_type() -> GType;
pub fn he_color_hct_color_get_type() -> GType;
pub fn he_color_lab_color_get_type() -> GType;
pub fn he_color_lab_color_distance(self_: *mut HeColorLABColor, lab: *mut HeColorLABColor) -> c_double;
pub fn he_color_lch_color_get_type() -> GType;
pub fn he_color_rgb_color_get_type() -> GType;
pub fn he_color_xyz_color_get_type() -> GType;
pub fn he_scheme_get_type() -> GType;
pub fn he_about_window_get_type() -> GType;
pub fn he_about_window_new(parent: *mut gtk::GtkWindow, app_name: *const c_char, app_id: *const c_char, version: *const c_char, icon: *const c_char, translate_url: *const c_char, issue_url: *const c_char, more_info_url: *const c_char, translators: *mut *mut c_char, translators_length1: c_int, developers: *mut *mut c_char, developers_length1: c_int, copyright_year: c_int, license: HeAboutWindowLicenses, color: HeColors) -> *mut HeAboutWindow;
pub fn he_about_window_get_color(self_: *mut HeAboutWindow) -> HeColors;
pub fn he_about_window_set_color(self_: *mut HeAboutWindow, value: HeColors);
pub fn he_about_window_get_license(self_: *mut HeAboutWindow) -> HeAboutWindowLicenses;
pub fn he_about_window_set_license(self_: *mut HeAboutWindow, value: HeAboutWindowLicenses);
pub fn he_about_window_get_version(self_: *mut HeAboutWindow) -> *const c_char;
pub fn he_about_window_set_version(self_: *mut HeAboutWindow, value: *const c_char);
pub fn he_about_window_get_app_name(self_: *mut HeAboutWindow) -> *const c_char;
pub fn he_about_window_set_app_name(self_: *mut HeAboutWindow, value: *const c_char);
pub fn he_about_window_get_icon(self_: *mut HeAboutWindow) -> *const c_char;
pub fn he_about_window_set_icon(self_: *mut HeAboutWindow, value: *const c_char);
pub fn he_about_window_get_translator_names(self_: *mut HeAboutWindow, result_length1: *mut c_int) -> *mut *mut c_char;
pub fn he_about_window_set_translator_names(self_: *mut HeAboutWindow, value: *mut *mut c_char, value_length1: c_int);
pub fn he_about_window_get_developer_names(self_: *mut HeAboutWindow, result_length1: *mut c_int) -> *mut *mut c_char;
pub fn he_about_window_set_developer_names(self_: *mut HeAboutWindow, value: *mut *mut c_char, value_length1: c_int);
pub fn he_about_window_get_copyright_year(self_: *mut HeAboutWindow) -> c_int;
pub fn he_about_window_set_copyright_year(self_: *mut HeAboutWindow, value: c_int);
pub fn he_about_window_get_app_id(self_: *mut HeAboutWindow) -> *const c_char;
pub fn he_about_window_set_app_id(self_: *mut HeAboutWindow, value: *const c_char);
pub fn he_about_window_get_translate_url(self_: *mut HeAboutWindow) -> *const c_char;
pub fn he_about_window_set_translate_url(self_: *mut HeAboutWindow, value: *const c_char);
pub fn he_about_window_get_issue_url(self_: *mut HeAboutWindow) -> *const c_char;
pub fn he_about_window_set_issue_url(self_: *mut HeAboutWindow, value: *const c_char);
pub fn he_about_window_get_more_info_url(self_: *mut HeAboutWindow) -> *const c_char;
pub fn he_about_window_set_more_info_url(self_: *mut HeAboutWindow, value: *const c_char);
pub fn he_app_bar_get_type() -> GType;
pub fn he_app_bar_append(self_: *mut HeAppBar, child: *mut gtk::GtkWidget);
pub fn he_app_bar_remove(self_: *mut HeAppBar, child: *mut gtk::GtkWidget);
pub fn he_app_bar_new() -> *mut HeAppBar;
pub fn he_app_bar_get_stack(self_: *mut HeAppBar) -> *mut gtk::GtkStack;
pub fn he_app_bar_set_stack(self_: *mut HeAppBar, value: *mut gtk::GtkStack);
pub fn he_app_bar_get_scroller(self_: *mut HeAppBar) -> *mut gtk::GtkScrolledWindow;
pub fn he_app_bar_set_scroller(self_: *mut HeAppBar, value: *mut gtk::GtkScrolledWindow);
pub fn he_app_bar_get_viewtitle_label(self_: *mut HeAppBar) -> *const c_char;
pub fn he_app_bar_set_viewtitle_label(self_: *mut HeAppBar, value: *const c_char);
pub fn he_app_bar_get_viewtitle_widget(self_: *mut HeAppBar) -> *mut gtk::GtkWidget;
pub fn he_app_bar_set_viewtitle_widget(self_: *mut HeAppBar, value: *mut gtk::GtkWidget);
pub fn he_app_bar_get_viewsubtitle_label(self_: *mut HeAppBar) -> *const c_char;
pub fn he_app_bar_set_viewsubtitle_label(self_: *mut HeAppBar, value: *const c_char);
pub fn he_app_bar_get_show_left_title_buttons(self_: *mut HeAppBar) -> gboolean;
pub fn he_app_bar_set_show_left_title_buttons(self_: *mut HeAppBar, value: gboolean);
pub fn he_app_bar_get_show_right_title_buttons(self_: *mut HeAppBar) -> gboolean;
pub fn he_app_bar_set_show_right_title_buttons(self_: *mut HeAppBar, value: gboolean);
pub fn he_app_bar_get_decoration_layout(self_: *mut HeAppBar) -> *const c_char;
pub fn he_app_bar_set_decoration_layout(self_: *mut HeAppBar, value: *const c_char);
pub fn he_app_bar_get_show_back(self_: *mut HeAppBar) -> gboolean;
pub fn he_app_bar_set_show_back(self_: *mut HeAppBar, value: gboolean);
pub fn he_application_get_type() -> GType;
pub fn he_application_new(application_id: *const c_char, flags: gio::GApplicationFlags) -> *mut HeApplication;
pub fn he_application_get_default_accent_color(self_: *mut HeApplication) -> *mut HeColorRGBColor;
pub fn he_application_set_default_accent_color(self_: *mut HeApplication, value: *mut HeColorRGBColor);
pub fn he_application_get_override_accent_color(self_: *mut HeApplication) -> gboolean;
pub fn he_application_set_override_accent_color(self_: *mut HeApplication, value: gboolean);
pub fn he_application_get_scheme_factory(self_: *mut HeApplication) -> *mut HeSchemeFactory;
pub fn he_application_set_scheme_factory(self_: *mut HeApplication, value: *mut HeSchemeFactory);
pub fn he_application_window_get_type() -> GType;
pub fn he_application_window_new(app: *mut HeApplication) -> *mut HeApplicationWindow;
pub fn he_application_window_get_has_title(self_: *mut HeApplicationWindow) -> gboolean;
pub fn he_application_window_set_has_title(self_: *mut HeApplicationWindow, value: gboolean);
pub fn he_application_window_get_has_back_button(self_: *mut HeApplicationWindow) -> gboolean;
pub fn he_application_window_set_has_back_button(self_: *mut HeApplicationWindow, value: gboolean);
pub fn he_avatar_get_type() -> GType;
pub fn he_avatar_new(size: c_int, image: *const c_char, text: *const c_char, status: *mut gboolean) -> *mut HeAvatar;
pub fn he_avatar_get_size(self_: *mut HeAvatar) -> c_int;
pub fn he_avatar_set_size(self_: *mut HeAvatar, value: c_int);
pub fn he_avatar_get_text(self_: *mut HeAvatar) -> *const c_char;
pub fn he_avatar_set_text(self_: *mut HeAvatar, value: *const c_char);
pub fn he_avatar_get_status(self_: *mut HeAvatar) -> gboolean;
pub fn he_avatar_set_status(self_: *mut HeAvatar, value: gboolean);
pub fn he_avatar_get_image(self_: *mut HeAvatar) -> *const c_char;
pub fn he_avatar_set_image(self_: *mut HeAvatar, value: *const c_char);
pub fn he_badge_get_type() -> GType;
pub fn he_badge_new() -> *mut HeBadge;
pub fn he_badge_get_child(self_: *mut HeBadge) -> *mut gtk::GtkWidget;
pub fn he_badge_set_child(self_: *mut HeBadge, value: *mut gtk::GtkWidget);
pub fn he_badge_get_label(self_: *mut HeBadge) -> *const c_char;
pub fn he_badge_set_label(self_: *mut HeBadge, value: *const c_char);
pub fn he_banner_get_type() -> GType;
pub fn he_banner_add_action_button(self_: *mut HeBanner, widget: *mut gtk::GtkWidget);
pub fn he_banner_remove_action(self_: *mut HeBanner, widget: *mut gtk::GtkWidget);
pub fn he_banner_set_banner_style(self_: *mut HeBanner, style: HeBannerStyle);
pub fn he_banner_new(title: *const c_char, description: *const c_char) -> *mut HeBanner;
pub fn he_banner_get_title(self_: *mut HeBanner) -> *const c_char;
pub fn he_banner_set_title(self_: *mut HeBanner, value: *const c_char);
pub fn he_banner_get_description(self_: *mut HeBanner) -> *const c_char;
pub fn he_banner_set_description(self_: *mut HeBanner, value: *const c_char);
pub fn he_banner_get_style(self_: *mut HeBanner) -> HeBannerStyle;
pub fn he_banner_set_style(self_: *mut HeBanner, value: HeBannerStyle);
pub fn he_bin_get_type() -> GType;
pub fn he_bin_add_child(self_: *mut HeBin, builder: *mut gtk::GtkBuilder, child: *mut gobject::GObject, type_: *const c_char);
pub fn he_bin_new() -> *mut HeBin;
pub fn he_bin_get_child(self_: *mut HeBin) -> *mut gtk::GtkWidget;
pub fn he_bin_set_child(self_: *mut HeBin, value: *mut gtk::GtkWidget);
pub fn he_bottom_bar_get_type() -> GType;
pub fn he_bottom_bar_new_with_details(title: *const c_char, description: *const c_char) -> *mut HeBottomBar;
pub fn he_bottom_bar_new() -> *mut HeBottomBar;
pub fn he_bottom_bar_append_button(self_: *mut HeBottomBar, icon: *mut HeIconicButton, position: HeBottomBarPosition);
pub fn he_bottom_bar_prepend_button(self_: *mut HeBottomBar, icon: *mut HeIconicButton, position: HeBottomBarPosition);
pub fn he_bottom_bar_remove_button(self_: *mut HeBottomBar, icon: *mut HeIconicButton, position: HeBottomBarPosition);
pub fn he_bottom_bar_insert_button_after(self_: *mut HeBottomBar, icon: *mut HeIconicButton, after: *mut HeIconicButton, position: HeBottomBarPosition);
pub fn he_bottom_bar_reorder_button_after(self_: *mut HeBottomBar, icon: *mut HeIconicButton, sibling: *mut HeIconicButton, position: HeBottomBarPosition);
pub fn he_bottom_bar_get_title(self_: *mut HeBottomBar) -> *const c_char;
pub fn he_bottom_bar_set_title(self_: *mut HeBottomBar, value: *const c_char);
pub fn he_bottom_bar_get_description(self_: *mut HeBottomBar) -> *const c_char;
pub fn he_bottom_bar_set_description(self_: *mut HeBottomBar, value: *const c_char);
pub fn he_bottom_bar_get_menu_model(self_: *mut HeBottomBar) -> *mut gio::GMenuModel;
pub fn he_bottom_bar_set_menu_model(self_: *mut HeBottomBar, value: *mut gio::GMenuModel);
pub fn he_bottom_bar_get_collapse_actions(self_: *mut HeBottomBar) -> gboolean;
pub fn he_bottom_bar_set_collapse_actions(self_: *mut HeBottomBar, value: gboolean);
pub fn he_button_get_type() -> GType;
pub fn he_button_get_color(self_: *mut HeButton) -> HeColors;
pub fn he_button_set_color(self_: *mut HeButton, value: HeColors);
pub fn he_button_get_icon(self_: *mut HeButton) -> *mut c_char;
pub fn he_button_set_icon(self_: *mut HeButton, value: *const c_char);
pub fn he_button_content_get_type() -> GType;
pub fn he_button_content_new() -> *mut HeButtonContent;
pub fn he_button_content_get_icon(self_: *mut HeButtonContent) -> *mut c_char;
pub fn he_button_content_set_icon(self_: *mut HeButtonContent, value: *const c_char);
pub fn he_button_content_get_label(self_: *mut HeButtonContent) -> *mut c_char;
pub fn he_button_content_set_label(self_: *mut HeButtonContent, value: *const c_char);
pub fn he_chip_get_type() -> GType;
pub fn he_chip_new(label: *const c_char) -> *mut HeChip;
pub fn he_chip_get_chip_label(self_: *mut HeChip) -> *const c_char;
pub fn he_chip_set_chip_label(self_: *mut HeChip, value: *const c_char);
pub fn he_chip_group_get_type() -> GType;
pub fn he_chip_group_new() -> *mut HeChipGroup;
pub fn he_chip_group_get_selection_model(self_: *mut HeChipGroup) -> *mut gtk::GtkSingleSelection;
pub fn he_chip_group_set_selection_model(self_: *mut HeChipGroup, value: *mut gtk::GtkSingleSelection);
pub fn he_chip_group_get_single_line(self_: *mut HeChipGroup) -> gboolean;
pub fn he_chip_group_set_single_line(self_: *mut HeChipGroup, value: gboolean);
pub fn he_content_block_get_type() -> GType;
pub fn he_content_block_new(title: *const c_char, subtitle: *const c_char, icon: *const c_char, primary_button: *mut HeButton, secondary_button: *mut HeButton) -> *mut HeContentBlock;
pub fn he_content_block_get_title(self_: *mut HeContentBlock) -> *const c_char;
pub fn he_content_block_set_title(self_: *mut HeContentBlock, value: *const c_char);
pub fn he_content_block_get_subtitle(self_: *mut HeContentBlock) -> *const c_char;
pub fn he_content_block_set_subtitle(self_: *mut HeContentBlock, value: *const c_char);
pub fn he_content_block_get_icon(self_: *mut HeContentBlock) -> *const c_char;
pub fn he_content_block_set_icon(self_: *mut HeContentBlock, value: *const c_char);
pub fn he_content_block_set_gicon(self_: *mut HeContentBlock, value: *mut gio::GIcon);
pub fn he_content_block_get_secondary_button(self_: *mut HeContentBlock) -> *mut HeButton;
pub fn he_content_block_set_secondary_button(self_: *mut HeContentBlock, value: *mut HeButton);
pub fn he_content_block_get_primary_button(self_: *mut HeContentBlock) -> *mut HeButton;
pub fn he_content_block_set_primary_button(self_: *mut HeContentBlock, value: *mut HeButton);
pub fn he_content_block_image_get_type() -> GType;
pub fn he_content_block_image_new(file: *const c_char) -> *mut HeContentBlockImage;
pub fn he_content_block_image_get_file(self_: *mut HeContentBlockImage) -> *const c_char;
pub fn he_content_block_image_set_file(self_: *mut HeContentBlockImage, value: *const c_char);
pub fn he_content_block_image_get_requested_height(self_: *mut HeContentBlockImage) -> c_int;
pub fn he_content_block_image_set_requested_height(self_: *mut HeContentBlockImage, value: c_int);
pub fn he_content_block_image_get_requested_width(self_: *mut HeContentBlockImage) -> c_int;
pub fn he_content_block_image_set_requested_width(self_: *mut HeContentBlockImage, value: c_int);
pub fn he_content_block_image_cluster_get_type() -> GType;
pub fn he_content_block_image_cluster_set_image(self_: *mut HeContentBlockImageCluster, image: *mut HeContentBlockImage, position: HeContentBlockImageClusterImagePosition);
pub fn he_content_block_image_cluster_remove_image(self_: *mut HeContentBlockImageCluster, image: *mut HeContentBlockImage);
pub fn he_content_block_image_cluster_new(title: *const c_char, subtitle: *const c_char, icon: *const c_char) -> *mut HeContentBlockImageCluster;
pub fn he_content_block_image_cluster_get_title(self_: *mut HeContentBlockImageCluster) -> *const c_char;
pub fn he_content_block_image_cluster_set_title(self_: *mut HeContentBlockImageCluster, value: *const c_char);
pub fn he_content_block_image_cluster_get_subtitle(self_: *mut HeContentBlockImageCluster) -> *const c_char;
pub fn he_content_block_image_cluster_set_subtitle(self_: *mut HeContentBlockImageCluster, value: *const c_char);
pub fn he_content_block_image_cluster_get_icon(self_: *mut HeContentBlockImageCluster) -> *const c_char;
pub fn he_content_block_image_cluster_set_icon(self_: *mut HeContentBlockImageCluster, value: *const c_char);
pub fn he_content_list_get_type() -> GType;
pub fn he_content_list_add(self_: *mut HeContentList, child: *mut gtk::GtkWidget);
pub fn he_content_list_remove(self_: *mut HeContentList, child: *mut gtk::GtkWidget);
pub fn he_content_list_new() -> *mut HeContentList;
pub fn he_content_list_get_title(self_: *mut HeContentList) -> *const c_char;
pub fn he_content_list_set_title(self_: *mut HeContentList, value: *const c_char);
pub fn he_content_list_get_description(self_: *mut HeContentList) -> *const c_char;
pub fn he_content_list_set_description(self_: *mut HeContentList, value: *const c_char);
pub fn he_content_scheme_get_type() -> GType;
pub fn he_content_scheme_new() -> *mut HeContentScheme;
pub fn he_date_picker_get_type() -> GType;
pub fn he_date_picker_new_with_format(format: *const c_char) -> *mut HeDatePicker;
pub fn he_date_picker_new() -> *mut HeDatePicker;
pub fn he_date_picker_get_format(self_: *mut HeDatePicker) -> *const c_char;
pub fn he_date_picker_get_date(self_: *mut HeDatePicker) -> *mut glib::GDateTime;
pub fn he_date_picker_set_date(self_: *mut HeDatePicker, value: *mut glib::GDateTime);
pub fn he_default_scheme_get_type() -> GType;
pub fn he_default_scheme_new() -> *mut HeDefaultScheme;
pub fn he_desktop_get_type() -> GType;
pub fn he_desktop_new() -> *mut HeDesktop;
pub fn he_desktop_get_prefers_color_scheme(self_: *mut HeDesktop) -> HeDesktopColorScheme;
pub fn he_desktop_set_prefers_color_scheme(self_: *mut HeDesktop, value: HeDesktopColorScheme);
pub fn he_desktop_get_ensor_scheme(self_: *mut HeDesktop) -> HeDesktopEnsorScheme;
pub fn he_desktop_get_accent_color(self_: *mut HeDesktop) -> *mut HeColorRGBColor;
pub fn he_desktop_set_accent_color(self_: *mut HeDesktop, value: *mut HeColorRGBColor);
pub fn he_desktop_get_font_weight(self_: *mut HeDesktop) -> c_double;
pub fn he_desktop_set_font_weight(self_: *mut HeDesktop, value: c_double);
pub fn he_desktop_get_roundness(self_: *mut HeDesktop) -> c_double;
pub fn he_desktop_set_roundness(self_: *mut HeDesktop, value: c_double);
pub fn he_desktop_get_contrast(self_: *mut HeDesktop) -> HeDesktopContrastScheme;
pub fn he_desktop_set_contrast(self_: *mut HeDesktop, value: HeDesktopContrastScheme);
pub fn he_dialog_get_type() -> GType;
pub fn he_dialog_add(self_: *mut HeDialog, widget: *mut gtk::GtkWidget);
pub fn he_dialog_new(modal: gboolean, parent: *mut gtk::GtkWindow, title: *const c_char, subtitle: *const c_char, info: *const c_char, icon: *const c_char, primary_button: *mut HeFillButton, secondary_button: *mut HeTintButton) -> *mut HeDialog;
pub fn he_dialog_get_title(self_: *mut HeDialog) -> *const c_char;
pub fn he_dialog_set_title(self_: *mut HeDialog, value: *const c_char);
pub fn he_dialog_get_info(self_: *mut HeDialog) -> *const c_char;
pub fn he_dialog_set_info(self_: *mut HeDialog, value: *const c_char);
pub fn he_dialog_get_icon(self_: *mut HeDialog) -> *const c_char;
pub fn he_dialog_set_icon(self_: *mut HeDialog, value: *const c_char);
pub fn he_dialog_get_secondary_button(self_: *mut HeDialog) -> *mut HeTintButton;
pub fn he_dialog_set_secondary_button(self_: *mut HeDialog, value: *mut HeTintButton);
pub fn he_dialog_get_primary_button(self_: *mut HeDialog) -> *mut HeFillButton;
pub fn he_dialog_set_primary_button(self_: *mut HeDialog, value: *mut HeFillButton);
pub fn he_disclosure_button_get_type() -> GType;
pub fn he_disclosure_button_new(icon: *const c_char) -> *mut HeDisclosureButton;
pub fn he_disclosure_button_new_from_icon(icon: *const c_char) -> *mut HeDisclosureButton;
pub fn he_disclosure_button_get_icon(self_: *mut HeDisclosureButton) -> *const c_char;
pub fn he_disclosure_button_set_icon(self_: *mut HeDisclosureButton, value: *const c_char);
pub fn he_divider_get_type() -> GType;
pub fn he_divider_new() -> *mut HeDivider;
pub fn he_divider_get_is_inset(self_: *mut HeDivider) -> gboolean;
pub fn he_divider_set_is_inset(self_: *mut HeDivider, value: gboolean);
pub fn he_empty_page_get_type() -> GType;
pub fn he_empty_page_new() -> *mut HeEmptyPage;
pub fn he_empty_page_get_title(self_: *mut HeEmptyPage) -> *const c_char;
pub fn he_empty_page_set_title(self_: *mut HeEmptyPage, value: *const c_char);
pub fn he_empty_page_get_description(self_: *mut HeEmptyPage) -> *const c_char;
pub fn he_empty_page_set_description(self_: *mut HeEmptyPage, value: *const c_char);
pub fn he_empty_page_get_icon(self_: *mut HeEmptyPage) -> *const c_char;
pub fn he_empty_page_set_icon(self_: *mut HeEmptyPage, value: *const c_char);
pub fn he_empty_page_set_resource(self_: *mut HeEmptyPage, value: *const c_char);
pub fn he_empty_page_get_button(self_: *mut HeEmptyPage) -> *const c_char;
pub fn he_empty_page_set_button(self_: *mut HeEmptyPage, value: *const c_char);
pub fn he_fill_button_get_type() -> GType;
pub fn he_fill_button_new(label: *const c_char) -> *mut HeFillButton;
pub fn he_iconic_button_get_type() -> GType;
pub fn he_iconic_button_new(icon: *const c_char) -> *mut HeIconicButton;
pub fn he_iconic_button_get_icon(self_: *mut HeIconicButton) -> *const c_char;
pub fn he_iconic_button_set_icon(self_: *mut HeIconicButton, value: *const c_char);
pub fn he_iconic_button_get_tooltip(self_: *mut HeIconicButton) -> *const c_char;
pub fn he_iconic_button_set_tooltip(self_: *mut HeIconicButton, value: *const c_char);
pub fn he_mini_content_block_get_type() -> GType;
pub fn he_mini_content_block_new_with_details(title: *const c_char, subtitle: *const c_char, primary_button: *mut HeButton) -> *mut HeMiniContentBlock;
pub fn he_mini_content_block_new() -> *mut HeMiniContentBlock;
pub fn he_mini_content_block_get_title(self_: *mut HeMiniContentBlock) -> *const c_char;
pub fn he_mini_content_block_set_title(self_: *mut HeMiniContentBlock, value: *const c_char);
pub fn he_mini_content_block_get_subtitle(self_: *mut HeMiniContentBlock) -> *const c_char;
pub fn he_mini_content_block_set_subtitle(self_: *mut HeMiniContentBlock, value: *const c_char);
pub fn he_mini_content_block_get_icon(self_: *mut HeMiniContentBlock) -> *const c_char;
pub fn he_mini_content_block_set_icon(self_: *mut HeMiniContentBlock, value: *const c_char);
pub fn he_mini_content_block_set_gicon(self_: *mut HeMiniContentBlock, value: *mut gio::GIcon);
pub fn he_mini_content_block_set_paintable(self_: *mut HeMiniContentBlock, value: *mut gdk::GdkPaintable);
pub fn he_mini_content_block_get_primary_button(self_: *mut HeMiniContentBlock) -> *mut HeButton;
pub fn he_mini_content_block_set_primary_button(self_: *mut HeMiniContentBlock, value: *mut HeButton);
pub fn he_modifier_badge_get_type() -> GType;
pub fn he_modifier_badge_new(label: *const c_char) -> *mut HeModifierBadge;
pub fn he_modifier_badge_get_color(self_: *mut HeModifierBadge) -> HeColors;
pub fn he_modifier_badge_set_color(self_: *mut HeModifierBadge, value: HeColors);
pub fn he_modifier_badge_get_tinted(self_: *mut HeModifierBadge) -> gboolean;
pub fn he_modifier_badge_set_tinted(self_: *mut HeModifierBadge, value: gboolean);
pub fn he_modifier_badge_get_label(self_: *mut HeModifierBadge) -> *const c_char;
pub fn he_modifier_badge_set_label(self_: *mut HeModifierBadge, value: *const c_char);
pub fn he_modifier_badge_get_alignment(self_: *mut HeModifierBadge) -> HeModifierBadgeAlignment;
pub fn he_modifier_badge_set_alignment(self_: *mut HeModifierBadge, value: HeModifierBadgeAlignment);
pub fn he_monochromatic_scheme_get_type() -> GType;
pub fn he_monochromatic_scheme_new() -> *mut HeMonochromaticScheme;
pub fn he_muted_scheme_get_type() -> GType;
pub fn he_muted_scheme_new() -> *mut HeMutedScheme;
pub fn he_navigation_rail_get_type() -> GType;
pub fn he_navigation_rail_new() -> *mut HeNavigationRail;
pub fn he_navigation_rail_get_stack(self_: *mut HeNavigationRail) -> *mut gtk::GtkStack;
pub fn he_navigation_rail_set_stack(self_: *mut HeNavigationRail, value: *mut gtk::GtkStack);
pub fn he_navigation_rail_get_orientation(self_: *mut HeNavigationRail) -> gtk::GtkOrientation;
pub fn he_navigation_rail_set_orientation(self_: *mut HeNavigationRail, value: gtk::GtkOrientation);
pub fn he_navigation_section_get_type() -> GType;
pub fn he_navigation_section_new() -> *mut HeNavigationSection;
pub fn he_navigation_section_get_stack(self_: *mut HeNavigationSection) -> *mut gtk::GtkStack;
pub fn he_navigation_section_set_stack(self_: *mut HeNavigationSection, value: *mut gtk::GtkStack);
pub fn he_navigation_section_get_orientation(self_: *mut HeNavigationSection) -> gtk::GtkOrientation;
pub fn he_navigation_section_set_orientation(self_: *mut HeNavigationSection, value: gtk::GtkOrientation);
pub fn he_outline_button_get_type() -> GType;
pub fn he_outline_button_new(label: *const c_char) -> *mut HeOutlineButton;
pub fn he_overlay_button_get_type() -> GType;
pub fn he_overlay_button_new(icon: *const c_char, label: *const c_char, secondary_icon: *const c_char) -> *mut HeOverlayButton;
pub fn he_overlay_button_get_size(self_: *mut HeOverlayButton) -> HeOverlayButtonSize;
pub fn he_overlay_button_set_size(self_: *mut HeOverlayButton, value: HeOverlayButtonSize);
pub fn he_overlay_button_get_typeb(self_: *mut HeOverlayButton) -> HeOverlayButtonTypeButton;
pub fn he_overlay_button_set_typeb(self_: *mut HeOverlayButton, value: HeOverlayButtonTypeButton);
pub fn he_overlay_button_get_typeb2(self_: *mut HeOverlayButton) -> HeOverlayButtonTypeButton;
pub fn he_overlay_button_set_typeb2(self_: *mut HeOverlayButton, value: HeOverlayButtonTypeButton);
pub fn he_overlay_button_get_color(self_: *mut HeOverlayButton) -> HeColors;
pub fn he_overlay_button_set_color(self_: *mut HeOverlayButton, value: HeColors);
pub fn he_overlay_button_get_secondary_color(self_: *mut HeOverlayButton) -> HeColors;
pub fn he_overlay_button_set_secondary_color(self_: *mut HeOverlayButton, value: HeColors);
pub fn he_overlay_button_get_secondary_icon(self_: *mut HeOverlayButton) -> *mut c_char;
pub fn he_overlay_button_set_secondary_icon(self_: *mut HeOverlayButton, value: *const c_char);
pub fn he_overlay_button_get_icon(self_: *mut HeOverlayButton) -> *mut c_char;
pub fn he_overlay_button_set_icon(self_: *mut HeOverlayButton, value: *const c_char);
pub fn he_overlay_button_get_label(self_: *mut HeOverlayButton) -> *const c_char;
pub fn he_overlay_button_set_label(self_: *mut HeOverlayButton, value: *const c_char);
pub fn he_overlay_button_get_primary_tooltip(self_: *mut HeOverlayButton) -> *mut c_char;
pub fn he_overlay_button_set_primary_tooltip(self_: *mut HeOverlayButton, value: *const c_char);
pub fn he_overlay_button_get_secondary_tooltip(self_: *mut HeOverlayButton) -> *mut c_char;
pub fn he_overlay_button_set_secondary_tooltip(self_: *mut HeOverlayButton, value: *const c_char);
pub fn he_overlay_button_get_child(self_: *mut HeOverlayButton) -> *mut gtk::GtkWidget;
pub fn he_overlay_button_set_child(self_: *mut HeOverlayButton, value: *mut gtk::GtkWidget);
pub fn he_overlay_button_get_alignment(self_: *mut HeOverlayButton) -> HeOverlayButtonAlignment;
pub fn he_overlay_button_set_alignment(self_: *mut HeOverlayButton, value: HeOverlayButtonAlignment);
pub fn he_pill_button_get_type() -> GType;
pub fn he_pill_button_new(label: *const c_char) -> *mut HePillButton;
pub fn he_progress_bar_get_type() -> GType;
pub fn he_progress_bar_new() -> *mut HeProgressBar;
pub fn he_progress_bar_get_stop_indicator_visibility(self_: *mut HeProgressBar) -> gboolean;
pub fn he_progress_bar_set_stop_indicator_visibility(self_: *mut HeProgressBar, value: gboolean);
pub fn he_progress_bar_get_is_osd(self_: *mut HeProgressBar) -> gboolean;
pub fn he_progress_bar_set_is_osd(self_: *mut HeProgressBar, value: gboolean);
pub fn he_quantizer_get_type() -> GType;
pub fn he_quantizer_quantize(self_: *mut HeQuantizer, pixels: *mut c_int, pixels_length1: c_int, max_colors: c_int) -> *mut HeQuantizerResult;
pub fn he_quantizer_celebi_get_type() -> GType;
pub fn he_quantizer_celebi_new() -> *mut HeQuantizerCelebi;
pub fn he_quantizer_celebi_quantize(self_: *mut HeQuantizerCelebi, pixels: *mut c_int, pixels_length1: c_int, max_colors: c_int) -> *mut glib::GHashTable;
pub fn he_quantizer_map_get_type() -> GType;
pub fn he_quantizer_map_get_color_to_count(self_: *mut HeQuantizerMap) -> *mut glib::GHashTable;
pub fn he_quantizer_map_new() -> *mut HeQuantizerMap;
pub fn he_quantizer_result_get_type() -> GType;
pub fn he_quantizer_result_new(color_to_count: *mut glib::GHashTable) -> *mut HeQuantizerResult;
pub fn he_quantizer_wsmeans_get_type() -> GType;
pub fn he_quantizer_wsmeans_quantize(input_pixels: *mut c_int, input_pixels_length1: c_int, starting_clusters: *mut c_int, starting_clusters_length1: c_int, max_colors: c_int) -> *mut glib::GHashTable;
pub fn he_quantizer_wu_get_type() -> GType;
pub fn he_quantizer_wu_new() -> *mut HeQuantizerWu;
pub fn he_salad_scheme_get_type() -> GType;
pub fn he_salad_scheme_new() -> *mut HeSaladScheme;
pub fn he_score_get_type() -> GType;
pub fn he_score_score(self_: *mut HeScore, colors_to_population: *mut glib::GHashTable, desired: *mut c_int) -> *mut glib::GArray;
pub fn he_score_new() -> *mut HeScore;
pub fn he_score_annotated_color_get_type() -> GType;
pub fn he_score_annotated_color_new() -> *mut HeScoreAnnotatedColor;
pub fn he_segmented_button_get_type() -> GType;
pub fn he_segmented_button_add_child(self_: *mut HeSegmentedButton, builder: *mut gtk::GtkBuilder, child: *mut gobject::GObject, type_: *const c_char);
pub fn he_segmented_button_new() -> *mut HeSegmentedButton;
pub fn he_settings_list_get_type() -> GType;
pub fn he_settings_list_add(self_: *mut HeSettingsList, child: *mut gtk::GtkWidget);
pub fn he_settings_list_remove(self_: *mut HeSettingsList, child: *mut gtk::GtkWidget);
pub fn he_settings_list_new() -> *mut HeSettingsList;
pub fn he_settings_list_get_title(self_: *mut HeSettingsList) -> *const c_char;
pub fn he_settings_list_set_title(self_: *mut HeSettingsList, value: *const c_char);
pub fn he_settings_list_get_description(self_: *mut HeSettingsList) -> *const c_char;
pub fn he_settings_list_set_description(self_: *mut HeSettingsList, value: *const c_char);
pub fn he_settings_page_get_type() -> GType;
pub fn he_settings_page_add_list(self_: *mut HeSettingsPage, list: *mut HeSettingsList);
pub fn he_settings_page_new(title: *const c_char) -> *mut HeSettingsPage;
pub fn he_settings_page_get_title(self_: *mut HeSettingsPage) -> *const c_char;
pub fn he_settings_page_set_title(self_: *mut HeSettingsPage, value: *const c_char);
pub fn he_settings_row_get_type() -> GType;
pub fn he_settings_row_add(self_: *mut HeSettingsRow, child: *mut gtk::GtkWidget);
pub fn he_settings_row_new_with_details(title: *const c_char, subtitle: *const c_char, primary_button: *mut HeButton) -> *mut HeSettingsRow;
pub fn he_settings_row_new() -> *mut HeSettingsRow;
pub fn he_settings_row_get_title(self_: *mut HeSettingsRow) -> *const c_char;
pub fn he_settings_row_set_title(self_: *mut HeSettingsRow, value: *const c_char);
pub fn he_settings_row_get_subtitle(self_: *mut HeSettingsRow) -> *const c_char;
pub fn he_settings_row_set_subtitle(self_: *mut HeSettingsRow, value: *const c_char);
pub fn he_settings_row_get_icon(self_: *mut HeSettingsRow) -> *const c_char;
pub fn he_settings_row_set_icon(self_: *mut HeSettingsRow, value: *const c_char);
pub fn he_settings_row_set_gicon(self_: *mut HeSettingsRow, value: *mut gio::GIcon);
pub fn he_settings_row_set_paintable(self_: *mut HeSettingsRow, value: *mut gdk::GdkPaintable);
pub fn he_settings_row_get_primary_button(self_: *mut HeSettingsRow) -> *mut HeButton;
pub fn he_settings_row_set_primary_button(self_: *mut HeSettingsRow, value: *mut HeButton);
pub fn he_settings_row_get_activatable_widget(self_: *mut HeSettingsRow) -> *mut gtk::GtkWidget;
pub fn he_settings_row_set_activatable_widget(self_: *mut HeSettingsRow, value: *mut gtk::GtkWidget);
pub fn he_settings_window_get_type() -> GType;
pub fn he_settings_window_add_page(self_: *mut HeSettingsWindow, page: *mut HeSettingsPage);
pub fn he_settings_window_add_list(self_: *mut HeSettingsWindow, list: *mut HeSettingsList);
pub fn he_settings_window_new(parent: *mut gtk::GtkWindow) -> *mut HeSettingsWindow;
pub fn he_side_bar_get_type() -> GType;
pub fn he_side_bar_new(title: *const c_char, subtitle: *const c_char) -> *mut HeSideBar;
pub fn he_side_bar_get_title(self_: *mut HeSideBar) -> *const c_char;
pub fn he_side_bar_set_title(self_: *mut HeSideBar, value: *const c_char);
pub fn he_side_bar_get_titlewidget(self_: *mut HeSideBar) -> *mut gtk::GtkWidget;
pub fn he_side_bar_set_titlewidget(self_: *mut HeSideBar, value: *mut gtk::GtkWidget);
pub fn he_side_bar_get_subtitle(self_: *mut HeSideBar) -> *const c_char;
pub fn he_side_bar_set_subtitle(self_: *mut HeSideBar, value: *const c_char);
pub fn he_side_bar_get_show_right_title_buttons(self_: *mut HeSideBar) -> gboolean;
pub fn he_side_bar_set_show_right_title_buttons(self_: *mut HeSideBar, value: gboolean);
pub fn he_side_bar_get_show_left_title_buttons(self_: *mut HeSideBar) -> gboolean;
pub fn he_side_bar_set_show_left_title_buttons(self_: *mut HeSideBar, value: gboolean);
pub fn he_side_bar_get_show_back(self_: *mut HeSideBar) -> gboolean;
pub fn he_side_bar_set_show_back(self_: *mut HeSideBar, value: gboolean);
pub fn he_side_bar_get_stack(self_: *mut HeSideBar) -> *mut gtk::GtkStack;
pub fn he_side_bar_set_stack(self_: *mut HeSideBar, value: *mut gtk::GtkStack);
pub fn he_side_bar_get_scroller(self_: *mut HeSideBar) -> *mut gtk::GtkScrolledWindow;
pub fn he_side_bar_set_scroller(self_: *mut HeSideBar, value: *mut gtk::GtkScrolledWindow);
pub fn he_side_bar_get_has_margins(self_: *mut HeSideBar) -> gboolean;
pub fn he_side_bar_set_has_margins(self_: *mut HeSideBar, value: gboolean);
pub fn he_slider_get_type() -> GType;
pub fn he_slider_new() -> *mut HeSlider;
pub fn he_slider_add_mark(self_: *mut HeSlider, value: c_double, text: *const c_char);
pub fn he_slider_get_left_icon(self_: *mut HeSlider) -> *const c_char;
pub fn he_slider_set_left_icon(self_: *mut HeSlider, value: *const c_char);
pub fn he_slider_get_right_icon(self_: *mut HeSlider) -> *const c_char;
pub fn he_slider_set_right_icon(self_: *mut HeSlider, value: *const c_char);
pub fn he_slider_get_stop_indicator_visibility(self_: *mut HeSlider) -> gboolean;
pub fn he_slider_set_stop_indicator_visibility(self_: *mut HeSlider, value: gboolean);
pub fn he_style_manager_get_type() -> GType;
pub fn he_style_manager_update(self_: *mut HeStyleManager);
pub fn he_style_manager_register(self_: *mut HeStyleManager);
pub fn he_style_manager_unregister(self_: *mut HeStyleManager);
pub fn he_style_manager_new() -> *mut HeStyleManager;
pub fn he_style_manager_get_is_registered(self_: *mut HeStyleManager) -> gboolean;
pub fn he_style_manager_get_user_base(self_: *mut HeStyleManager) -> *mut gtk::GtkCssProvider;
pub fn he_style_manager_get_user_dark(self_: *mut HeStyleManager) -> *mut gtk::GtkCssProvider;
pub fn he_switch_get_type() -> GType;
pub fn he_switch_new() -> *mut HeSwitch;
pub fn he_switch_get_left_icon(self_: *mut HeSwitch) -> *const c_char;
pub fn he_switch_set_left_icon(self_: *mut HeSwitch, value: *const c_char);
pub fn he_switch_get_right_icon(self_: *mut HeSwitch) -> *const c_char;
pub fn he_switch_set_right_icon(self_: *mut HeSwitch, value: *const c_char);
pub fn he_switch_bar_get_type() -> GType;
pub fn he_switch_bar_new() -> *mut HeSwitchBar;
pub fn he_switch_bar_get_title(self_: *mut HeSwitchBar) -> *const c_char;
pub fn he_switch_bar_set_title(self_: *mut HeSwitchBar, value: *const c_char);
pub fn he_switch_bar_get_subtitle(self_: *mut HeSwitchBar) -> *const c_char;
pub fn he_switch_bar_set_subtitle(self_: *mut HeSwitchBar, value: *const c_char);
pub fn he_switch_bar_get_sensitive_widget(self_: *mut HeSwitchBar) -> *mut gtk::GtkWidget;
pub fn he_switch_bar_set_sensitive_widget(self_: *mut HeSwitchBar, value: *mut gtk::GtkWidget);
pub fn he_tab_get_type() -> GType;
pub fn he_tab_new(label: *const c_char, page: *mut gtk::GtkWidget) -> *mut HeTab;
pub fn he_tab_get_label(self_: *mut HeTab) -> *const c_char;
pub fn he_tab_set_label(self_: *mut HeTab, value: *const c_char);
pub fn he_tab_set_tooltip(self_: *mut HeTab, value: *const c_char);
pub fn he_tab_get_pinned(self_: *mut HeTab) -> gboolean;
pub fn he_tab_set_pinned(self_: *mut HeTab, value: gboolean);
pub fn he_tab_get_can_pin(self_: *mut HeTab) -> gboolean;
pub fn he_tab_set_can_pin(self_: *mut HeTab, value: gboolean);
pub fn he_tab_get_can_close(self_: *mut HeTab) -> gboolean;
pub fn he_tab_set_can_close(self_: *mut HeTab, value: gboolean);
pub fn he_tab_get_page(self_: *mut HeTab) -> *mut gtk::GtkWidget;
pub fn he_tab_set_page(self_: *mut HeTab, value: *mut gtk::GtkWidget);
pub fn he_tab_get_menu(self_: *mut HeTab) -> *mut gio::GMenu;
pub fn he_tab_get_actions(self_: *mut HeTab) -> *mut gio::GSimpleActionGroup;
pub fn he_tab_page_get_type() -> GType;
pub fn he_tab_page_new(tab: *mut HeTab) -> *mut HeTabPage;
pub fn he_tab_page_get_tab(self_: *mut HeTabPage) -> *mut HeTab;
pub fn he_tab_page_set_tab(self_: *mut HeTabPage, value: *mut HeTab);
pub fn he_tab_switcher_get_type() -> GType;
pub fn he_tab_switcher_get_tab_position(self_: *mut HeTabSwitcher, tab: *mut HeTab) -> c_int;
pub fn he_tab_switcher_insert_tab(self_: *mut HeTabSwitcher, tab: *mut HeTab, index: c_int) -> c_uint;
pub fn he_tab_switcher_remove_tab(self_: *mut HeTabSwitcher, tab: *mut HeTab);
pub fn he_tab_switcher_new() -> *mut HeTabSwitcher;
pub fn he_tab_switcher_get_n_tabs(self_: *mut HeTabSwitcher) -> c_int;
pub fn he_tab_switcher_get_tabs(self_: *mut HeTabSwitcher) -> *mut glib::GList;
pub fn he_tab_switcher_get_tab_bar_behavior(self_: *mut HeTabSwitcher) -> HeTabSwitcherTabBarBehavior;
pub fn he_tab_switcher_set_tab_bar_behavior(self_: *mut HeTabSwitcher, value: HeTabSwitcherTabBarBehavior);
pub fn he_tab_switcher_get_allow_duplicate_tabs(self_: *mut HeTabSwitcher) -> gboolean;
pub fn he_tab_switcher_set_allow_duplicate_tabs(self_: *mut HeTabSwitcher, value: gboolean);
pub fn he_tab_switcher_get_allow_drag(self_: *mut HeTabSwitcher) -> gboolean;
pub fn he_tab_switcher_set_allow_drag(self_: *mut HeTabSwitcher, value: gboolean);
pub fn he_tab_switcher_get_allow_pinning(self_: *mut HeTabSwitcher) -> gboolean;
pub fn he_tab_switcher_set_allow_pinning(self_: *mut HeTabSwitcher, value: gboolean);
pub fn he_tab_switcher_get_allow_closing(self_: *mut HeTabSwitcher) -> gboolean;
pub fn he_tab_switcher_set_allow_closing(self_: *mut HeTabSwitcher, value: gboolean);
pub fn he_tab_switcher_get_allow_new_window(self_: *mut HeTabSwitcher) -> gboolean;
pub fn he_tab_switcher_set_allow_new_window(self_: *mut HeTabSwitcher, value: gboolean);
pub fn he_tab_switcher_get_current(self_: *mut HeTabSwitcher) -> *mut HeTab;
pub fn he_tab_switcher_set_current(self_: *mut HeTabSwitcher, value: *mut HeTab);
pub fn he_tab_switcher_get_menu(self_: *mut HeTabSwitcher) -> *mut gio::GMenu;
pub fn he_tab_switcher_get_actions(self_: *mut HeTabSwitcher) -> *mut gio::GSimpleActionGroup;
pub fn he_text_button_get_type() -> GType;
pub fn he_text_button_new(label: *const c_char) -> *mut HeTextButton;
pub fn he_text_button_new_from_icon(icon: *const c_char) -> *mut HeTextButton;
pub fn he_text_field_get_type() -> GType;
pub fn he_text_field_get_internal_entry(self_: *mut HeTextField) -> *mut gtk::GtkText;
pub fn he_text_field_new_from_regex(regex_arg: *mut glib::GRegex) -> *mut HeTextField;
pub fn he_text_field_new() -> *mut HeTextField;
pub fn he_text_field_get_is_valid(self_: *mut HeTextField) -> gboolean;
pub fn he_text_field_set_is_valid(self_: *mut HeTextField, value: gboolean);
pub fn he_text_field_get_needs_validation(self_: *mut HeTextField) -> gboolean;
pub fn he_text_field_set_needs_validation(self_: *mut HeTextField, value: gboolean);
pub fn he_text_field_get_min_length(self_: *mut HeTextField) -> c_int;
pub fn he_text_field_set_min_length(self_: *mut HeTextField, value: c_int);
pub fn he_text_field_get_regex(self_: *mut HeTextField) -> *mut glib::GRegex;
pub fn he_text_field_set_regex(self_: *mut HeTextField, value: *mut glib::GRegex);
pub fn he_text_field_get_is_search(self_: *mut HeTextField) -> gboolean;
pub fn he_text_field_set_is_search(self_: *mut HeTextField, value: gboolean);
pub fn he_text_field_get_is_outline(self_: *mut HeTextField) -> gboolean;
pub fn he_text_field_set_is_outline(self_: *mut HeTextField, value: gboolean);
pub fn he_text_field_get_entry(self_: *mut HeTextField) -> *mut gtk::GtkText;
pub fn he_text_field_get_text(self_: *mut HeTextField) -> *const c_char;
pub fn he_text_field_set_text(self_: *mut HeTextField, value: *const c_char);
pub fn he_text_field_get_suffix_icon(self_: *mut HeTextField) -> *const c_char;
pub fn he_text_field_set_suffix_icon(self_: *mut HeTextField, value: *const c_char);
pub fn he_text_field_get_prefix_icon(self_: *mut HeTextField) -> *const c_char;
pub fn he_text_field_set_prefix_icon(self_: *mut HeTextField, value: *const c_char);
pub fn he_text_field_get_support_text(self_: *mut HeTextField) -> *const c_char;
pub fn he_text_field_set_support_text(self_: *mut HeTextField, value: *const c_char);
pub fn he_text_field_get_placeholder_text(self_: *mut HeTextField) -> *const c_char;
pub fn he_text_field_set_placeholder_text(self_: *mut HeTextField, value: *const c_char);
pub fn he_text_field_get_max_length(self_: *mut HeTextField) -> c_int;
pub fn he_text_field_set_max_length(self_: *mut HeTextField, value: c_int);
pub fn he_text_field_get_visibility(self_: *mut HeTextField) -> gboolean;
pub fn he_text_field_set_visibility(self_: *mut HeTextField, value: gboolean);
pub fn he_time_picker_get_type() -> GType;
pub fn he_time_picker_new_with_format(format_12: *const c_char, format_24: *const c_char) -> *mut HeTimePicker;
pub fn he_time_picker_new() -> *mut HeTimePicker;
pub fn he_time_picker_get_format_12(self_: *mut HeTimePicker) -> *const c_char;
pub fn he_time_picker_get_format_24(self_: *mut HeTimePicker) -> *const c_char;
pub fn he_time_picker_get_time(self_: *mut HeTimePicker) -> *mut glib::GDateTime;
pub fn he_time_picker_set_time(self_: *mut HeTimePicker, value: *mut glib::GDateTime);
pub fn he_tint_button_get_type() -> GType;
pub fn he_tint_button_new(label: *const c_char) -> *mut HeTintButton;
pub fn he_tint_button_new_from_icon(icon: *const c_char) -> *mut HeTintButton;
pub fn he_toast_get_type() -> GType;
pub fn he_toast_new(label: *const c_char) -> *mut HeToast;
pub fn he_toast_send_notification(self_: *mut HeToast);
pub fn he_toast_get_label(self_: *mut HeToast) -> *const c_char;
pub fn he_toast_set_label(self_: *mut HeToast, value: *const c_char);
pub fn he_toast_get_default_action(self_: *mut HeToast) -> *const c_char;
pub fn he_toast_set_default_action(self_: *mut HeToast, value: *const c_char);
pub fn he_vibrant_scheme_get_type() -> GType;
pub fn he_vibrant_scheme_new() -> *mut HeVibrantScheme;
pub fn he_view_get_type() -> GType;
pub fn he_view_add_child(self_: *mut HeView, builder: *mut gtk::GtkBuilder, child: *mut gobject::GObject, type_: *const c_char);
pub fn he_view_add(self_: *mut HeView, widget: *mut gtk::GtkWidget);
pub fn he_view_get_title(self_: *mut HeView) -> *const c_char;
pub fn he_view_set_title(self_: *mut HeView, value: *const c_char);
pub fn he_view_get_stack(self_: *mut HeView) -> *mut gtk::GtkStack;
pub fn he_view_set_stack(self_: *mut HeView, value: *mut gtk::GtkStack);
pub fn he_view_get_subtitle(self_: *mut HeView) -> *const c_char;
pub fn he_view_set_subtitle(self_: *mut HeView, value: *const c_char);
pub fn he_view_get_has_margins(self_: *mut HeView) -> gboolean;
pub fn he_view_set_has_margins(self_: *mut HeView, value: gboolean);
pub fn he_view_aux_get_type() -> GType;
pub fn he_view_aux_new() -> *mut HeViewAux;
pub fn he_view_aux_get_show_aux(self_: *mut HeViewAux) -> gboolean;
pub fn he_view_aux_set_show_aux(self_: *mut HeViewAux, value: gboolean);
pub fn he_view_chooser_get_type() -> GType;
pub fn he_view_chooser_new() -> *mut HeViewChooser;
pub fn he_view_chooser_stack_clear(self_: *mut HeViewChooser);
pub fn he_view_chooser_get_stack(self_: *mut HeViewChooser) -> *mut gtk::GtkStack;
pub fn he_view_chooser_set_stack(self_: *mut HeViewChooser, value: *mut gtk::GtkStack);
pub fn he_view_dual_get_type() -> GType;
pub fn he_view_dual_new() -> *mut HeViewDual;
pub fn he_view_mono_get_type() -> GType;
pub fn he_view_mono_new() -> *mut HeViewMono;
pub fn he_view_sub_title_get_type() -> GType;
pub fn he_view_sub_title_new() -> *mut HeViewSubTitle;
pub fn he_view_sub_title_get_label(self_: *mut HeViewSubTitle) -> *const c_char;
pub fn he_view_sub_title_set_label(self_: *mut HeViewSubTitle, value: *const c_char);
pub fn he_view_switcher_get_type() -> GType;
pub fn he_view_switcher_new() -> *mut HeViewSwitcher;
pub fn he_view_switcher_get_stack(self_: *mut HeViewSwitcher) -> *mut gtk::GtkStack;
pub fn he_view_switcher_set_stack(self_: *mut HeViewSwitcher, value: *mut gtk::GtkStack);
pub fn he_view_title_get_type() -> GType;
pub fn he_view_title_new() -> *mut HeViewTitle;
pub fn he_view_title_get_label(self_: *mut HeViewTitle) -> *const c_char;
pub fn he_view_title_set_label(self_: *mut HeViewTitle, value: *const c_char);
pub fn he_viewing_conditions_get_type() -> GType;
pub fn he_viewing_conditions_lerp(start: c_double, stop: c_double, amount: c_double) -> c_double;
pub fn he_viewing_conditions_make(white_point: *mut c_double, white_point_length1: c_int, adapting_luminance: c_double, bg_lstar: c_double, surround: c_double, discount_illuminant: gboolean) -> *mut HeViewingConditions;
pub fn he_viewing_conditions_with_lstar(lstar: c_double) -> *mut HeViewingConditions;
pub fn he_viewing_conditions_get_aw(self_: *mut HeViewingConditions) -> c_double;
pub fn he_viewing_conditions_set_aw(self_: *mut HeViewingConditions, value: c_double);
pub fn he_viewing_conditions_get_nbb(self_: *mut HeViewingConditions) -> c_double;
pub fn he_viewing_conditions_set_nbb(self_: *mut HeViewingConditions, value: c_double);
pub fn he_viewing_conditions_get_ncb(self_: *mut HeViewingConditions) -> c_double;
pub fn he_viewing_conditions_set_ncb(self_: *mut HeViewingConditions, value: c_double);
pub fn he_viewing_conditions_get_c(self_: *mut HeViewingConditions) -> c_double;
pub fn he_viewing_conditions_set_c(self_: *mut HeViewingConditions, value: c_double);
pub fn he_viewing_conditions_get_nc(self_: *mut HeViewingConditions) -> c_double;
pub fn he_viewing_conditions_set_nc(self_: *mut HeViewingConditions, value: c_double);
pub fn he_viewing_conditions_get_n(self_: *mut HeViewingConditions) -> c_double;
pub fn he_viewing_conditions_set_n(self_: *mut HeViewingConditions, value: c_double);
pub fn he_viewing_conditions_get_fl(self_: *mut HeViewingConditions) -> c_double;
pub fn he_viewing_conditions_set_fl(self_: *mut HeViewingConditions, value: c_double);
pub fn he_viewing_conditions_get_fl_root(self_: *mut HeViewingConditions) -> c_double;
pub fn he_viewing_conditions_set_fl_root(self_: *mut HeViewingConditions, value: c_double);
pub fn he_viewing_conditions_get_z(self_: *mut HeViewingConditions) -> c_double;
pub fn he_viewing_conditions_set_z(self_: *mut HeViewingConditions, value: c_double);
pub fn he_welcome_screen_get_type() -> GType;
pub fn he_welcome_screen_add_child(self_: *mut HeWelcomeScreen, builder: *mut gtk::GtkBuilder, child: *mut gobject::GObject, type_: *const c_char);
pub fn he_welcome_screen_new(appname: *const c_char, description: *const c_char) -> *mut HeWelcomeScreen;
pub fn he_welcome_screen_get_appname(self_: *mut HeWelcomeScreen) -> *const c_char;
pub fn he_welcome_screen_set_appname(self_: *mut HeWelcomeScreen, value: *const c_char);
pub fn he_welcome_screen_get_description(self_: *mut HeWelcomeScreen) -> *const c_char;
pub fn he_welcome_screen_set_description(self_: *mut HeWelcomeScreen, value: *const c_char);
pub fn he_window_get_type() -> GType;
pub fn he_window_new() -> *mut HeWindow;
pub fn he_window_get_parent(self_: *mut HeWindow) -> *mut gtk::GtkWindow;
pub fn he_window_set_parent(self_: *mut HeWindow, value: *mut gtk::GtkWindow);
pub fn he_window_get_has_title(self_: *mut HeWindow) -> gboolean;
pub fn he_window_set_has_title(self_: *mut HeWindow, value: gboolean);
pub fn he_window_get_has_back_button(self_: *mut HeWindow) -> gboolean;
pub fn he_window_set_has_back_button(self_: *mut HeWindow, value: gboolean);
pub fn he_scheme_factory_get_type() -> GType;
pub fn he_scheme_factory_generate(self_: *mut HeSchemeFactory, accent: *mut HeColorCAM16Color, is_dark: gboolean, is_contrast: gboolean, result: *mut HeScheme);
pub fn he_color_rgb_to_argb_int(color: *mut HeColorRGBColor) -> c_int;
pub fn he_color_lab_to_argb_int(lab: *mut HeColorLABColor) -> c_int;
pub fn he_color_argb_from_rgb_int(red: c_int, green: c_int, blue: c_int) -> c_int;
pub fn he_color_xyz_to_argb(xyz: *mut HeColorXYZColor) -> c_int;
pub fn he_color_argb_to_rgb(argb: c_int, result_length1: *mut c_int) -> *mut c_double;
pub fn he_color_alpha_from_rgba_int(argb: c_int) -> c_int;
pub fn he_color_red_from_rgba_int(argb: c_int) -> c_int;
pub fn he_color_green_from_rgba_int(argb: c_int) -> c_int;
pub fn he_color_blue_from_rgba_int(argb: c_int) -> c_int;
pub fn he_color_xyz_to_cam16(color: *mut HeColorXYZColor, result: *mut HeColorCAM16Color);
pub fn he_color_cam16_from_int(argb: c_int, result: *mut HeColorCAM16Color);
pub fn he_color_to_gdk_rgba(color: *mut HeColorRGBColor, result: *mut gdk::GdkRGBA);
pub fn he_color_critical_plane_below(x: c_double) -> c_int;
pub fn he_color_critical_plane_above(x: c_double) -> c_int;
pub fn he_color_from_params(hue: c_double, chroma: c_double, tone: c_double, result: *mut HeColorHCTColor);
pub fn he_color_disliked(hct: *mut HeColorHCTColor) -> gboolean;
pub fn he_color_fix_disliked(hct: *mut HeColorHCTColor, result: *mut HeColorHCTColor);
pub fn he_color_hct_to_hex(hue: c_double, chroma: c_double, lstar: c_double) -> *mut c_char;
pub fn he_color_hct_to_argb(hue: c_double, chroma: c_double, lstar: c_double) -> c_int;
pub fn he_color_hct_blend(a: *mut HeColorHCTColor, b: *mut HeColorHCTColor, result: *mut HeColorHCTColor);
pub fn he_color_get_rotated_hue(hue: c_double, hues: *mut c_double, hues_length1: c_int, rotations: *mut c_double, rotations_length1: c_int) -> c_double;
pub fn he_color_rgb_from_linrgb(red: c_int, green: c_int, blue: c_int) -> c_int;
pub fn he_color_argb_from_linrgb(linrgb: *mut c_double, linrgb_length1: c_int) -> c_int;
pub fn he_color_find_result_by_j(hr: c_double, c: c_double, y: c_double) -> c_int;
pub fn he_color_hexcode(r: c_double, g: c_double, b: c_double) -> *mut c_char;
pub fn he_color_hexcode_argb(color: c_int) -> *mut c_char;
pub fn he_color_xyz_value_to_lab(v: c_double) -> c_double;
pub fn he_color_xyz_to_lab(color: *mut HeColorXYZColor, result: *mut HeColorLABColor);
pub fn he_color_lch_to_lab(color: *mut HeColorLCHColor, result: *mut HeColorLABColor);
pub fn he_color_rgb_to_lab(color: *mut HeColorRGBColor, result: *mut HeColorLABColor);
pub fn he_color_lab_from_argb(argb: c_int, result: *mut HeColorLABColor);
pub fn he_color_rgb_to_lch(color: *mut HeColorRGBColor, result: *mut HeColorLCHColor);
pub fn he_color_lab_to_lch(color: *mut HeColorLABColor, result: *mut HeColorLCHColor);
pub fn he_color_hct_to_lch(color: *mut HeColorHCTColor, result: *mut HeColorLCHColor);
pub fn he_color_xyz_to_rgb(color: *mut HeColorXYZColor, result: *mut HeColorRGBColor);
pub fn he_color_lab_to_rgb(color: *mut HeColorLABColor, result: *mut HeColorRGBColor);
pub fn he_color_lch_to_rgb(color: *mut HeColorLCHColor, result: *mut HeColorRGBColor);
pub fn he_color_from_gdk_rgba(color: *mut gdk::GdkRGBA, result: *mut HeColorRGBColor);
pub fn he_color_from_hex(color: *const c_char, result: *mut HeColorRGBColor);
pub fn he_color_from_argb_int(argb: c_int, result: *mut HeColorRGBColor);
pub fn he_color_argb_to_xyz(argb: c_int, result: *mut HeColorXYZColor);
pub fn he_color_rgb_value_to_xyz(v: c_double) -> c_double;
pub fn he_color_rgb_to_xyz(color: *mut HeColorRGBColor, result: *mut HeColorXYZColor);
pub fn he_color_cam16_to_xyz(color: *mut HeColorCAM16Color, result: *mut HeColorXYZColor);
pub fn he_color_lab_to_xyz(color: *mut HeColorLABColor, result: *mut HeColorXYZColor);
pub fn he_ensor_accent_from_pixels_async(pixels: *mut u8, pixels_length1: c_int, alpha: gboolean, _callback_: gio::GAsyncReadyCallback, _callback__target: *mut c_void);
pub fn he_ensor_accent_from_pixels_finish(_res_: *mut gio::GAsyncResult) -> *mut glib::GArray;
pub fn he_math_utils_clamp_double(min: c_double, max: c_double, input: c_double) -> c_double;
pub fn he_math_utils_signum(x: c_double) -> c_int;
pub fn he_math_utils_chromatic_adaptation(component: c_double) -> c_double;
pub fn he_math_utils_inverse_chromatic_adaptation(adapted: c_double) -> c_double;
pub fn he_math_utils_lerp_point(source: *mut c_double, source_length1: c_int, t: c_double, target: *mut c_double, target_length1: c_int, result_length1: *mut c_int) -> *mut c_double;
pub fn he_math_utils_lerp(a: c_double, b: c_double, t: c_double) -> c_double;
pub fn he_math_utils_sanitize_radians(angle: c_double) -> c_double;
pub fn he_math_utils_is_bounded_rgb(x: c_double) -> gboolean;
pub fn he_math_utils_adapt(color_channel: c_double) -> c_double;
pub fn he_math_utils_elem_mul(row: *mut c_double, row_length1: c_int, matrix: *mut c_double, matrix_length1: c_int, matrix_length2: c_int, result_length1: *mut c_int) -> *mut c_double;
pub fn he_math_utils_lab_inverse_fovea(ft: c_double) -> c_double;
pub fn he_math_utils_lab_fovea(t: c_double) -> c_double;
pub fn he_math_utils_sanitize_degrees(degrees: c_double) -> c_double;
pub fn he_math_utils_sanitize_degrees_int(degrees: c_int) -> c_int;
pub fn he_math_utils_rotate_direction(from: c_double, to: c_double) -> c_double;
pub fn he_math_utils_difference_degrees(a: c_double, b: c_double) -> c_double;
pub fn he_math_utils_abs(n: c_double) -> c_double;
pub fn he_math_utils_max(n: c_double, m: c_double) -> c_double;
pub fn he_math_utils_min(n: c_double, m: c_double) -> c_double;
pub fn he_math_utils_linearized(rgb_component: c_int) -> c_double;
pub fn he_math_utils_delinearized(rgb_component: c_double) -> c_int;
pub fn he_math_utils_double_delinearized(rgb_component: c_double) -> c_double;
pub fn he_math_utils_midpoint(a: *mut c_double, a_length1: c_int, b: *mut c_double, b_length1: c_int, result_length1: *mut c_int) -> *mut c_double;
pub fn he_math_utils_intercept(source: c_double, mid: c_double, target: c_double) -> c_double;
pub fn he_math_utils_hue_of(linrgb: *mut c_double, linrgb_length1: c_int) -> c_double;
pub fn he_math_utils_nth_vertex(y: c_double, n: c_int, result_length1: *mut c_int) -> *mut c_double;
pub fn he_math_utils_are_in_cyclic_order(a: c_double, b: c_double, c: c_double) -> gboolean;
pub fn he_math_utils_set_coordinate(source: *mut c_double, source_length1: c_int, coordinate: c_double, target: *mut c_double, target_length1: c_int, axis: c_int, result_length1: *mut c_int) -> *mut c_double;
pub fn he_math_utils_convert(value: c_double) -> c_double;
pub fn he_math_utils_bisect_to_segment(y: c_double, target_hue: c_double, result_length1: *mut c_int) -> *mut c_double;
pub fn he_math_utils_bisect_to_limit(y: c_double, target_hue: c_double, result_length1: *mut c_int) -> *mut c_double;
pub fn he_math_utils_y_from_lstar(lstar: c_double) -> c_double;
pub fn he_math_utils_argb_from_lstar(lstar: c_double) -> c_int;
pub fn he_math_utils_lstar_from_argb(argb: c_int) -> c_double;
pub fn he_misc_find_ancestor_of_type(t_type: GType, t_dup_func: gobject::GBoxedCopyFunc, t_destroy_func: glib::GDestroyNotify, widget: *mut gtk::GtkWidget) -> gpointer;
pub fn he_misc_contrast_ratio(red: c_double, green: c_double, blue: c_double, red2: c_double, green2: c_double, blue2: c_double) -> c_double;
pub fn he_misc_fix_fg_contrast(red: c_double, green: c_double, blue: c_double, red2: c_double, green2: c_double, blue2: c_double, result_length1: *mut c_int) -> *mut c_double;
pub fn he_misc_accel_label(accel: *const c_char) -> *mut c_char;
pub fn he_misc_accel_string(accels: *mut *mut c_char, accels_length1: c_int, description: *const c_char) -> *mut c_char;
pub fn he_colors_to_css_class(self_: HeColors) -> *mut c_char;
pub fn he_colors_to_string(self_: HeColors) -> *mut c_char;
pub fn he_desktop_ensor_scheme_to_factory(self_: HeDesktopEnsorScheme) -> *mut HeSchemeFactory;
pub fn he_about_window_licenses_get_url(self_: HeAboutWindowLicenses) -> *mut c_char;
pub fn he_about_window_licenses_get_name(self_: HeAboutWindowLicenses) -> *mut c_char;
pub fn he_content_block_image_cluster_image_position_get_column(self_: HeContentBlockImageClusterImagePosition) -> c_int;
pub fn he_content_block_image_cluster_image_position_get_row(self_: HeContentBlockImageClusterImagePosition) -> c_int;
pub fn he_modifier_badge_alignment_to_gtk_align(self_: HeModifierBadgeAlignment) -> gtk::GtkAlign;
pub fn he_modifier_badge_alignment_from_gtk_align(align: gtk::GtkAlign) -> HeModifierBadgeAlignment;
pub fn he_overlay_button_size_to_css_class(self_: HeOverlayButtonSize) -> *mut c_char;
pub fn he_overlay_button_type_button_to_css_class(self_: HeOverlayButtonTypeButton) -> *mut c_char;
pub fn he_overlay_button_alignment_to_gtk_align(self_: HeOverlayButtonAlignment) -> gtk::GtkAlign;
pub fn he_overlay_button_alignment_from_gtk_align(align: gtk::GtkAlign) -> HeOverlayButtonAlignment;
pub fn he_init();
}