#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
clippy::approx_constant,
clippy::type_complexity,
clippy::unreadable_literal,
clippy::upper_case_acronyms
)]
#![cfg_attr(feature = "dox", feature(doc_cfg))]
#[allow(unused_imports)]
use libc::{
c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
intptr_t, size_t, ssize_t, uintptr_t, FILE,
};
#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};
pub type DzlAnimationMode = c_int;
pub const DZL_ANIMATION_LINEAR: DzlAnimationMode = 0;
pub const DZL_ANIMATION_EASE_IN_QUAD: DzlAnimationMode = 1;
pub const DZL_ANIMATION_EASE_IN_OUT_QUAD: DzlAnimationMode = 3;
pub const DZL_ANIMATION_EASE_OUT_QUAD: DzlAnimationMode = 2;
pub const DZL_ANIMATION_EASE_IN_CUBIC: DzlAnimationMode = 4;
pub const DZL_ANIMATION_EASE_OUT_CUBIC: DzlAnimationMode = 5;
pub const DZL_ANIMATION_EASE_IN_OUT_CUBIC: DzlAnimationMode = 6;
pub type DzlDockRevealerTransitionType = c_int;
pub const DZL_DOCK_REVEALER_TRANSITION_TYPE_NONE: DzlDockRevealerTransitionType = 0;
pub const DZL_DOCK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT: DzlDockRevealerTransitionType = 1;
pub const DZL_DOCK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT: DzlDockRevealerTransitionType = 2;
pub const DZL_DOCK_REVEALER_TRANSITION_TYPE_SLIDE_UP: DzlDockRevealerTransitionType = 3;
pub const DZL_DOCK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN: DzlDockRevealerTransitionType = 4;
pub type DzlShortcutMatch = c_int;
pub const DZL_SHORTCUT_MATCH_NONE: DzlShortcutMatch = 0;
pub const DZL_SHORTCUT_MATCH_EQUAL: DzlShortcutMatch = 1;
pub const DZL_SHORTCUT_MATCH_PARTIAL: DzlShortcutMatch = 2;
pub type DzlShortcutType = c_int;
pub const DZL_SHORTCUT_ACCELERATOR: DzlShortcutType = 0;
pub const DZL_SHORTCUT_GESTURE_PINCH: DzlShortcutType = 1;
pub const DZL_SHORTCUT_GESTURE_STRETCH: DzlShortcutType = 2;
pub const DZL_SHORTCUT_GESTURE_ROTATE_CLOCKWISE: DzlShortcutType = 3;
pub const DZL_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE: DzlShortcutType = 4;
pub const DZL_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT: DzlShortcutType = 5;
pub const DZL_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT: DzlShortcutType = 6;
pub const DZL_SHORTCUT_GESTURE: DzlShortcutType = 7;
pub type DzlSliderPosition = c_int;
pub const DZL_SLIDER_NONE: DzlSliderPosition = 0;
pub const DZL_SLIDER_TOP: DzlSliderPosition = 1;
pub const DZL_SLIDER_RIGHT: DzlSliderPosition = 2;
pub const DZL_SLIDER_BOTTOM: DzlSliderPosition = 3;
pub const DZL_SLIDER_LEFT: DzlSliderPosition = 4;
pub type DzlThreeGridColumn = c_int;
pub const DZL_THREE_GRID_COLUMN_LEFT: DzlThreeGridColumn = 0;
pub const DZL_THREE_GRID_COLUMN_CENTER: DzlThreeGridColumn = 1;
pub const DZL_THREE_GRID_COLUMN_RIGHT: DzlThreeGridColumn = 2;
pub type DzlTreeDropPosition = c_int;
pub const DZL_TREE_DROP_INTO: DzlTreeDropPosition = 0;
pub const DZL_TREE_DROP_BEFORE: DzlTreeDropPosition = 1;
pub const DZL_TREE_DROP_AFTER: DzlTreeDropPosition = 2;
pub const DZL_DOCK_BIN_STYLE_CLASS_PINNED: *const c_char =
b"pinned\0" as *const u8 as *const c_char;
pub type DzlFileTransferFlags = c_uint;
pub const DZL_FILE_TRANSFER_FLAGS_NONE: DzlFileTransferFlags = 0;
pub const DZL_FILE_TRANSFER_FLAGS_MOVE: DzlFileTransferFlags = 1;
pub type DzlPropertiesFlags = c_uint;
pub const DZL_PROPERTIES_FLAGS_NONE: DzlPropertiesFlags = 0;
pub const DZL_PROPERTIES_FLAGS_STATEFUL_BOOLEANS: DzlPropertiesFlags = 1;
pub type DzlShortcutPhase = c_uint;
pub const DZL_SHORTCUT_PHASE_DISPATCH: DzlShortcutPhase = 0;
pub const DZL_SHORTCUT_PHASE_CAPTURE: DzlShortcutPhase = 1;
pub const DZL_SHORTCUT_PHASE_BUBBLE: DzlShortcutPhase = 2;
pub const DZL_SHORTCUT_PHASE_GLOBAL: DzlShortcutPhase = 4;
pub type DzlTabStyle = c_uint;
pub const DZL_TAB_ICONS: DzlTabStyle = 2;
pub const DZL_TAB_TEXT: DzlTabStyle = 1;
pub const DZL_TAB_BOTH: DzlTabStyle = 3;
pub type DzlCounterForeachFunc = Option<unsafe extern "C" fn(*mut DzlCounter, gpointer)>;
pub type DzlDirectoryModelVisibleFunc = Option<
unsafe extern "C" fn(
*mut DzlDirectoryModel,
*mut gio::GFile,
*mut gio::GFileInfo,
gpointer,
) -> gboolean,
>;
pub type DzlListModelFilterFunc =
Option<unsafe extern "C" fn(*mut gobject::GObject, gpointer) -> gboolean>;
pub type DzlRecursiveIgnoreFunc =
Option<unsafe extern "C" fn(*mut gio::GFile, gpointer) -> gboolean>;
pub type DzlShortcutChordTableForeach =
Option<unsafe extern "C" fn(*const DzlShortcutChord, gpointer, gpointer)>;
pub type DzlStackListCreateWidgetFunc =
Option<unsafe extern "C" fn(*mut gobject::GObject, gpointer) -> *mut gtk::GtkWidget>;
pub type DzlSuggestionPositionFunc = Option<
unsafe extern "C" fn(*mut DzlSuggestionEntry, *mut gdk::GdkRectangle, *mut gboolean, gpointer),
>;
pub type DzlTaskCacheCallback =
Option<unsafe extern "C" fn(*mut DzlTaskCache, gconstpointer, *mut gio::GTask, gpointer)>;
pub type DzlTreeFilterFunc =
Option<unsafe extern "C" fn(*mut DzlTree, *mut DzlTreeNode, gpointer) -> gboolean>;
pub type DzlTreeFindFunc = Option<
unsafe extern "C" fn(*mut DzlTree, *mut DzlTreeNode, *mut DzlTreeNode, gpointer) -> gboolean,
>;
pub type DzlTreeNodeCompareFunc =
Option<unsafe extern "C" fn(*mut DzlTreeNode, *mut DzlTreeNode, gpointer) -> c_int>;
pub type DzlTrieTraverseFunc =
Option<unsafe extern "C" fn(*mut DzlTrie, *const c_char, gpointer, gpointer) -> gboolean>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlAnimationClass {
pub parent_class: gobject::GInitiallyUnownedClass,
}
impl ::std::fmt::Debug for DzlAnimationClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlAnimationClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlApplicationClass {
pub parent_class: gtk::GtkApplicationClass,
pub add_resources: Option<unsafe extern "C" fn(*mut DzlApplication, *const c_char)>,
pub remove_resources: Option<unsafe extern "C" fn(*mut DzlApplication, *const c_char)>,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlApplicationClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlApplicationClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("add_resources", &self.add_resources)
.field("remove_resources", &self.remove_resources)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlApplicationWindowClass {
pub parent_class: gtk::GtkApplicationWindowClass,
pub get_fullscreen: Option<unsafe extern "C" fn(*mut DzlApplicationWindow) -> gboolean>,
pub set_fullscreen: Option<unsafe extern "C" fn(*mut DzlApplicationWindow, gboolean)>,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlApplicationWindowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlApplicationWindowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("get_fullscreen", &self.get_fullscreen)
.field("set_fullscreen", &self.set_fullscreen)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlBinClass {
pub parent_class: gtk::GtkBinClass,
}
impl ::std::fmt::Debug for DzlBinClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlBinClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlBindingGroupClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlBindingGroupClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlBindingGroupClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlBoldingLabelClass {
pub parent_class: gtk::GtkLabelClass,
}
impl ::std::fmt::Debug for DzlBoldingLabelClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlBoldingLabelClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlBoxClass {
pub parent_class: gtk::GtkBoxClass,
}
impl ::std::fmt::Debug for DzlBoxClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlBoxClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlBoxTheatricClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlBoxTheatricClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlBoxTheatricClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlCenteringBinClass {
pub parent: gtk::GtkBinClass,
}
impl ::std::fmt::Debug for DzlCenteringBinClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlCenteringBinClass @ {:p}", self))
.field("parent", &self.parent)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlChildPropertyActionClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlChildPropertyActionClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlChildPropertyActionClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlColumnLayoutClass {
pub parent: gtk::GtkContainerClass,
}
impl ::std::fmt::Debug for DzlColumnLayoutClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlColumnLayoutClass @ {:p}", self))
.field("parent", &self.parent)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlCounter {
pub values: *mut DzlCounterValue,
pub category: *const c_char,
pub name: *const c_char,
pub description: *const c_char,
}
impl ::std::fmt::Debug for DzlCounter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlCounter @ {:p}", self))
.field("values", &self.values)
.field("category", &self.category)
.field("name", &self.name)
.field("description", &self.description)
.finish()
}
}
#[repr(C)]
pub struct DzlCounterArena {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlCounterArena {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlCounterArena @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlCounterValue {
pub value: i64,
pub padding: [i64; 7],
}
impl ::std::fmt::Debug for DzlCounterValue {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlCounterValue @ {:p}", self))
.field("padding", &self.padding)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlCountersWindowClass {
pub parent_class: gtk::GtkWindowClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
}
impl ::std::fmt::Debug for DzlCountersWindowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlCountersWindowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlCpuGraphClass {
pub parent_class: DzlGraphViewClass,
}
impl ::std::fmt::Debug for DzlCpuGraphClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlCpuGraphClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlCpuModelClass {
pub parent_class: DzlGraphModelClass,
}
impl ::std::fmt::Debug for DzlCpuModelClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlCpuModelClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlCssProviderClass {
pub parent_class: gtk::GtkCssProviderClass,
}
impl ::std::fmt::Debug for DzlCssProviderClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlCssProviderClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDirectoryModelClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlDirectoryModelClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDirectoryModelClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDirectoryReaperClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlDirectoryReaperClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDirectoryReaperClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockBinClass {
pub parent: gtk::GtkContainerClass,
pub create_edge:
Option<unsafe extern "C" fn(*mut DzlDockBin, gtk::GtkPositionType) -> *mut gtk::GtkWidget>,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlDockBinClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockBinClass @ {:p}", self))
.field("parent", &self.parent)
.field("create_edge", &self.create_edge)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockBinEdgeClass {
pub parent: DzlDockRevealerClass,
pub move_to_bin_child: Option<unsafe extern "C" fn(*mut DzlDockBinEdge)>,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlDockBinEdgeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockBinEdgeClass @ {:p}", self))
.field("parent", &self.parent)
.field("move_to_bin_child", &self.move_to_bin_child)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockInterface {
pub parent: gobject::GTypeInterface,
}
impl ::std::fmt::Debug for DzlDockInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockInterface @ {:p}", self))
.field("parent", &self.parent)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockItemInterface {
pub parent: gobject::GTypeInterface,
pub set_manager: Option<unsafe extern "C" fn(*mut DzlDockItem, *mut DzlDockManager)>,
pub get_manager: Option<unsafe extern "C" fn(*mut DzlDockItem) -> *mut DzlDockManager>,
pub manager_set: Option<unsafe extern "C" fn(*mut DzlDockItem, *mut DzlDockManager)>,
pub present_child: Option<unsafe extern "C" fn(*mut DzlDockItem, *mut DzlDockItem)>,
pub update_visibility: Option<unsafe extern "C" fn(*mut DzlDockItem)>,
pub get_child_visible:
Option<unsafe extern "C" fn(*mut DzlDockItem, *mut DzlDockItem) -> gboolean>,
pub set_child_visible:
Option<unsafe extern "C" fn(*mut DzlDockItem, *mut DzlDockItem, gboolean)>,
pub get_title: Option<unsafe extern "C" fn(*mut DzlDockItem) -> *mut c_char>,
pub get_icon_name: Option<unsafe extern "C" fn(*mut DzlDockItem) -> *mut c_char>,
pub get_can_close: Option<unsafe extern "C" fn(*mut DzlDockItem) -> gboolean>,
pub can_minimize: Option<unsafe extern "C" fn(*mut DzlDockItem, *mut DzlDockItem) -> gboolean>,
pub close: Option<unsafe extern "C" fn(*mut DzlDockItem) -> gboolean>,
pub minimize: Option<
unsafe extern "C" fn(
*mut DzlDockItem,
*mut DzlDockItem,
*mut gtk::GtkPositionType,
) -> gboolean,
>,
pub release: Option<unsafe extern "C" fn(*mut DzlDockItem, *mut DzlDockItem)>,
pub presented: Option<unsafe extern "C" fn(*mut DzlDockItem)>,
pub ref_gicon: Option<unsafe extern "C" fn(*mut DzlDockItem) -> *mut gio::GIcon>,
pub needs_attention: Option<unsafe extern "C" fn(*mut DzlDockItem)>,
}
impl ::std::fmt::Debug for DzlDockItemInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockItemInterface @ {:p}", self))
.field("parent", &self.parent)
.field("set_manager", &self.set_manager)
.field("get_manager", &self.get_manager)
.field("manager_set", &self.manager_set)
.field("present_child", &self.present_child)
.field("update_visibility", &self.update_visibility)
.field("get_child_visible", &self.get_child_visible)
.field("set_child_visible", &self.set_child_visible)
.field("get_title", &self.get_title)
.field("get_icon_name", &self.get_icon_name)
.field("get_can_close", &self.get_can_close)
.field("can_minimize", &self.can_minimize)
.field("close", &self.close)
.field("minimize", &self.minimize)
.field("release", &self.release)
.field("presented", &self.presented)
.field("ref_gicon", &self.ref_gicon)
.field("needs_attention", &self.needs_attention)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockManagerClass {
pub parent: gobject::GObjectClass,
pub register_dock: Option<unsafe extern "C" fn(*mut DzlDockManager, *mut DzlDock)>,
pub unregister_dock: Option<unsafe extern "C" fn(*mut DzlDockManager, *mut DzlDock)>,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlDockManagerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockManagerClass @ {:p}", self))
.field("parent", &self.parent)
.field("register_dock", &self.register_dock)
.field("unregister_dock", &self.unregister_dock)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockOverlayClass {
pub parent: gtk::GtkEventBoxClass,
pub hide_edges: Option<unsafe extern "C" fn(*mut DzlDockOverlay)>,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlDockOverlayClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockOverlayClass @ {:p}", self))
.field("parent", &self.parent)
.field("hide_edges", &self.hide_edges)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockOverlayEdgeClass {
pub parent_class: DzlBinClass,
}
impl ::std::fmt::Debug for DzlDockOverlayEdgeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockOverlayEdgeClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockPanedClass {
pub parent: DzlMultiPanedClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlDockPanedClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockPanedClass @ {:p}", self))
.field("parent", &self.parent)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockRevealerClass {
pub parent: DzlBinClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlDockRevealerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockRevealerClass @ {:p}", self))
.field("parent", &self.parent)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockStackClass {
pub parent: gtk::GtkBoxClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
}
impl ::std::fmt::Debug for DzlDockStackClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockStackClass @ {:p}", self))
.field("parent", &self.parent)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockTransientGrabClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlDockTransientGrabClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockTransientGrabClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockWidgetClass {
pub parent: DzlBinClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlDockWidgetClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockWidgetClass @ {:p}", self))
.field("parent", &self.parent)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockWindowClass {
pub parent: gtk::GtkWindowClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlDockWindowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockWindowClass @ {:p}", self))
.field("parent", &self.parent)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlElasticBinClass {
pub parent_class: gtk::GtkBinClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
}
impl ::std::fmt::Debug for DzlElasticBinClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlElasticBinClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlEmptyStateClass {
pub parent_class: gtk::GtkBinClass,
}
impl ::std::fmt::Debug for DzlEmptyStateClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlEmptyStateClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlEntryBoxClass {
pub parent_class: gtk::GtkBoxClass,
}
impl ::std::fmt::Debug for DzlEntryBoxClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlEntryBoxClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlFileChooserEntryClass {
pub parent_class: gtk::GtkBinClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
}
impl ::std::fmt::Debug for DzlFileChooserEntryClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlFileChooserEntryClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlFileTransferClass {
pub parent_class: gobject::GObjectClass,
pub _padding: [gpointer; 12],
}
impl ::std::fmt::Debug for DzlFileTransferClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlFileTransferClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlFileTransferStat {
pub n_files_total: i64,
pub n_files: i64,
pub n_dirs_total: i64,
pub n_dirs: i64,
pub n_bytes_total: i64,
pub n_bytes: i64,
pub _padding: [i64; 10],
}
impl ::std::fmt::Debug for DzlFileTransferStat {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlFileTransferStat @ {:p}", self))
.field("n_files_total", &self.n_files_total)
.field("n_files", &self.n_files)
.field("n_dirs_total", &self.n_dirs_total)
.field("n_dirs", &self.n_dirs)
.field("n_bytes_total", &self.n_bytes_total)
.field("n_bytes", &self.n_bytes)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlFuzzyIndexBuilderClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlFuzzyIndexBuilderClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlFuzzyIndexBuilderClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlFuzzyIndexClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlFuzzyIndexClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlFuzzyIndexClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlFuzzyIndexCursorClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlFuzzyIndexCursorClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlFuzzyIndexCursorClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlFuzzyIndexMatchClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlFuzzyIndexMatchClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlFuzzyIndexMatchClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct DzlFuzzyMutableIndex {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlFuzzyMutableIndex {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlFuzzyMutableIndex @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlFuzzyMutableIndexMatch {
pub key: *const c_char,
pub value: gpointer,
pub score: c_float,
pub id: c_uint,
}
impl ::std::fmt::Debug for DzlFuzzyMutableIndexMatch {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlFuzzyMutableIndexMatch @ {:p}", self))
.field("key", &self.key)
.field("value", &self.value)
.field("score", &self.score)
.field("id", &self.id)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlGraphColumnClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlGraphColumnClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlGraphColumnClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlGraphLineRendererClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlGraphLineRendererClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlGraphLineRendererClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlGraphModelClass {
pub parent: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlGraphModelClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlGraphModelClass @ {:p}", self))
.field("parent", &self.parent)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlGraphModelIter {
pub data: [gpointer; 8],
}
impl ::std::fmt::Debug for DzlGraphModelIter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlGraphModelIter @ {:p}", self))
.field("data", &self.data)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlGraphRendererInterface {
pub parent: gobject::GTypeInterface,
pub render: Option<
unsafe extern "C" fn(
*mut DzlGraphRenderer,
*mut DzlGraphModel,
i64,
i64,
c_double,
c_double,
*mut cairo::cairo_t,
*const cairo::cairo_rectangle_int_t,
),
>,
}
impl ::std::fmt::Debug for DzlGraphRendererInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlGraphRendererInterface @ {:p}", self))
.field("parent", &self.parent)
.field("render", &self.render)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlGraphViewClass {
pub parent_class: gtk::GtkDrawingAreaClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlGraphViewClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlGraphViewClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlHeap {
pub data: *mut c_char,
pub len: size_t,
}
impl ::std::fmt::Debug for DzlHeap {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlHeap @ {:p}", self))
.field("data", &self.data)
.field("len", &self.len)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlJoinedMenuClass {
pub parent_class: gio::GMenuModelClass,
}
impl ::std::fmt::Debug for DzlJoinedMenuClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlJoinedMenuClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlListBoxClass {
pub parent_class: gtk::GtkListBoxClass,
pub _reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for DzlListBoxClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlListBoxClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlListBoxRowClass {
pub parent_class: gtk::GtkListBoxRowClass,
}
impl ::std::fmt::Debug for DzlListBoxRowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlListBoxRowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlListModelFilterClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlListModelFilterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlListModelFilterClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlListStoreAdapterClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlListStoreAdapterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlListStoreAdapterClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlMenuButtonClass {
pub parent_class: gtk::GtkMenuButtonClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
}
impl ::std::fmt::Debug for DzlMenuButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlMenuButtonClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlMenuManagerClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlMenuManagerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlMenuManagerClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlMultiPanedClass {
pub parent: gtk::GtkContainerClass,
pub resize_drag_begin: Option<unsafe extern "C" fn(*mut DzlMultiPaned, *mut gtk::GtkWidget)>,
pub resize_drag_end: Option<unsafe extern "C" fn(*mut DzlMultiPaned, *mut gtk::GtkWidget)>,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlMultiPanedClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlMultiPanedClass @ {:p}", self))
.field("parent", &self.parent)
.field("resize_drag_begin", &self.resize_drag_begin)
.field("resize_drag_end", &self.resize_drag_end)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPathBarClass {
pub parent_class: gtk::GtkBoxClass,
}
impl ::std::fmt::Debug for DzlPathBarClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPathBarClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPathClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlPathClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPathClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPathElementClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlPathElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPathElementClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct DzlPatternSpec {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlPatternSpec {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPatternSpec @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPillBoxClass {
pub parent_class: gtk::GtkEventBoxClass,
}
impl ::std::fmt::Debug for DzlPillBoxClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPillBoxClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPreferencesBinClass {
pub parent_class: gtk::GtkBinClass,
pub connect: Option<unsafe extern "C" fn(*mut DzlPreferencesBin, *mut gio::GSettings)>,
pub disconnect: Option<unsafe extern "C" fn(*mut DzlPreferencesBin, *mut gio::GSettings)>,
pub matches:
Option<unsafe extern "C" fn(*mut DzlPreferencesBin, *mut DzlPatternSpec) -> gboolean>,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlPreferencesBinClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesBinClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("connect", &self.connect)
.field("disconnect", &self.disconnect)
.field("matches", &self.matches)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPreferencesEntryClass {
pub parent_class: DzlPreferencesBinClass,
}
impl ::std::fmt::Debug for DzlPreferencesEntryClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesEntryClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPreferencesFileChooserButtonClass {
pub parent_class: DzlPreferencesBinClass,
}
impl ::std::fmt::Debug for DzlPreferencesFileChooserButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"DzlPreferencesFileChooserButtonClass @ {:p}",
self
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPreferencesFlowBoxClass {
pub parent_class: DzlColumnLayoutClass,
}
impl ::std::fmt::Debug for DzlPreferencesFlowBoxClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesFlowBoxClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPreferencesFontButtonClass {
pub parent_class: DzlPreferencesBinClass,
}
impl ::std::fmt::Debug for DzlPreferencesFontButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesFontButtonClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPreferencesGroupClass {
pub parent_class: gtk::GtkBinClass,
}
impl ::std::fmt::Debug for DzlPreferencesGroupClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesGroupClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct DzlPreferencesInterface {
pub parent_interface: gobject::GTypeInterface,
pub set_page:
Option<unsafe extern "C" fn(*mut DzlPreferences, *const c_char, *mut glib::GHashTable)>,
pub add_page:
Option<unsafe extern "C" fn(*mut DzlPreferences, *const c_char, *const c_char, c_int)>,
pub add_group: Option<
unsafe extern "C" fn(
*mut DzlPreferences,
*const c_char,
*const c_char,
*const c_char,
c_int,
),
>,
pub add_list_group: Option<
unsafe extern "C" fn(
*mut DzlPreferences,
*const c_char,
*const c_char,
*const c_char,
gtk::GtkSelectionMode,
c_int,
),
>,
pub add_radio: Option<
unsafe extern "C" fn(
*mut DzlPreferences,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
c_int,
) -> c_uint,
>,
pub add_font_button: Option<
unsafe extern "C" fn(
*mut DzlPreferences,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
c_int,
) -> c_uint,
>,
pub add_switch: Option<
unsafe extern "C" fn(
*mut DzlPreferences,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
c_int,
) -> c_uint,
>,
pub add_spin_button: Option<
unsafe extern "C" fn(
*mut DzlPreferences,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
c_int,
) -> c_uint,
>,
pub add_file_chooser: Option<
unsafe extern "C" fn(
*mut DzlPreferences,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
*const c_char,
gtk::GtkFileChooserAction,
*const c_char,
c_int,
) -> c_uint,
>,
pub add_custom: Option<
unsafe extern "C" fn(
*mut DzlPreferences,
*const c_char,
*const c_char,
*mut gtk::GtkWidget,
*const c_char,
c_int,
) -> c_uint,
>,
pub remove_id: Option<unsafe extern "C" fn(*mut DzlPreferences, c_uint) -> gboolean>,
pub get_widget:
Option<unsafe extern "C" fn(*mut DzlPreferences, c_uint) -> *mut gtk::GtkWidget>,
_truncated_record_marker: c_void,
}
impl ::std::fmt::Debug for DzlPreferencesInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesInterface @ {:p}", self))
.field("parent_interface", &self.parent_interface)
.field("set_page", &self.set_page)
.field("add_page", &self.add_page)
.field("add_group", &self.add_group)
.field("add_list_group", &self.add_list_group)
.field("add_radio", &self.add_radio)
.field("add_font_button", &self.add_font_button)
.field("add_switch", &self.add_switch)
.field("add_spin_button", &self.add_spin_button)
.field("add_file_chooser", &self.add_file_chooser)
.field("add_custom", &self.add_custom)
.field("remove_id", &self.remove_id)
.field("get_widget", &self.get_widget)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPreferencesPageClass {
pub parent_class: gtk::GtkBinClass,
}
impl ::std::fmt::Debug for DzlPreferencesPageClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesPageClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPreferencesSpinButtonClass {
pub parent_class: DzlPreferencesBinClass,
}
impl ::std::fmt::Debug for DzlPreferencesSpinButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesSpinButtonClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPreferencesSwitchClass {
pub parent_class: DzlPreferencesBinClass,
}
impl ::std::fmt::Debug for DzlPreferencesSwitchClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesSwitchClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPreferencesViewClass {
pub parent_class: gtk::GtkBinClass,
pub _reserved: [gpointer; 8],
}
impl ::std::fmt::Debug for DzlPreferencesViewClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesViewClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPriorityBoxClass {
pub parent_class: gtk::GtkBoxClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
}
impl ::std::fmt::Debug for DzlPriorityBoxClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPriorityBoxClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlProgressButtonClass {
pub parent_class: gtk::GtkButtonClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
}
impl ::std::fmt::Debug for DzlProgressButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlProgressButtonClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlProgressIconClass {
pub parent_class: gtk::GtkDrawingAreaClass,
}
impl ::std::fmt::Debug for DzlProgressIconClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlProgressIconClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlProgressMenuButtonClass {
pub parent_class: gtk::GtkMenuButtonClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
}
impl ::std::fmt::Debug for DzlProgressMenuButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlProgressMenuButtonClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPropertiesGroupClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlPropertiesGroupClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPropertiesGroupClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlRadioBoxClass {
pub parent_class: gtk::GtkBinClass,
pub _padding1: gpointer,
pub _padding2: gpointer,
pub _padding3: gpointer,
pub _padding4: gpointer,
}
impl ::std::fmt::Debug for DzlRadioBoxClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlRadioBoxClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("_padding1", &self._padding1)
.field("_padding2", &self._padding2)
.field("_padding3", &self._padding3)
.field("_padding4", &self._padding4)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlReadOnlyListModelClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlReadOnlyListModelClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlReadOnlyListModelClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlRecursiveFileMonitorClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlRecursiveFileMonitorClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlRecursiveFileMonitorClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlRing {
pub data: *mut u8,
pub len: c_uint,
pub pos: c_uint,
}
impl ::std::fmt::Debug for DzlRing {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlRing @ {:p}", self))
.field("data", &self.data)
.field("len", &self.len)
.field("pos", &self.pos)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlScrolledWindowClass {
pub parent_class: gtk::GtkScrolledWindowClass,
}
impl ::std::fmt::Debug for DzlScrolledWindowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlScrolledWindowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSearchBarClass {
pub parent_class: gtk::GtkBinClass,
}
impl ::std::fmt::Debug for DzlSearchBarClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSearchBarClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSettingsFlagActionClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlSettingsFlagActionClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSettingsFlagActionClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSettingsSandwichClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlSettingsSandwichClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSettingsSandwichClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutAccelDialogClass {
pub parent_class: gtk::GtkDialogClass,
}
impl ::std::fmt::Debug for DzlShortcutAccelDialogClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutAccelDialogClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct DzlShortcutChord {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlShortcutChord {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutChord @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct _DzlShortcutChordTable {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type DzlShortcutChordTable = *mut _DzlShortcutChordTable;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutContextClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlShortcutContextClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutContextClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutControllerClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlShortcutControllerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutControllerClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutEntry {
pub command: *const c_char,
pub phase: DzlShortcutPhase,
pub default_accel: *const c_char,
pub section: *const c_char,
pub group: *const c_char,
pub title: *const c_char,
pub subtitle: *const c_char,
}
impl ::std::fmt::Debug for DzlShortcutEntry {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutEntry @ {:p}", self))
.field("command", &self.command)
.field("phase", &self.phase)
.field("default_accel", &self.default_accel)
.field("section", &self.section)
.field("group", &self.group)
.field("title", &self.title)
.field("subtitle", &self.subtitle)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutLabelClass {
pub parent_class: gtk::GtkBoxClass,
}
impl ::std::fmt::Debug for DzlShortcutLabelClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutLabelClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutManagerClass {
pub parent_instance: gobject::GObjectClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlShortcutManagerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutManagerClass @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutModelClass {
pub parent_class: gtk::GtkTreeStoreClass,
}
impl ::std::fmt::Debug for DzlShortcutModelClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutModelClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutSimpleLabelClass {
pub parent_class: gtk::GtkBoxClass,
}
impl ::std::fmt::Debug for DzlShortcutSimpleLabelClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutSimpleLabelClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutThemeClass {
pub parent_class: gobject::GObjectClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlShortcutThemeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutThemeClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutThemeEditorClass {
pub parent_class: gtk::GtkBinClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlShortcutThemeEditorClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutThemeEditorClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutTooltipClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlShortcutTooltipClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutTooltipClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _DzlShortcutsGroupClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type DzlShortcutsGroupClass = *mut _DzlShortcutsGroupClass;
#[repr(C)]
pub struct _DzlShortcutsSectionClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type DzlShortcutsSectionClass = *mut _DzlShortcutsSectionClass;
#[repr(C)]
pub struct _DzlShortcutsShortcutClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type DzlShortcutsShortcutClass = *mut _DzlShortcutsShortcutClass;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutsWindowClass {
pub parent_class: gtk::GtkWindowClass,
pub close: Option<unsafe extern "C" fn(*mut DzlShortcutsWindow)>,
pub search: Option<unsafe extern "C" fn(*mut DzlShortcutsWindow)>,
}
impl ::std::fmt::Debug for DzlShortcutsWindowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutsWindowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("close", &self.close)
.field("search", &self.search)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSignalGroupClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlSignalGroupClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSignalGroupClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSimpleLabelClass {
pub parent_class: gtk::GtkWidgetClass,
}
impl ::std::fmt::Debug for DzlSimpleLabelClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSimpleLabelClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSimplePopoverClass {
pub parent: gtk::GtkPopoverClass,
pub activate: Option<unsafe extern "C" fn(*mut DzlSimplePopover, *const c_char)>,
pub insert_text: Option<
unsafe extern "C" fn(*mut DzlSimplePopover, c_uint, *const c_char, c_uint) -> gboolean,
>,
pub changed: Option<unsafe extern "C" fn(*mut DzlSimplePopover)>,
}
impl ::std::fmt::Debug for DzlSimplePopoverClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSimplePopoverClass @ {:p}", self))
.field("parent", &self.parent)
.field("activate", &self.activate)
.field("insert_text", &self.insert_text)
.field("changed", &self.changed)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSliderClass {
pub parent_instance: gtk::GtkContainerClass,
}
impl ::std::fmt::Debug for DzlSliderClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSliderClass @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlStackListClass {
pub parent_instance: gtk::GtkBinClass,
pub row_activated: Option<unsafe extern "C" fn(*mut DzlStackList, *mut gtk::GtkListBoxRow)>,
pub header_activated: Option<unsafe extern "C" fn(*mut DzlStackList, *mut gtk::GtkListBoxRow)>,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlStackListClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlStackListClass @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.field("row_activated", &self.row_activated)
.field("header_activated", &self.header_activated)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlStateMachineClass {
pub parent: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlStateMachineClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlStateMachineClass @ {:p}", self))
.field("parent", &self.parent)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestionButtonClass {
pub parent_class: gtk::GtkStackClass,
pub _reserved: [gpointer; 8],
}
impl ::std::fmt::Debug for DzlSuggestionButtonClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSuggestionButtonClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestionClass {
pub parent_class: gobject::GObjectClass,
pub suggest_suffix:
Option<unsafe extern "C" fn(*mut DzlSuggestion, *const c_char) -> *mut c_char>,
pub replace_typed_text:
Option<unsafe extern "C" fn(*mut DzlSuggestion, *const c_char) -> *mut c_char>,
pub get_icon: Option<unsafe extern "C" fn(*mut DzlSuggestion) -> *mut gio::GIcon>,
pub get_icon_surface: Option<
unsafe extern "C" fn(
*mut DzlSuggestion,
*mut gtk::GtkWidget,
) -> *mut cairo::cairo_surface_t,
>,
pub get_secondary_icon: Option<unsafe extern "C" fn(*mut DzlSuggestion) -> *mut gio::GIcon>,
pub get_secondary_icon_surface: Option<
unsafe extern "C" fn(
*mut DzlSuggestion,
*mut gtk::GtkWidget,
) -> *mut cairo::cairo_surface_t,
>,
}
impl ::std::fmt::Debug for DzlSuggestionClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSuggestionClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("suggest_suffix", &self.suggest_suffix)
.field("replace_typed_text", &self.replace_typed_text)
.field("get_icon", &self.get_icon)
.field("get_icon_surface", &self.get_icon_surface)
.field("get_secondary_icon", &self.get_secondary_icon)
.field(
"get_secondary_icon_surface",
&self.get_secondary_icon_surface,
)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestionEntryBufferClass {
pub parent_class: gtk::GtkEntryBufferClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
}
impl ::std::fmt::Debug for DzlSuggestionEntryBufferClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSuggestionEntryBufferClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestionEntryClass {
pub parent_class: gtk::GtkEntryClass,
pub hide_suggestions: Option<unsafe extern "C" fn(*mut DzlSuggestionEntry)>,
pub show_suggestions: Option<unsafe extern "C" fn(*mut DzlSuggestionEntry)>,
pub move_suggestion: Option<unsafe extern "C" fn(*mut DzlSuggestionEntry, c_int)>,
pub suggestion_activated:
Option<unsafe extern "C" fn(*mut DzlSuggestionEntry, *mut DzlSuggestion)>,
pub suggestion_selected:
Option<unsafe extern "C" fn(*mut DzlSuggestionEntry, *mut DzlSuggestion)>,
pub _reserved: [gpointer; 7],
}
impl ::std::fmt::Debug for DzlSuggestionEntryClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSuggestionEntryClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("hide_suggestions", &self.hide_suggestions)
.field("show_suggestions", &self.show_suggestions)
.field("move_suggestion", &self.move_suggestion)
.field("suggestion_activated", &self.suggestion_activated)
.field("suggestion_selected", &self.suggestion_selected)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestionPopoverClass {
pub parent_class: gtk::GtkWindowClass,
}
impl ::std::fmt::Debug for DzlSuggestionPopoverClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSuggestionPopoverClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestionRowClass {
pub parent_class: DzlListBoxRowClass,
pub _reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for DzlSuggestionRowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSuggestionRowClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlTabClass {
pub parent_class: DzlBinClass,
}
impl ::std::fmt::Debug for DzlTabClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlTabClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlTabStripClass {
pub parent: gtk::GtkBoxClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlTabStripClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlTabStripClass @ {:p}", self))
.field("parent", &self.parent)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlTaskCacheClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlTaskCacheClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlTaskCacheClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlThemeManagerClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlThemeManagerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlThemeManagerClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlThreeGridClass {
pub parent_class: gtk::GtkContainerClass,
pub _reserved1: gpointer,
pub _reserved2: gpointer,
pub _reserved3: gpointer,
pub _reserved4: gpointer,
pub _reserved5: gpointer,
pub _reserved6: gpointer,
pub _reserved7: gpointer,
pub _reserved8: gpointer,
}
impl ::std::fmt::Debug for DzlThreeGridClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlThreeGridClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("_reserved1", &self._reserved1)
.field("_reserved2", &self._reserved2)
.field("_reserved3", &self._reserved3)
.field("_reserved4", &self._reserved4)
.field("_reserved5", &self._reserved5)
.field("_reserved6", &self._reserved6)
.field("_reserved7", &self._reserved7)
.field("_reserved8", &self._reserved8)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlTreeBuilderClass {
pub parent_class: gobject::GInitiallyUnownedClass,
pub added: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut gtk::GtkWidget)>,
pub removed: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut gtk::GtkWidget)>,
pub build_node: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode)>,
pub build_children: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode)>,
pub node_activated:
Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode) -> gboolean>,
pub node_selected: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode)>,
pub node_unselected: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode)>,
pub node_popup:
Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode, *mut gio::GMenu)>,
pub node_expanded: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode)>,
pub node_collapsed: Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode)>,
pub node_draggable:
Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode) -> gboolean>,
pub node_droppable: Option<
unsafe extern "C" fn(
*mut DzlTreeBuilder,
*mut DzlTreeNode,
*mut gtk::GtkSelectionData,
) -> gboolean,
>,
pub drag_data_get: Option<
unsafe extern "C" fn(
*mut DzlTreeBuilder,
*mut DzlTreeNode,
*mut gtk::GtkSelectionData,
) -> gboolean,
>,
pub drag_node_received: Option<
unsafe extern "C" fn(
*mut DzlTreeBuilder,
*mut DzlTreeNode,
*mut DzlTreeNode,
DzlTreeDropPosition,
gdk::GdkDragAction,
*mut gtk::GtkSelectionData,
) -> gboolean,
>,
pub drag_data_received: Option<
unsafe extern "C" fn(
*mut DzlTreeBuilder,
*mut DzlTreeNode,
DzlTreeDropPosition,
gdk::GdkDragAction,
*mut gtk::GtkSelectionData,
) -> gboolean,
>,
pub drag_node_delete:
Option<unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode) -> gboolean>,
pub cell_data_func: Option<
unsafe extern "C" fn(*mut DzlTreeBuilder, *mut DzlTreeNode, *mut gtk::GtkCellRenderer),
>,
pub _padding: [gpointer; 11],
}
impl ::std::fmt::Debug for DzlTreeBuilderClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlTreeBuilderClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("added", &self.added)
.field("removed", &self.removed)
.field("build_node", &self.build_node)
.field("build_children", &self.build_children)
.field("node_activated", &self.node_activated)
.field("node_selected", &self.node_selected)
.field("node_unselected", &self.node_unselected)
.field("node_popup", &self.node_popup)
.field("node_expanded", &self.node_expanded)
.field("node_collapsed", &self.node_collapsed)
.field("node_draggable", &self.node_draggable)
.field("node_droppable", &self.node_droppable)
.field("drag_data_get", &self.drag_data_get)
.field("drag_node_received", &self.drag_node_received)
.field("drag_data_received", &self.drag_data_received)
.field("drag_node_delete", &self.drag_node_delete)
.field("cell_data_func", &self.cell_data_func)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlTreeClass {
pub parent_class: gtk::GtkTreeViewClass,
pub action:
Option<unsafe extern "C" fn(*mut DzlTree, *const c_char, *const c_char, *const c_char)>,
pub populate_popup: Option<unsafe extern "C" fn(*mut DzlTree, *mut gtk::GtkWidget)>,
pub _padding: [gpointer; 12],
}
impl ::std::fmt::Debug for DzlTreeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlTreeClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.field("action", &self.action)
.field("populate_popup", &self.populate_popup)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlTreeNodeClass {
pub parent_class: gobject::GInitiallyUnownedClass,
}
impl ::std::fmt::Debug for DzlTreeNodeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlTreeNodeClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct DzlTrie {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlTrie {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlTrie @ {:p}", self)).finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlWidgetActionGroupClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for DzlWidgetActionGroupClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlWidgetActionGroupClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct DzlAnimation {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlAnimation {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlAnimation @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlApplication {
pub parent_instance: gtk::GtkApplication,
}
impl ::std::fmt::Debug for DzlApplication {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlApplication @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlApplicationWindow {
pub parent_instance: gtk::GtkApplicationWindow,
}
impl ::std::fmt::Debug for DzlApplicationWindow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlApplicationWindow @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlBin {
pub parent_instance: gtk::GtkBin,
}
impl ::std::fmt::Debug for DzlBin {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlBin @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlBindingGroup {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlBindingGroup {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlBindingGroup @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlBoldingLabel {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlBoldingLabel {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlBoldingLabel @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlBox {
pub parent_instance: gtk::GtkBox,
}
impl ::std::fmt::Debug for DzlBox {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlBox @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlBoxTheatric {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlBoxTheatric {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlBoxTheatric @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlCenteringBin {
pub parent_instance: gtk::GtkBin,
}
impl ::std::fmt::Debug for DzlCenteringBin {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlCenteringBin @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlChildPropertyAction {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlChildPropertyAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlChildPropertyAction @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlColumnLayout {
pub parent_instance: gtk::GtkContainer,
}
impl ::std::fmt::Debug for DzlColumnLayout {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlColumnLayout @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlCountersWindow {
pub parent_instance: gtk::GtkWindow,
}
impl ::std::fmt::Debug for DzlCountersWindow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlCountersWindow @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlCpuGraph {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlCpuGraph {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlCpuGraph @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlCpuModel {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlCpuModel {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlCpuModel @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlCssProvider {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlCssProvider {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlCssProvider @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlDirectoryModel {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlDirectoryModel {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDirectoryModel @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlDirectoryReaper {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlDirectoryReaper {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDirectoryReaper @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockBin {
pub parent_instance: gtk::GtkContainer,
}
impl ::std::fmt::Debug for DzlDockBin {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockBin @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockBinEdge {
pub parent_instance: DzlDockRevealer,
}
impl ::std::fmt::Debug for DzlDockBinEdge {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockBinEdge @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockManager {
pub parent_instance: gobject::GObject,
}
impl ::std::fmt::Debug for DzlDockManager {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockManager @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockOverlay {
pub parent_instance: gtk::GtkEventBox,
}
impl ::std::fmt::Debug for DzlDockOverlay {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockOverlay @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlDockOverlayEdge {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlDockOverlayEdge {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockOverlayEdge @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockPaned {
pub parent_instance: DzlMultiPaned,
}
impl ::std::fmt::Debug for DzlDockPaned {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockPaned @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockRevealer {
pub parent_instance: DzlBin,
}
impl ::std::fmt::Debug for DzlDockRevealer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockRevealer @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockStack {
pub parent_instance: gtk::GtkBox,
}
impl ::std::fmt::Debug for DzlDockStack {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockStack @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlDockTransientGrab {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlDockTransientGrab {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockTransientGrab @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockWidget {
pub parent_instance: DzlBin,
}
impl ::std::fmt::Debug for DzlDockWidget {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockWidget @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlDockWindow {
pub parent_instance: gtk::GtkWindow,
}
impl ::std::fmt::Debug for DzlDockWindow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlDockWindow @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlElasticBin {
pub parent_instance: gtk::GtkBin,
}
impl ::std::fmt::Debug for DzlElasticBin {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlElasticBin @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlEmptyState {
pub parent_instance: gtk::GtkBin,
}
impl ::std::fmt::Debug for DzlEmptyState {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlEmptyState @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlEntryBox {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlEntryBox {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlEntryBox @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlFileChooserEntry {
pub parent_instance: gtk::GtkBin,
}
impl ::std::fmt::Debug for DzlFileChooserEntry {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlFileChooserEntry @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlFileTransfer {
pub parent_instance: gobject::GObject,
}
impl ::std::fmt::Debug for DzlFileTransfer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlFileTransfer @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlFuzzyIndex {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlFuzzyIndex {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlFuzzyIndex @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlFuzzyIndexBuilder {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlFuzzyIndexBuilder {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlFuzzyIndexBuilder @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlFuzzyIndexCursor {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlFuzzyIndexCursor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlFuzzyIndexCursor @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlFuzzyIndexMatch {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlFuzzyIndexMatch {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlFuzzyIndexMatch @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlGraphColumn {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlGraphColumn {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlGraphColumn @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlGraphLineRenderer {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlGraphLineRenderer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlGraphLineRenderer @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlGraphModel {
pub parent_instance: gobject::GObject,
}
impl ::std::fmt::Debug for DzlGraphModel {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlGraphModel @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlGraphView {
pub parent_instance: gtk::GtkDrawingArea,
}
impl ::std::fmt::Debug for DzlGraphView {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlGraphView @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlJoinedMenu {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlJoinedMenu {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlJoinedMenu @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlListBox {
pub parent_instance: gtk::GtkListBox,
}
impl ::std::fmt::Debug for DzlListBox {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlListBox @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlListBoxRow {
pub parent_instance: gtk::GtkListBoxRow,
}
impl ::std::fmt::Debug for DzlListBoxRow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlListBoxRow @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlListModelFilter {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlListModelFilter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlListModelFilter @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlListStoreAdapter {
pub parent_instance: gobject::GObject,
}
impl ::std::fmt::Debug for DzlListStoreAdapter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlListStoreAdapter @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlMenuButton {
pub parent_instance: gtk::GtkMenuButton,
}
impl ::std::fmt::Debug for DzlMenuButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlMenuButton @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlMenuManager {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlMenuManager {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlMenuManager @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlMultiPaned {
pub parent_instance: gtk::GtkContainer,
}
impl ::std::fmt::Debug for DzlMultiPaned {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlMultiPaned @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlPath {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlPath {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPath @ {:p}", self)).finish()
}
}
#[repr(C)]
pub struct DzlPathBar {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlPathBar {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPathBar @ {:p}", self)).finish()
}
}
#[repr(C)]
pub struct DzlPathElement {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlPathElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPathElement @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlPillBox {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlPillBox {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPillBox @ {:p}", self)).finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPreferencesBin {
pub parent_instance: gtk::GtkBin,
}
impl ::std::fmt::Debug for DzlPreferencesBin {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesBin @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPreferencesEntry {
pub parent_instance: DzlPreferencesBin,
}
impl ::std::fmt::Debug for DzlPreferencesEntry {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesEntry @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlPreferencesFileChooserButton {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlPreferencesFileChooserButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesFileChooserButton @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlPreferencesFlowBox {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlPreferencesFlowBox {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesFlowBox @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlPreferencesFontButton {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlPreferencesFontButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesFontButton @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlPreferencesGroup {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlPreferencesGroup {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesGroup @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlPreferencesPage {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlPreferencesPage {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesPage @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlPreferencesSpinButton {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlPreferencesSpinButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesSpinButton @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlPreferencesSwitch {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlPreferencesSwitch {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesSwitch @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPreferencesView {
pub parent_instance: gtk::GtkBin,
}
impl ::std::fmt::Debug for DzlPreferencesView {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPreferencesView @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlPriorityBox {
pub parent_instance: gtk::GtkBox,
}
impl ::std::fmt::Debug for DzlPriorityBox {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPriorityBox @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlProgressButton {
pub parent_instance: gtk::GtkButton,
}
impl ::std::fmt::Debug for DzlProgressButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlProgressButton @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlProgressIcon {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlProgressIcon {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlProgressIcon @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlProgressMenuButton {
pub parent_instance: gtk::GtkMenuButton,
}
impl ::std::fmt::Debug for DzlProgressMenuButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlProgressMenuButton @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlPropertiesGroup {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlPropertiesGroup {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlPropertiesGroup @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlRadioBox {
pub parent_instance: gtk::GtkBin,
}
impl ::std::fmt::Debug for DzlRadioBox {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlRadioBox @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlReadOnlyListModel {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlReadOnlyListModel {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlReadOnlyListModel @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlRecursiveFileMonitor {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlRecursiveFileMonitor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlRecursiveFileMonitor @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlScrolledWindow {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlScrolledWindow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlScrolledWindow @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSearchBar {
pub parent_instance: gtk::GtkBin,
}
impl ::std::fmt::Debug for DzlSearchBar {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSearchBar @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlSettingsFlagAction {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlSettingsFlagAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSettingsFlagAction @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlSettingsSandwich {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlSettingsSandwich {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSettingsSandwich @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlShortcutAccelDialog {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlShortcutAccelDialog {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutAccelDialog @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlShortcutContext {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlShortcutContext {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutContext @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlShortcutController {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlShortcutController {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutController @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlShortcutLabel {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlShortcutLabel {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutLabel @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutManager {
pub parent_instance: gobject::GObject,
}
impl ::std::fmt::Debug for DzlShortcutManager {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutManager @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlShortcutModel {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlShortcutModel {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutModel @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlShortcutSimpleLabel {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlShortcutSimpleLabel {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutSimpleLabel @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutTheme {
pub parent_instance: gobject::GObject,
}
impl ::std::fmt::Debug for DzlShortcutTheme {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutTheme @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutThemeEditor {
pub parent_instance: gtk::GtkBin,
}
impl ::std::fmt::Debug for DzlShortcutThemeEditor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutThemeEditor @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlShortcutTooltip {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlShortcutTooltip {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutTooltip @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlShortcutsGroup {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlShortcutsGroup {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutsGroup @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlShortcutsSection {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlShortcutsSection {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutsSection @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlShortcutsShortcut {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlShortcutsShortcut {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutsShortcut @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlShortcutsWindow {
pub window: gtk::GtkWindow,
}
impl ::std::fmt::Debug for DzlShortcutsWindow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlShortcutsWindow @ {:p}", self))
.field("window", &self.window)
.finish()
}
}
#[repr(C)]
pub struct DzlSignalGroup {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlSignalGroup {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSignalGroup @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlSimpleLabel {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlSimpleLabel {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSimpleLabel @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSimplePopover {
pub parent_instance: gtk::GtkPopover,
}
impl ::std::fmt::Debug for DzlSimplePopover {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSimplePopover @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSlider {
pub parent_instance: gtk::GtkContainer,
}
impl ::std::fmt::Debug for DzlSlider {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSlider @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlStackList {
pub parent_instance: gtk::GtkBin,
}
impl ::std::fmt::Debug for DzlStackList {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlStackList @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlStateMachine {
pub parent_instance: gobject::GObject,
}
impl ::std::fmt::Debug for DzlStateMachine {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlStateMachine @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestion {
pub parent_instance: gobject::GObject,
}
impl ::std::fmt::Debug for DzlSuggestion {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSuggestion @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestionButton {
pub parent_instance: gtk::GtkStack,
}
impl ::std::fmt::Debug for DzlSuggestionButton {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSuggestionButton @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestionEntry {
pub parent_instance: gtk::GtkEntry,
}
impl ::std::fmt::Debug for DzlSuggestionEntry {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSuggestionEntry @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestionEntryBuffer {
pub parent_instance: gtk::GtkEntryBuffer,
}
impl ::std::fmt::Debug for DzlSuggestionEntryBuffer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSuggestionEntryBuffer @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlSuggestionPopover {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlSuggestionPopover {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSuggestionPopover @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlSuggestionRow {
pub parent_instance: DzlListBoxRow,
}
impl ::std::fmt::Debug for DzlSuggestionRow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlSuggestionRow @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlTab {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlTab {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlTab @ {:p}", self)).finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlTabStrip {
pub parent_instance: gtk::GtkBox,
}
impl ::std::fmt::Debug for DzlTabStrip {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlTabStrip @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlTaskCache {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlTaskCache {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlTaskCache @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlThemeManager {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlThemeManager {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlThemeManager @ {:p}", self))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlThreeGrid {
pub parent_instance: gtk::GtkContainer,
}
impl ::std::fmt::Debug for DzlThreeGrid {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlThreeGrid @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlTree {
pub parent_instance: gtk::GtkTreeView,
}
impl ::std::fmt::Debug for DzlTree {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlTree @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DzlTreeBuilder {
pub parent_instance: gobject::GInitiallyUnowned,
}
impl ::std::fmt::Debug for DzlTreeBuilder {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlTreeBuilder @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct DzlTreeNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlTreeNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlTreeNode @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlWidgetActionGroup {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlWidgetActionGroup {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("DzlWidgetActionGroup @ {:p}", self))
.finish()
}
}
#[repr(C)]
pub struct DzlDock {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlDock {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "DzlDock @ {:p}", self)
}
}
#[repr(C)]
pub struct DzlDockItem {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlDockItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "DzlDockItem @ {:p}", self)
}
}
#[repr(C)]
pub struct DzlGraphRenderer {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlGraphRenderer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "DzlGraphRenderer @ {:p}", self)
}
}
#[repr(C)]
pub struct DzlPreferences {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for DzlPreferences {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "DzlPreferences @ {:p}", self)
}
}
#[link(name = "dazzle-1.0")]
extern "C" {
pub fn dzl_animation_mode_get_type() -> GType;
pub fn dzl_dock_revealer_transition_type_get_type() -> GType;
pub fn dzl_shortcut_match_get_type() -> GType;
pub fn dzl_slider_position_get_type() -> GType;
pub fn dzl_three_grid_column_get_type() -> GType;
pub fn dzl_tree_drop_position_get_type() -> GType;
pub fn dzl_file_transfer_flags_get_type() -> GType;
pub fn dzl_shortcut_phase_get_type() -> GType;
pub fn dzl_tab_style_get_type() -> GType;
pub fn dzl_counter_get(counter: *mut DzlCounter) -> i64;
pub fn dzl_counter_reset(counter: *mut DzlCounter);
pub fn dzl_counter_arena_get_type() -> GType;
pub fn dzl_counter_arena_new_for_pid(pid: glib::GPid) -> *mut DzlCounterArena;
pub fn dzl_counter_arena_foreach(
arena: *mut DzlCounterArena,
func: DzlCounterForeachFunc,
user_data: gpointer,
);
pub fn dzl_counter_arena_ref(arena: *mut DzlCounterArena) -> *mut DzlCounterArena;
pub fn dzl_counter_arena_register(arena: *mut DzlCounterArena, counter: *mut DzlCounter);
pub fn dzl_counter_arena_unref(arena: *mut DzlCounterArena);
pub fn dzl_counter_arena_get_default() -> *mut DzlCounterArena;
pub fn dzl_fuzzy_mutable_index_get_type() -> GType;
pub fn dzl_fuzzy_mutable_index_new(case_sensitive: gboolean) -> *mut DzlFuzzyMutableIndex;
pub fn dzl_fuzzy_mutable_index_new_with_free_func(
case_sensitive: gboolean,
free_func: glib::GDestroyNotify,
) -> *mut DzlFuzzyMutableIndex;
pub fn dzl_fuzzy_mutable_index_begin_bulk_insert(fuzzy: *mut DzlFuzzyMutableIndex);
pub fn dzl_fuzzy_mutable_index_contains(
fuzzy: *mut DzlFuzzyMutableIndex,
key: *const c_char,
) -> gboolean;
pub fn dzl_fuzzy_mutable_index_end_bulk_insert(fuzzy: *mut DzlFuzzyMutableIndex);
pub fn dzl_fuzzy_mutable_index_insert(
fuzzy: *mut DzlFuzzyMutableIndex,
key: *const c_char,
value: gpointer,
);
pub fn dzl_fuzzy_mutable_index_match(
fuzzy: *mut DzlFuzzyMutableIndex,
needle: *const c_char,
max_matches: size_t,
) -> *mut glib::GArray;
pub fn dzl_fuzzy_mutable_index_ref(
fuzzy: *mut DzlFuzzyMutableIndex,
) -> *mut DzlFuzzyMutableIndex;
pub fn dzl_fuzzy_mutable_index_remove(fuzzy: *mut DzlFuzzyMutableIndex, key: *const c_char);
pub fn dzl_fuzzy_mutable_index_set_free_func(
fuzzy: *mut DzlFuzzyMutableIndex,
free_func: glib::GDestroyNotify,
);
pub fn dzl_fuzzy_mutable_index_unref(fuzzy: *mut DzlFuzzyMutableIndex);
pub fn dzl_heap_get_type() -> GType;
pub fn dzl_heap_new(element_size: c_uint, compare_func: glib::GCompareFunc) -> *mut DzlHeap;
pub fn dzl_heap_extract(heap: *mut DzlHeap, result: gpointer) -> gboolean;
pub fn dzl_heap_extract_index(heap: *mut DzlHeap, index_: size_t, result: gpointer)
-> gboolean;
pub fn dzl_heap_insert_vals(heap: *mut DzlHeap, data: gconstpointer, len: c_uint);
pub fn dzl_heap_ref(heap: *mut DzlHeap) -> *mut DzlHeap;
pub fn dzl_heap_unref(heap: *mut DzlHeap);
pub fn dzl_pattern_spec_get_type() -> GType;
pub fn dzl_pattern_spec_new(keywords: *const c_char) -> *mut DzlPatternSpec;
pub fn dzl_pattern_spec_get_text(self_: *mut DzlPatternSpec) -> *const c_char;
pub fn dzl_pattern_spec_match(self_: *mut DzlPatternSpec, haystack: *const c_char) -> gboolean;
pub fn dzl_pattern_spec_ref(self_: *mut DzlPatternSpec) -> *mut DzlPatternSpec;
pub fn dzl_pattern_spec_unref(self_: *mut DzlPatternSpec);
pub fn dzl_ring_get_type() -> GType;
pub fn dzl_ring_sized_new(
element_size: c_uint,
reserved_size: c_uint,
element_destroy: glib::GDestroyNotify,
) -> *mut DzlRing;
pub fn dzl_ring_append_vals(ring: *mut DzlRing, data: gconstpointer, len: c_uint) -> c_uint;
pub fn dzl_ring_foreach(ring: *mut DzlRing, func: glib::GFunc, user_data: gpointer);
pub fn dzl_ring_ref(ring: *mut DzlRing) -> *mut DzlRing;
pub fn dzl_ring_unref(ring: *mut DzlRing);
pub fn dzl_shortcut_chord_get_type() -> GType;
pub fn dzl_shortcut_chord_new_from_event(
event: *const gdk::GdkEventKey,
) -> *mut DzlShortcutChord;
pub fn dzl_shortcut_chord_new_from_string(accelerator: *const c_char) -> *mut DzlShortcutChord;
pub fn dzl_shortcut_chord_append_event(
self_: *mut DzlShortcutChord,
event: *const gdk::GdkEventKey,
) -> gboolean;
pub fn dzl_shortcut_chord_copy(self_: *const DzlShortcutChord) -> *mut DzlShortcutChord;
pub fn dzl_shortcut_chord_free(self_: *mut DzlShortcutChord);
pub fn dzl_shortcut_chord_get_label(self_: *const DzlShortcutChord) -> *mut c_char;
pub fn dzl_shortcut_chord_get_length(self_: *const DzlShortcutChord) -> c_uint;
pub fn dzl_shortcut_chord_get_nth_key(
self_: *const DzlShortcutChord,
nth: c_uint,
keyval: *mut c_uint,
modifier: *mut gdk::GdkModifierType,
);
pub fn dzl_shortcut_chord_has_modifier(self_: *const DzlShortcutChord) -> gboolean;
pub fn dzl_shortcut_chord_match(
self_: *const DzlShortcutChord,
other: *const DzlShortcutChord,
) -> DzlShortcutMatch;
pub fn dzl_shortcut_chord_to_string(self_: *const DzlShortcutChord) -> *mut c_char;
pub fn dzl_shortcut_chord_equal(data1: gconstpointer, data2: gconstpointer) -> gboolean;
pub fn dzl_shortcut_chord_hash(data: gconstpointer) -> c_uint;
pub fn dzl_shortcut_chord_table_add(
self_: *mut DzlShortcutChordTable,
chord: *const DzlShortcutChord,
data: gpointer,
);
pub fn dzl_shortcut_chord_table_foreach(
self_: *const DzlShortcutChordTable,
foreach_func: DzlShortcutChordTableForeach,
foreach_data: gpointer,
);
pub fn dzl_shortcut_chord_table_free(self_: *mut DzlShortcutChordTable);
pub fn dzl_shortcut_chord_table_lookup(
self_: *mut DzlShortcutChordTable,
chord: *const DzlShortcutChord,
data: *mut gpointer,
) -> DzlShortcutMatch;
pub fn dzl_shortcut_chord_table_lookup_data(
self_: *mut DzlShortcutChordTable,
data: gpointer,
) -> *const DzlShortcutChord;
pub fn dzl_shortcut_chord_table_printf(self_: *const DzlShortcutChordTable);
pub fn dzl_shortcut_chord_table_remove(
self_: *mut DzlShortcutChordTable,
chord: *const DzlShortcutChord,
) -> gboolean;
pub fn dzl_shortcut_chord_table_remove_data(
self_: *mut DzlShortcutChordTable,
data: gpointer,
) -> gboolean;
pub fn dzl_shortcut_chord_table_set_free_func(
self_: *mut DzlShortcutChordTable,
notify: glib::GDestroyNotify,
);
pub fn dzl_shortcut_chord_table_size(self_: *const DzlShortcutChordTable) -> c_uint;
pub fn dzl_shortcut_chord_table_new() -> *mut DzlShortcutChordTable;
pub fn dzl_trie_get_type() -> GType;
pub fn dzl_trie_new(value_destroy: glib::GDestroyNotify) -> *mut DzlTrie;
pub fn dzl_trie_destroy(trie: *mut DzlTrie);
pub fn dzl_trie_insert(trie: *mut DzlTrie, key: *const c_char, value: gpointer);
pub fn dzl_trie_lookup(trie: *mut DzlTrie, key: *const c_char) -> gpointer;
pub fn dzl_trie_ref(trie: *mut DzlTrie) -> *mut DzlTrie;
pub fn dzl_trie_remove(trie: *mut DzlTrie, key: *const c_char) -> gboolean;
pub fn dzl_trie_traverse(
trie: *mut DzlTrie,
key: *const c_char,
order: glib::GTraverseType,
flags: glib::GTraverseFlags,
max_depth: c_int,
func: DzlTrieTraverseFunc,
user_data: gpointer,
);
pub fn dzl_trie_unref(trie: *mut DzlTrie);
pub fn dzl_animation_get_type() -> GType;
pub fn dzl_animation_calculate_duration(
monitor: *mut gdk::GdkMonitor,
from_value: c_double,
to_value: c_double,
) -> c_uint;
pub fn dzl_animation_add_property(
animation: *mut DzlAnimation,
pspec: *mut gobject::GParamSpec,
value: *const gobject::GValue,
);
pub fn dzl_animation_start(animation: *mut DzlAnimation);
pub fn dzl_animation_stop(animation: *mut DzlAnimation);
pub fn dzl_application_get_type() -> GType;
pub fn dzl_application_new(
application_id: *const c_char,
flags: gio::GApplicationFlags,
) -> *mut DzlApplication;
pub fn dzl_application_add_resources(self_: *mut DzlApplication, resource_path: *const c_char);
pub fn dzl_application_get_menu_by_id(
self_: *mut DzlApplication,
menu_id: *const c_char,
) -> *mut gio::GMenu;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_application_get_menu_manager(self_: *mut DzlApplication) -> *mut DzlMenuManager;
pub fn dzl_application_get_shortcut_manager(
self_: *mut DzlApplication,
) -> *mut DzlShortcutManager;
pub fn dzl_application_get_theme_manager(self_: *mut DzlApplication) -> *mut DzlThemeManager;
pub fn dzl_application_remove_resources(
self_: *mut DzlApplication,
resource_path: *const c_char,
);
pub fn dzl_application_window_get_type() -> GType;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_application_window_get_fullscreen(self_: *mut DzlApplicationWindow) -> gboolean;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_application_window_get_titlebar(
self_: *mut DzlApplicationWindow,
) -> *mut gtk::GtkWidget;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_application_window_set_fullscreen(
self_: *mut DzlApplicationWindow,
fullscreen: gboolean,
);
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_application_window_set_titlebar(
self_: *mut DzlApplicationWindow,
titlebar: *mut gtk::GtkWidget,
);
pub fn dzl_bin_get_type() -> GType;
pub fn dzl_bin_new() -> *mut gtk::GtkWidget;
pub fn dzl_binding_group_get_type() -> GType;
pub fn dzl_binding_group_new() -> *mut DzlBindingGroup;
pub fn dzl_binding_group_bind(
self_: *mut DzlBindingGroup,
source_property: *const c_char,
target: *mut gobject::GObject,
target_property: *const c_char,
flags: gobject::GBindingFlags,
);
pub fn dzl_binding_group_bind_full(
self_: *mut DzlBindingGroup,
source_property: *const c_char,
target: *mut gobject::GObject,
target_property: *const c_char,
flags: gobject::GBindingFlags,
transform_to: gobject::GBindingTransformFunc,
transform_from: gobject::GBindingTransformFunc,
user_data: gpointer,
user_data_destroy: glib::GDestroyNotify,
);
pub fn dzl_binding_group_bind_with_closures(
self_: *mut DzlBindingGroup,
source_property: *const c_char,
target: *mut gobject::GObject,
target_property: *const c_char,
flags: gobject::GBindingFlags,
transform_to: *mut gobject::GClosure,
transform_from: *mut gobject::GClosure,
);
pub fn dzl_binding_group_get_source(self_: *mut DzlBindingGroup) -> *mut gobject::GObject;
pub fn dzl_binding_group_set_source(self_: *mut DzlBindingGroup, source: *mut gobject::GObject);
pub fn dzl_bolding_label_get_type() -> GType;
pub fn dzl_bolding_label_new(str: *const c_char, bold: gboolean) -> *mut DzlBoldingLabel;
pub fn dzl_bolding_label_new_with_mnemonic(
str: *const c_char,
bold: gboolean,
) -> *mut DzlBoldingLabel;
pub fn dzl_bolding_label_set_bold(self_: *mut DzlBoldingLabel, bold: gboolean);
pub fn dzl_bolding_label_set_weight(self_: *mut DzlBoldingLabel, weight: pango::PangoWeight);
pub fn dzl_box_get_type() -> GType;
pub fn dzl_box_new() -> *mut gtk::GtkWidget;
pub fn dzl_box_get_max_width_request(self_: *mut DzlBox) -> c_int;
pub fn dzl_box_get_nth_child(self_: *mut DzlBox, nth: c_uint) -> *mut gtk::GtkWidget;
pub fn dzl_box_set_max_width_request(self_: *mut DzlBox, max_width_request: c_int);
pub fn dzl_box_theatric_get_type() -> GType;
pub fn dzl_centering_bin_get_type() -> GType;
pub fn dzl_centering_bin_new() -> *mut gtk::GtkWidget;
pub fn dzl_child_property_action_get_type() -> GType;
pub fn dzl_child_property_action_new(
name: *const c_char,
container: *mut gtk::GtkContainer,
child: *mut gtk::GtkWidget,
child_property_name: *const c_char,
) -> *mut gio::GAction;
pub fn dzl_column_layout_get_type() -> GType;
pub fn dzl_column_layout_new() -> *mut gtk::GtkWidget;
pub fn dzl_column_layout_get_column_spacing(self_: *mut DzlColumnLayout) -> c_int;
pub fn dzl_column_layout_get_column_width(self_: *mut DzlColumnLayout) -> c_int;
pub fn dzl_column_layout_get_max_columns(self_: *mut DzlColumnLayout) -> c_uint;
pub fn dzl_column_layout_get_row_spacing(self_: *mut DzlColumnLayout) -> c_int;
pub fn dzl_column_layout_set_column_spacing(self_: *mut DzlColumnLayout, column_spacing: c_int);
pub fn dzl_column_layout_set_column_width(self_: *mut DzlColumnLayout, column_width: c_int);
pub fn dzl_column_layout_set_max_columns(self_: *mut DzlColumnLayout, max_columns: c_uint);
pub fn dzl_column_layout_set_row_spacing(self_: *mut DzlColumnLayout, row_spacing: c_int);
pub fn dzl_counters_window_get_type() -> GType;
pub fn dzl_counters_window_new() -> *mut gtk::GtkWidget;
pub fn dzl_counters_window_get_arena(self_: *mut DzlCountersWindow) -> *mut DzlCounterArena;
pub fn dzl_counters_window_set_arena(
self_: *mut DzlCountersWindow,
arena: *mut DzlCounterArena,
);
pub fn dzl_cpu_graph_get_type() -> GType;
pub fn dzl_cpu_graph_new_full(timespan: i64, max_samples: c_uint) -> *mut gtk::GtkWidget;
pub fn dzl_cpu_model_get_type() -> GType;
pub fn dzl_cpu_model_new() -> *mut DzlGraphModel;
pub fn dzl_css_provider_get_type() -> GType;
pub fn dzl_css_provider_new(base_path: *const c_char) -> *mut gtk::GtkCssProvider;
pub fn dzl_directory_model_get_type() -> GType;
pub fn dzl_directory_model_new(directory: *mut gio::GFile) -> *mut gio::GListModel;
pub fn dzl_directory_model_get_directory(self_: *mut DzlDirectoryModel) -> *mut gio::GFile;
pub fn dzl_directory_model_set_directory(
self_: *mut DzlDirectoryModel,
directory: *mut gio::GFile,
);
pub fn dzl_directory_model_set_visible_func(
self_: *mut DzlDirectoryModel,
visible_func: DzlDirectoryModelVisibleFunc,
user_data: gpointer,
user_data_free_func: glib::GDestroyNotify,
);
pub fn dzl_directory_reaper_get_type() -> GType;
pub fn dzl_directory_reaper_new() -> *mut DzlDirectoryReaper;
pub fn dzl_directory_reaper_add_directory(
self_: *mut DzlDirectoryReaper,
directory: *mut gio::GFile,
min_age: glib::GTimeSpan,
);
pub fn dzl_directory_reaper_add_file(
self_: *mut DzlDirectoryReaper,
file: *mut gio::GFile,
min_age: glib::GTimeSpan,
);
pub fn dzl_directory_reaper_add_glob(
self_: *mut DzlDirectoryReaper,
directory: *mut gio::GFile,
glob: *const c_char,
min_age: glib::GTimeSpan,
);
pub fn dzl_directory_reaper_execute(
self_: *mut DzlDirectoryReaper,
cancellable: *mut gio::GCancellable,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_directory_reaper_execute_async(
self_: *mut DzlDirectoryReaper,
cancellable: *mut gio::GCancellable,
callback: gio::GAsyncReadyCallback,
user_data: gpointer,
);
pub fn dzl_directory_reaper_execute_finish(
self_: *mut DzlDirectoryReaper,
result: *mut gio::GAsyncResult,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_dock_bin_get_type() -> GType;
pub fn dzl_dock_bin_new() -> *mut gtk::GtkWidget;
pub fn dzl_dock_bin_get_bottom_edge(self_: *mut DzlDockBin) -> *mut gtk::GtkWidget;
pub fn dzl_dock_bin_get_center_widget(self_: *mut DzlDockBin) -> *mut gtk::GtkWidget;
pub fn dzl_dock_bin_get_left_edge(self_: *mut DzlDockBin) -> *mut gtk::GtkWidget;
pub fn dzl_dock_bin_get_right_edge(self_: *mut DzlDockBin) -> *mut gtk::GtkWidget;
pub fn dzl_dock_bin_get_top_edge(self_: *mut DzlDockBin) -> *mut gtk::GtkWidget;
pub fn dzl_dock_bin_edge_get_type() -> GType;
pub fn dzl_dock_bin_edge_get_edge(self_: *mut DzlDockBinEdge) -> gtk::GtkPositionType;
pub fn dzl_dock_manager_get_type() -> GType;
pub fn dzl_dock_manager_new() -> *mut DzlDockManager;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_dock_manager_pause_grabs(self_: *mut DzlDockManager);
pub fn dzl_dock_manager_register_dock(self_: *mut DzlDockManager, dock: *mut DzlDock);
pub fn dzl_dock_manager_release_transient_grab(self_: *mut DzlDockManager);
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_dock_manager_unpause_grabs(self_: *mut DzlDockManager);
pub fn dzl_dock_manager_unregister_dock(self_: *mut DzlDockManager, dock: *mut DzlDock);
pub fn dzl_dock_overlay_get_type() -> GType;
pub fn dzl_dock_overlay_new() -> *mut gtk::GtkWidget;
pub fn dzl_dock_overlay_get_edge(
self_: *mut DzlDockOverlay,
position: gtk::GtkPositionType,
) -> *mut DzlDockOverlayEdge;
pub fn dzl_dock_overlay_get_edge_adjustment(
self_: *mut DzlDockOverlay,
position: gtk::GtkPositionType,
) -> *mut gtk::GtkAdjustment;
pub fn dzl_dock_overlay_edge_get_type() -> GType;
pub fn dzl_dock_overlay_edge_get_edge(self_: *mut DzlDockOverlayEdge) -> gtk::GtkPositionType;
pub fn dzl_dock_overlay_edge_get_position(self_: *mut DzlDockOverlayEdge) -> c_int;
pub fn dzl_dock_overlay_edge_set_edge(
self_: *mut DzlDockOverlayEdge,
edge: gtk::GtkPositionType,
);
pub fn dzl_dock_overlay_edge_set_position(self_: *mut DzlDockOverlayEdge, position: c_int);
pub fn dzl_dock_paned_get_type() -> GType;
pub fn dzl_dock_paned_new() -> *mut gtk::GtkWidget;
pub fn dzl_dock_revealer_get_type() -> GType;
pub fn dzl_dock_revealer_new() -> *mut gtk::GtkWidget;
pub fn dzl_dock_revealer_animate_to_position(
self_: *mut DzlDockRevealer,
position: c_int,
transition_duration: c_uint,
);
pub fn dzl_dock_revealer_get_child_revealed(self_: *mut DzlDockRevealer) -> gboolean;
pub fn dzl_dock_revealer_get_position(self_: *mut DzlDockRevealer) -> c_int;
pub fn dzl_dock_revealer_get_position_set(self_: *mut DzlDockRevealer) -> gboolean;
pub fn dzl_dock_revealer_get_reveal_child(self_: *mut DzlDockRevealer) -> gboolean;
pub fn dzl_dock_revealer_get_transition_duration(self_: *mut DzlDockRevealer) -> c_uint;
pub fn dzl_dock_revealer_get_transition_type(
self_: *mut DzlDockRevealer,
) -> DzlDockRevealerTransitionType;
pub fn dzl_dock_revealer_is_animating(self_: *mut DzlDockRevealer) -> gboolean;
pub fn dzl_dock_revealer_set_position(self_: *mut DzlDockRevealer, position: c_int);
pub fn dzl_dock_revealer_set_position_set(self_: *mut DzlDockRevealer, position_set: gboolean);
pub fn dzl_dock_revealer_set_reveal_child(self_: *mut DzlDockRevealer, reveal_child: gboolean);
pub fn dzl_dock_revealer_set_transition_duration(
self_: *mut DzlDockRevealer,
transition_duration: c_uint,
);
pub fn dzl_dock_revealer_set_transition_type(
self_: *mut DzlDockRevealer,
transition_type: DzlDockRevealerTransitionType,
);
pub fn dzl_dock_stack_get_type() -> GType;
pub fn dzl_dock_stack_new() -> *mut gtk::GtkWidget;
pub fn dzl_dock_stack_get_edge(self_: *mut DzlDockStack) -> gtk::GtkPositionType;
pub fn dzl_dock_stack_get_show_pinned_button(self_: *mut DzlDockStack) -> gboolean;
pub fn dzl_dock_stack_get_style(self_: *mut DzlDockStack) -> DzlTabStyle;
pub fn dzl_dock_stack_set_edge(self_: *mut DzlDockStack, edge: gtk::GtkPositionType);
pub fn dzl_dock_stack_set_show_pinned_button(
self_: *mut DzlDockStack,
show_pinned_button: gboolean,
);
pub fn dzl_dock_stack_set_style(self_: *mut DzlDockStack, style: DzlTabStyle);
pub fn dzl_dock_transient_grab_get_type() -> GType;
pub fn dzl_dock_transient_grab_new() -> *mut DzlDockTransientGrab;
pub fn dzl_dock_transient_grab_acquire(self_: *mut DzlDockTransientGrab);
pub fn dzl_dock_transient_grab_add_item(
self_: *mut DzlDockTransientGrab,
item: *mut DzlDockItem,
);
pub fn dzl_dock_transient_grab_cancel(self_: *mut DzlDockTransientGrab);
pub fn dzl_dock_transient_grab_contains(
self_: *mut DzlDockTransientGrab,
item: *mut DzlDockItem,
) -> gboolean;
pub fn dzl_dock_transient_grab_get_timeout(self_: *mut DzlDockTransientGrab) -> c_uint;
pub fn dzl_dock_transient_grab_is_descendant(
self_: *mut DzlDockTransientGrab,
widget: *mut gtk::GtkWidget,
) -> gboolean;
pub fn dzl_dock_transient_grab_release(self_: *mut DzlDockTransientGrab);
pub fn dzl_dock_transient_grab_remove_item(
self_: *mut DzlDockTransientGrab,
item: *mut DzlDockItem,
);
pub fn dzl_dock_transient_grab_set_timeout(self_: *mut DzlDockTransientGrab, timeout: c_uint);
pub fn dzl_dock_transient_grab_steal_common_ancestors(
self_: *mut DzlDockTransientGrab,
other: *mut DzlDockTransientGrab,
);
pub fn dzl_dock_widget_get_type() -> GType;
pub fn dzl_dock_widget_new() -> *mut gtk::GtkWidget;
pub fn dzl_dock_widget_set_gicon(self_: *mut DzlDockWidget, gicon: *mut gio::GIcon);
pub fn dzl_dock_widget_set_icon_name(self_: *mut DzlDockWidget, icon_name: *const c_char);
pub fn dzl_dock_widget_set_title(self_: *mut DzlDockWidget, title: *const c_char);
pub fn dzl_dock_window_get_type() -> GType;
pub fn dzl_dock_window_new() -> *mut gtk::GtkWidget;
pub fn dzl_elastic_bin_get_type() -> GType;
pub fn dzl_elastic_bin_new() -> *mut gtk::GtkWidget;
pub fn dzl_empty_state_get_type() -> GType;
pub fn dzl_empty_state_new() -> *mut gtk::GtkWidget;
pub fn dzl_empty_state_get_icon_name(self_: *mut DzlEmptyState) -> *const c_char;
pub fn dzl_empty_state_get_subtitle(self_: *mut DzlEmptyState) -> *const c_char;
pub fn dzl_empty_state_get_title(self_: *mut DzlEmptyState) -> *const c_char;
pub fn dzl_empty_state_set_icon_name(self_: *mut DzlEmptyState, icon_name: *const c_char);
pub fn dzl_empty_state_set_resource(self_: *mut DzlEmptyState, resource: *const c_char);
pub fn dzl_empty_state_set_subtitle(self_: *mut DzlEmptyState, title: *const c_char);
pub fn dzl_empty_state_set_title(self_: *mut DzlEmptyState, title: *const c_char);
pub fn dzl_entry_box_get_type() -> GType;
pub fn dzl_entry_box_new() -> *mut gtk::GtkWidget;
pub fn dzl_file_chooser_entry_get_type() -> GType;
pub fn dzl_file_chooser_entry_new(
title: *const c_char,
action: gtk::GtkFileChooserAction,
) -> *mut gtk::GtkWidget;
#[cfg(any(feature = "v3_32", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_32")))]
pub fn dzl_file_chooser_entry_get_entry(self_: *mut DzlFileChooserEntry) -> *mut gtk::GtkEntry;
pub fn dzl_file_chooser_entry_get_file(self_: *mut DzlFileChooserEntry) -> *mut gio::GFile;
pub fn dzl_file_chooser_entry_set_file(self_: *mut DzlFileChooserEntry, file: *mut gio::GFile);
pub fn dzl_file_transfer_get_type() -> GType;
pub fn dzl_file_transfer_new() -> *mut DzlFileTransfer;
pub fn dzl_file_transfer_add(
self_: *mut DzlFileTransfer,
src: *mut gio::GFile,
dest: *mut gio::GFile,
);
pub fn dzl_file_transfer_execute(
self_: *mut DzlFileTransfer,
io_priority: c_int,
cancellable: *mut gio::GCancellable,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_file_transfer_execute_async(
self_: *mut DzlFileTransfer,
io_priority: c_int,
cancellable: *mut gio::GCancellable,
callback: gio::GAsyncReadyCallback,
user_data: gpointer,
);
pub fn dzl_file_transfer_execute_finish(
self_: *mut DzlFileTransfer,
result: *mut gio::GAsyncResult,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_file_transfer_get_flags(self_: *mut DzlFileTransfer) -> DzlFileTransferFlags;
pub fn dzl_file_transfer_get_progress(self_: *mut DzlFileTransfer) -> c_double;
pub fn dzl_file_transfer_set_flags(self_: *mut DzlFileTransfer, flags: DzlFileTransferFlags);
#[cfg(any(feature = "v3_28", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_28")))]
pub fn dzl_file_transfer_stat(self_: *mut DzlFileTransfer, stat_buf: *mut DzlFileTransferStat);
pub fn dzl_fuzzy_index_get_type() -> GType;
pub fn dzl_fuzzy_index_new() -> *mut DzlFuzzyIndex;
pub fn dzl_fuzzy_index_get_metadata(
self_: *mut DzlFuzzyIndex,
key: *const c_char,
) -> *mut glib::GVariant;
pub fn dzl_fuzzy_index_get_metadata_string(
self_: *mut DzlFuzzyIndex,
key: *const c_char,
) -> *const c_char;
pub fn dzl_fuzzy_index_get_metadata_uint32(
self_: *mut DzlFuzzyIndex,
key: *const c_char,
) -> u32;
pub fn dzl_fuzzy_index_get_metadata_uint64(
self_: *mut DzlFuzzyIndex,
key: *const c_char,
) -> u64;
pub fn dzl_fuzzy_index_load_file(
self_: *mut DzlFuzzyIndex,
file: *mut gio::GFile,
cancellable: *mut gio::GCancellable,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_fuzzy_index_load_file_async(
self_: *mut DzlFuzzyIndex,
file: *mut gio::GFile,
cancellable: *mut gio::GCancellable,
callback: gio::GAsyncReadyCallback,
user_data: gpointer,
);
pub fn dzl_fuzzy_index_load_file_finish(
self_: *mut DzlFuzzyIndex,
result: *mut gio::GAsyncResult,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_fuzzy_index_query_async(
self_: *mut DzlFuzzyIndex,
query: *const c_char,
max_matches: c_uint,
cancellable: *mut gio::GCancellable,
callback: gio::GAsyncReadyCallback,
user_data: gpointer,
);
pub fn dzl_fuzzy_index_query_finish(
self_: *mut DzlFuzzyIndex,
result: *mut gio::GAsyncResult,
error: *mut *mut glib::GError,
) -> *mut gio::GListModel;
pub fn dzl_fuzzy_index_builder_get_type() -> GType;
pub fn dzl_fuzzy_index_builder_new() -> *mut DzlFuzzyIndexBuilder;
pub fn dzl_fuzzy_index_builder_get_case_sensitive(self_: *mut DzlFuzzyIndexBuilder)
-> gboolean;
pub fn dzl_fuzzy_index_builder_get_document(
self_: *mut DzlFuzzyIndexBuilder,
document_id: u64,
) -> *const glib::GVariant;
pub fn dzl_fuzzy_index_builder_insert(
self_: *mut DzlFuzzyIndexBuilder,
key: *const c_char,
document: *mut glib::GVariant,
priority: c_uint,
) -> u64;
pub fn dzl_fuzzy_index_builder_set_case_sensitive(
self_: *mut DzlFuzzyIndexBuilder,
case_sensitive: gboolean,
);
pub fn dzl_fuzzy_index_builder_set_metadata(
self_: *mut DzlFuzzyIndexBuilder,
key: *const c_char,
value: *mut glib::GVariant,
);
pub fn dzl_fuzzy_index_builder_set_metadata_string(
self_: *mut DzlFuzzyIndexBuilder,
key: *const c_char,
value: *const c_char,
);
pub fn dzl_fuzzy_index_builder_set_metadata_uint32(
self_: *mut DzlFuzzyIndexBuilder,
key: *const c_char,
value: u32,
);
pub fn dzl_fuzzy_index_builder_set_metadata_uint64(
self_: *mut DzlFuzzyIndexBuilder,
key: *const c_char,
value: u64,
);
pub fn dzl_fuzzy_index_builder_write(
self_: *mut DzlFuzzyIndexBuilder,
file: *mut gio::GFile,
io_priority: c_int,
cancellable: *mut gio::GCancellable,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_fuzzy_index_builder_write_async(
self_: *mut DzlFuzzyIndexBuilder,
file: *mut gio::GFile,
io_priority: c_int,
cancellable: *mut gio::GCancellable,
callback: gio::GAsyncReadyCallback,
user_data: gpointer,
);
pub fn dzl_fuzzy_index_builder_write_finish(
self_: *mut DzlFuzzyIndexBuilder,
result: *mut gio::GAsyncResult,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_fuzzy_index_cursor_get_type() -> GType;
pub fn dzl_fuzzy_index_cursor_get_index(self_: *mut DzlFuzzyIndexCursor) -> *mut DzlFuzzyIndex;
pub fn dzl_fuzzy_index_match_get_type() -> GType;
pub fn dzl_fuzzy_index_match_get_document(
self_: *mut DzlFuzzyIndexMatch,
) -> *mut glib::GVariant;
pub fn dzl_fuzzy_index_match_get_key(self_: *mut DzlFuzzyIndexMatch) -> *const c_char;
pub fn dzl_fuzzy_index_match_get_priority(self_: *mut DzlFuzzyIndexMatch) -> c_uint;
pub fn dzl_fuzzy_index_match_get_score(self_: *mut DzlFuzzyIndexMatch) -> c_float;
pub fn dzl_graph_view_column_get_type() -> GType;
pub fn dzl_graph_view_column_new(name: *const c_char, value_type: GType)
-> *mut DzlGraphColumn;
pub fn dzl_graph_view_column_get_name(self_: *mut DzlGraphColumn) -> *const c_char;
pub fn dzl_graph_view_column_set_name(self_: *mut DzlGraphColumn, name: *const c_char);
pub fn dzl_graph_view_line_renderer_get_type() -> GType;
pub fn dzl_graph_view_line_renderer_new() -> *mut DzlGraphLineRenderer;
pub fn dzl_graph_view_line_renderer_get_stroke_color_rgba(
self_: *mut DzlGraphLineRenderer,
) -> *const gdk::GdkRGBA;
pub fn dzl_graph_view_line_renderer_set_stroke_color(
self_: *mut DzlGraphLineRenderer,
stroke_color: *const c_char,
);
pub fn dzl_graph_view_line_renderer_set_stroke_color_rgba(
self_: *mut DzlGraphLineRenderer,
stroke_color_rgba: *const gdk::GdkRGBA,
);
pub fn dzl_graph_view_model_get_type() -> GType;
pub fn dzl_graph_view_model_new() -> *mut DzlGraphModel;
pub fn dzl_graph_view_model_iter_get(iter: *mut DzlGraphModelIter, first_column: c_int, ...);
pub fn dzl_graph_view_model_iter_get_timestamp(iter: *mut DzlGraphModelIter) -> i64;
pub fn dzl_graph_view_model_iter_get_value(
iter: *mut DzlGraphModelIter,
column: c_uint,
value: *mut gobject::GValue,
);
pub fn dzl_graph_view_model_iter_next(iter: *mut DzlGraphModelIter) -> gboolean;
pub fn dzl_graph_view_model_iter_set(iter: *mut DzlGraphModelIter, first_column: c_int, ...);
#[cfg(any(feature = "v3_30", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_30")))]
pub fn dzl_graph_view_model_iter_set_value(
iter: *mut DzlGraphModelIter,
column: c_uint,
value: *const gobject::GValue,
);
pub fn dzl_graph_view_model_add_column(
self_: *mut DzlGraphModel,
column: *mut DzlGraphColumn,
) -> c_uint;
pub fn dzl_graph_view_model_get_end_time(self_: *mut DzlGraphModel) -> i64;
pub fn dzl_graph_view_model_get_iter_first(
self_: *mut DzlGraphModel,
iter: *mut DzlGraphModelIter,
) -> gboolean;
pub fn dzl_graph_view_model_get_iter_last(
self_: *mut DzlGraphModel,
iter: *mut DzlGraphModelIter,
) -> gboolean;
pub fn dzl_graph_view_model_get_max_samples(self_: *mut DzlGraphModel) -> c_uint;
pub fn dzl_graph_view_model_get_n_columns(self_: *mut DzlGraphModel) -> c_uint;
pub fn dzl_graph_view_model_get_timespan(self_: *mut DzlGraphModel) -> glib::GTimeSpan;
pub fn dzl_graph_view_model_push(
self_: *mut DzlGraphModel,
iter: *mut DzlGraphModelIter,
timestamp: i64,
);
pub fn dzl_graph_view_model_set_max_samples(self_: *mut DzlGraphModel, n_rows: c_uint);
pub fn dzl_graph_view_model_set_timespan(self_: *mut DzlGraphModel, timespan: glib::GTimeSpan);
pub fn dzl_graph_view_get_type() -> GType;
pub fn dzl_graph_view_new() -> *mut gtk::GtkWidget;
pub fn dzl_graph_view_add_renderer(self_: *mut DzlGraphView, renderer: *mut DzlGraphRenderer);
pub fn dzl_graph_view_get_model(self_: *mut DzlGraphView) -> *mut DzlGraphModel;
pub fn dzl_graph_view_set_model(self_: *mut DzlGraphView, model: *mut DzlGraphModel);
pub fn dzl_joined_menu_get_type() -> GType;
pub fn dzl_joined_menu_new() -> *mut DzlJoinedMenu;
pub fn dzl_joined_menu_append_menu(self_: *mut DzlJoinedMenu, model: *mut gio::GMenuModel);
pub fn dzl_joined_menu_get_n_joined(self_: *mut DzlJoinedMenu) -> c_uint;
pub fn dzl_joined_menu_prepend_menu(self_: *mut DzlJoinedMenu, model: *mut gio::GMenuModel);
pub fn dzl_joined_menu_remove_index(self_: *mut DzlJoinedMenu, index: c_uint);
pub fn dzl_joined_menu_remove_menu(self_: *mut DzlJoinedMenu, model: *mut gio::GMenuModel);
pub fn dzl_list_box_get_type() -> GType;
pub fn dzl_list_box_new(row_type: GType, property_name: *const c_char) -> *mut gtk::GtkWidget;
pub fn dzl_list_box_get_model(self_: *mut DzlListBox) -> *mut gio::GListModel;
pub fn dzl_list_box_get_property_name(self_: *mut DzlListBox) -> *const c_char;
pub fn dzl_list_box_get_row_type(self_: *mut DzlListBox) -> GType;
pub fn dzl_list_box_set_model(self_: *mut DzlListBox, model: *mut gio::GListModel);
#[cfg(any(feature = "v3_28", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_28")))]
pub fn dzl_list_box_set_recycle_max(self_: *mut DzlListBox, recycle_max: c_uint);
pub fn dzl_list_box_row_get_type() -> GType;
pub fn dzl_list_model_filter_get_type() -> GType;
pub fn dzl_list_model_filter_new(child_model: *mut gio::GListModel) -> *mut DzlListModelFilter;
pub fn dzl_list_model_filter_get_child_model(
self_: *mut DzlListModelFilter,
) -> *mut gio::GListModel;
pub fn dzl_list_model_filter_invalidate(self_: *mut DzlListModelFilter);
pub fn dzl_list_model_filter_set_filter_func(
self_: *mut DzlListModelFilter,
filter_func: DzlListModelFilterFunc,
filter_func_data: gpointer,
filter_func_data_destroy: glib::GDestroyNotify,
);
pub fn dzl_list_store_adapter_get_type() -> GType;
pub fn dzl_list_store_adapter_new(model: *mut gio::GListModel) -> *mut DzlListStoreAdapter;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_list_store_adapter_get_model(
self_: *mut DzlListStoreAdapter,
) -> *mut gio::GListModel;
pub fn dzl_list_store_adapter_set_model(
self_: *mut DzlListStoreAdapter,
model: *mut gio::GListModel,
);
pub fn dzl_menu_button_get_type() -> GType;
pub fn dzl_menu_button_new_with_model(
icon_name: *const c_char,
model: *mut gio::GMenuModel,
) -> *mut gtk::GtkWidget;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_menu_button_get_model(self_: *mut DzlMenuButton) -> *mut gio::GMenuModel;
pub fn dzl_menu_button_get_show_accels(self_: *mut DzlMenuButton) -> gboolean;
pub fn dzl_menu_button_get_show_arrow(self_: *mut DzlMenuButton) -> gboolean;
pub fn dzl_menu_button_get_show_icons(self_: *mut DzlMenuButton) -> gboolean;
pub fn dzl_menu_button_set_model(self_: *mut DzlMenuButton, model: *mut gio::GMenuModel);
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_menu_button_set_show_accels(self_: *mut DzlMenuButton, show_accels: gboolean);
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_menu_button_set_show_arrow(self_: *mut DzlMenuButton, show_arrow: gboolean);
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_menu_button_set_show_icons(self_: *mut DzlMenuButton, show_icons: gboolean);
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_menu_manager_get_type() -> GType;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_menu_manager_new() -> *mut DzlMenuManager;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_menu_manager_add_filename(
self_: *mut DzlMenuManager,
filename: *const c_char,
error: *mut *mut glib::GError,
) -> c_uint;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_menu_manager_add_resource(
self_: *mut DzlMenuManager,
resource: *const c_char,
error: *mut *mut glib::GError,
) -> c_uint;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_menu_manager_get_menu_by_id(
self_: *mut DzlMenuManager,
menu_id: *const c_char,
) -> *mut gio::GMenu;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_menu_manager_merge(
self_: *mut DzlMenuManager,
menu_id: *const c_char,
model: *mut gio::GMenuModel,
) -> c_uint;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_menu_manager_remove(self_: *mut DzlMenuManager, merge_id: c_uint);
pub fn dzl_multi_paned_get_type() -> GType;
pub fn dzl_multi_paned_new() -> *mut gtk::GtkWidget;
#[cfg(any(feature = "v3_28", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_28")))]
pub fn dzl_multi_paned_get_at_point(
self_: *mut DzlMultiPaned,
x: c_int,
y: c_int,
) -> *mut gtk::GtkWidget;
pub fn dzl_multi_paned_get_n_children(self_: *mut DzlMultiPaned) -> c_uint;
pub fn dzl_multi_paned_get_nth_child(
self_: *mut DzlMultiPaned,
nth: c_uint,
) -> *mut gtk::GtkWidget;
pub fn dzl_path_get_type() -> GType;
pub fn dzl_path_new() -> *mut DzlPath;
pub fn dzl_path_append(self_: *mut DzlPath, element: *mut DzlPathElement);
pub fn dzl_path_get_element(self_: *mut DzlPath, index: c_uint) -> *mut DzlPathElement;
pub fn dzl_path_get_elements(self_: *mut DzlPath) -> *mut glib::GList;
pub fn dzl_path_get_length(self_: *mut DzlPath) -> c_uint;
pub fn dzl_path_has_prefix(self_: *mut DzlPath, prefix: *mut DzlPath) -> gboolean;
pub fn dzl_path_is_empty(self_: *mut DzlPath) -> gboolean;
pub fn dzl_path_prepend(self_: *mut DzlPath, element: *mut DzlPathElement);
pub fn dzl_path_printf(self_: *mut DzlPath) -> *mut c_char;
pub fn dzl_path_bar_get_type() -> GType;
pub fn dzl_path_bar_new() -> *mut gtk::GtkWidget;
pub fn dzl_path_bar_get_path(self_: *mut DzlPathBar) -> *mut DzlPath;
pub fn dzl_path_bar_set_path(self_: *mut DzlPathBar, path: *mut DzlPath);
pub fn dzl_path_bar_set_selected_index(self_: *mut DzlPathBar, index: c_uint);
pub fn dzl_path_element_get_type() -> GType;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_path_element_new(
id: *const c_char,
icon_name: *const c_char,
title: *const c_char,
) -> *mut DzlPathElement;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_path_element_get_icon_name(self_: *mut DzlPathElement) -> *const c_char;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_path_element_get_id(self_: *mut DzlPathElement) -> *const c_char;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_path_element_get_title(self_: *mut DzlPathElement) -> *const c_char;
pub fn dzl_pill_box_get_type() -> GType;
pub fn dzl_pill_box_new(label: *const c_char) -> *mut gtk::GtkWidget;
pub fn dzl_pill_box_get_label(self_: *mut DzlPillBox) -> *const c_char;
pub fn dzl_pill_box_set_label(self_: *mut DzlPillBox, label: *const c_char);
pub fn dzl_preferences_bin_get_type() -> GType;
pub fn dzl_preferences_entry_get_type() -> GType;
pub fn dzl_preferences_entry_get_entry_widget(
self_: *mut DzlPreferencesEntry,
) -> *mut gtk::GtkWidget;
pub fn dzl_preferences_entry_get_title_widget(
self_: *mut DzlPreferencesEntry,
) -> *mut gtk::GtkWidget;
pub fn dzl_preferences_file_chooser_button_get_type() -> GType;
pub fn dzl_preferences_flow_box_get_type() -> GType;
pub fn dzl_preferences_flow_box_new() -> *mut gtk::GtkWidget;
pub fn dzl_preferences_font_button_get_type() -> GType;
pub fn dzl_preferences_group_get_type() -> GType;
pub fn dzl_preferences_group_add(self_: *mut DzlPreferencesGroup, widget: *mut gtk::GtkWidget);
pub fn dzl_preferences_group_get_priority(self_: *mut DzlPreferencesGroup) -> c_int;
pub fn dzl_preferences_group_get_size_group(
self_: *mut DzlPreferencesGroup,
column: c_uint,
) -> *mut gtk::GtkSizeGroup;
pub fn dzl_preferences_group_get_title(self_: *mut DzlPreferencesGroup) -> *const c_char;
pub fn dzl_preferences_group_refilter(
self_: *mut DzlPreferencesGroup,
spec: *mut DzlPatternSpec,
) -> c_uint;
pub fn dzl_preferences_group_set_map(
self_: *mut DzlPreferencesGroup,
map: *mut glib::GHashTable,
);
pub fn dzl_preferences_page_get_type() -> GType;
pub fn dzl_preferences_page_add_group(
self_: *mut DzlPreferencesPage,
group: *mut DzlPreferencesGroup,
);
pub fn dzl_preferences_page_get_group(
self_: *mut DzlPreferencesPage,
group_name: *const c_char,
) -> *mut DzlPreferencesGroup;
pub fn dzl_preferences_page_refilter(self_: *mut DzlPreferencesPage, spec: *mut DzlPatternSpec);
pub fn dzl_preferences_page_set_map(self_: *mut DzlPreferencesPage, map: *mut glib::GHashTable);
pub fn dzl_preferences_spin_button_get_type() -> GType;
pub fn dzl_preferences_spin_button_get_spin_button(
self_: *mut DzlPreferencesSpinButton,
) -> *mut gtk::GtkWidget;
pub fn dzl_preferences_switch_get_type() -> GType;
pub fn dzl_preferences_view_get_type() -> GType;
pub fn dzl_preferences_view_new() -> *mut gtk::GtkWidget;
pub fn dzl_preferences_view_get_show_search_entry(self_: *mut DzlPreferencesView) -> gboolean;
pub fn dzl_preferences_view_get_use_sidebar(self_: *mut DzlPreferencesView) -> gboolean;
pub fn dzl_preferences_view_reapply_filter(self_: *mut DzlPreferencesView);
pub fn dzl_preferences_view_set_show_search_entry(
self_: *mut DzlPreferencesView,
show_search_entry: gboolean,
);
pub fn dzl_preferences_view_set_use_sidebar(
self_: *mut DzlPreferencesView,
use_sidebar: gboolean,
);
pub fn dzl_priority_box_get_type() -> GType;
pub fn dzl_priority_box_new() -> *mut gtk::GtkWidget;
pub fn dzl_progress_button_get_type() -> GType;
pub fn dzl_progress_button_new() -> *mut gtk::GtkWidget;
pub fn dzl_progress_button_get_progress(self_: *mut DzlProgressButton) -> c_uint;
pub fn dzl_progress_button_get_show_progress(self_: *mut DzlProgressButton) -> gboolean;
pub fn dzl_progress_button_set_progress(button: *mut DzlProgressButton, percentage: c_uint);
pub fn dzl_progress_button_set_show_progress(
button: *mut DzlProgressButton,
show_progress: gboolean,
);
pub fn dzl_progress_icon_get_type() -> GType;
pub fn dzl_progress_icon_new() -> *mut gtk::GtkWidget;
pub fn dzl_progress_icon_get_progress(self_: *mut DzlProgressIcon) -> c_double;
pub fn dzl_progress_icon_set_progress(self_: *mut DzlProgressIcon, progress: c_double);
pub fn dzl_progress_menu_button_get_type() -> GType;
pub fn dzl_progress_menu_button_new() -> *mut gtk::GtkWidget;
pub fn dzl_progress_menu_button_get_progress(button: *mut DzlProgressMenuButton) -> c_double;
pub fn dzl_progress_menu_button_get_show_progress(
self_: *mut DzlProgressMenuButton,
) -> gboolean;
pub fn dzl_progress_menu_button_get_show_theatric(
self_: *mut DzlProgressMenuButton,
) -> gboolean;
pub fn dzl_progress_menu_button_reset_theatrics(self_: *mut DzlProgressMenuButton);
pub fn dzl_progress_menu_button_set_progress(
button: *mut DzlProgressMenuButton,
progress: c_double,
);
pub fn dzl_progress_menu_button_set_show_progress(
self_: *mut DzlProgressMenuButton,
show_progress: gboolean,
);
pub fn dzl_progress_menu_button_set_show_theatric(
self_: *mut DzlProgressMenuButton,
show_theatic: gboolean,
);
pub fn dzl_properties_group_get_type() -> GType;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_properties_group_new(object: *mut gobject::GObject) -> *mut DzlPropertiesGroup;
pub fn dzl_properties_group_new_for_type(object_type: GType) -> *mut DzlPropertiesGroup;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_properties_group_add_all_properties(self_: *mut DzlPropertiesGroup);
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_properties_group_add_property(
self_: *mut DzlPropertiesGroup,
name: *const c_char,
property_name: *const c_char,
);
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_properties_group_add_property_full(
self_: *mut DzlPropertiesGroup,
name: *const c_char,
property_name: *const c_char,
flags: DzlPropertiesFlags,
);
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_properties_group_remove(self_: *mut DzlPropertiesGroup, name: *const c_char);
pub fn dzl_radio_box_get_type() -> GType;
pub fn dzl_radio_box_new() -> *mut gtk::GtkWidget;
pub fn dzl_radio_box_add_item(self_: *mut DzlRadioBox, id: *const c_char, text: *const c_char);
pub fn dzl_radio_box_get_active_id(self_: *mut DzlRadioBox) -> *const c_char;
pub fn dzl_radio_box_remove_item(self_: *mut DzlRadioBox, id: *const c_char);
pub fn dzl_radio_box_set_active_id(self_: *mut DzlRadioBox, id: *const c_char);
pub fn dzl_read_only_list_model_get_type() -> GType;
#[cfg(any(feature = "v3_30", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_30")))]
pub fn dzl_read_only_list_model_new(base_model: *mut gio::GListModel) -> *mut gio::GListModel;
pub fn dzl_recursive_file_monitor_get_type() -> GType;
pub fn dzl_recursive_file_monitor_new(root: *mut gio::GFile) -> *mut DzlRecursiveFileMonitor;
#[cfg(any(feature = "v3_28", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_28")))]
pub fn dzl_recursive_file_monitor_cancel(self_: *mut DzlRecursiveFileMonitor);
#[cfg(any(feature = "v3_28", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_28")))]
pub fn dzl_recursive_file_monitor_get_root(
self_: *mut DzlRecursiveFileMonitor,
) -> *mut gio::GFile;
#[cfg(any(feature = "v3_28", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_28")))]
pub fn dzl_recursive_file_monitor_set_ignore_func(
self_: *mut DzlRecursiveFileMonitor,
ignore_func: DzlRecursiveIgnoreFunc,
ignore_func_data: gpointer,
ignore_func_data_destroy: glib::GDestroyNotify,
);
pub fn dzl_recursive_file_monitor_start_async(
self_: *mut DzlRecursiveFileMonitor,
cancellable: *mut gio::GCancellable,
callback: gio::GAsyncReadyCallback,
user_data: gpointer,
);
pub fn dzl_recursive_file_monitor_start_finish(
self_: *mut DzlRecursiveFileMonitor,
result: *mut gio::GAsyncResult,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_scrolled_window_get_type() -> GType;
pub fn dzl_search_bar_get_type() -> GType;
pub fn dzl_search_bar_new() -> *mut gtk::GtkWidget;
pub fn dzl_search_bar_get_entry(self_: *mut DzlSearchBar) -> *mut gtk::GtkSearchEntry;
pub fn dzl_search_bar_get_search_mode_enabled(self_: *mut DzlSearchBar) -> gboolean;
pub fn dzl_search_bar_get_show_close_button(self_: *mut DzlSearchBar) -> gboolean;
pub fn dzl_search_bar_set_search_mode_enabled(
self_: *mut DzlSearchBar,
search_mode_enabled: gboolean,
);
pub fn dzl_search_bar_set_show_close_button(
self_: *mut DzlSearchBar,
show_close_button: gboolean,
);
pub fn dzl_settings_flag_action_get_type() -> GType;
pub fn dzl_settings_flag_action_new(
schema_id: *const c_char,
schema_key: *const c_char,
flag_nick: *const c_char,
) -> *mut gio::GAction;
pub fn dzl_settings_sandwich_get_type() -> GType;
pub fn dzl_settings_sandwich_new(
schema_id: *const c_char,
path: *const c_char,
) -> *mut DzlSettingsSandwich;
pub fn dzl_settings_sandwich_append(
self_: *mut DzlSettingsSandwich,
settings: *mut gio::GSettings,
);
pub fn dzl_settings_sandwich_bind(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
object: gpointer,
property: *const c_char,
flags: gio::GSettingsBindFlags,
);
pub fn dzl_settings_sandwich_bind_with_mapping(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
object: gpointer,
property: *const c_char,
flags: gio::GSettingsBindFlags,
get_mapping: gio::GSettingsBindGetMapping,
set_mapping: gio::GSettingsBindSetMapping,
user_data: gpointer,
destroy: glib::GDestroyNotify,
);
pub fn dzl_settings_sandwich_get_boolean(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
) -> gboolean;
pub fn dzl_settings_sandwich_get_default_value(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
) -> *mut glib::GVariant;
pub fn dzl_settings_sandwich_get_double(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
) -> c_double;
pub fn dzl_settings_sandwich_get_int(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
) -> c_int;
pub fn dzl_settings_sandwich_get_string(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
) -> *mut c_char;
pub fn dzl_settings_sandwich_get_uint(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
) -> c_uint;
pub fn dzl_settings_sandwich_get_user_value(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
) -> *mut glib::GVariant;
pub fn dzl_settings_sandwich_get_value(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
) -> *mut glib::GVariant;
pub fn dzl_settings_sandwich_set_boolean(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
val: gboolean,
);
pub fn dzl_settings_sandwich_set_double(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
val: c_double,
);
pub fn dzl_settings_sandwich_set_int(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
val: c_int,
);
pub fn dzl_settings_sandwich_set_string(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
val: *const c_char,
);
pub fn dzl_settings_sandwich_set_uint(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
val: c_uint,
);
pub fn dzl_settings_sandwich_set_value(
self_: *mut DzlSettingsSandwich,
key: *const c_char,
value: *mut glib::GVariant,
);
pub fn dzl_settings_sandwich_unbind(self_: *mut DzlSettingsSandwich, property: *const c_char);
pub fn dzl_shortcut_accel_dialog_get_type() -> GType;
pub fn dzl_shortcut_accel_dialog_new() -> *mut gtk::GtkWidget;
pub fn dzl_shortcut_accel_dialog_get_accelerator(
self_: *mut DzlShortcutAccelDialog,
) -> *mut c_char;
pub fn dzl_shortcut_accel_dialog_get_chord(
self_: *mut DzlShortcutAccelDialog,
) -> *const DzlShortcutChord;
pub fn dzl_shortcut_accel_dialog_get_shortcut_title(
self_: *mut DzlShortcutAccelDialog,
) -> *const c_char;
pub fn dzl_shortcut_accel_dialog_set_accelerator(
self_: *mut DzlShortcutAccelDialog,
accelerator: *const c_char,
);
pub fn dzl_shortcut_accel_dialog_set_shortcut_title(
self_: *mut DzlShortcutAccelDialog,
title: *const c_char,
);
pub fn dzl_shortcut_context_get_type() -> GType;
pub fn dzl_shortcut_context_new(name: *const c_char) -> *mut DzlShortcutContext;
pub fn dzl_shortcut_context_activate(
self_: *mut DzlShortcutContext,
widget: *mut gtk::GtkWidget,
chord: *const DzlShortcutChord,
) -> DzlShortcutMatch;
pub fn dzl_shortcut_context_add_action(
self_: *mut DzlShortcutContext,
accel: *const c_char,
detailed_action_name: *const c_char,
);
pub fn dzl_shortcut_context_add_command(
self_: *mut DzlShortcutContext,
accel: *const c_char,
command: *const c_char,
);
pub fn dzl_shortcut_context_add_signal(
self_: *mut DzlShortcutContext,
accel: *const c_char,
signal_name: *const c_char,
n_args: c_uint,
...
);
pub fn dzl_shortcut_context_add_signalv(
self_: *mut DzlShortcutContext,
accel: *const c_char,
signal_name: *const c_char,
values: *mut glib::GArray,
);
pub fn dzl_shortcut_context_get_name(self_: *mut DzlShortcutContext) -> *const c_char;
pub fn dzl_shortcut_context_load_from_data(
self_: *mut DzlShortcutContext,
data: *const c_char,
len: ssize_t,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_shortcut_context_load_from_resource(
self_: *mut DzlShortcutContext,
resource_path: *const c_char,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_shortcut_context_remove(
self_: *mut DzlShortcutContext,
accel: *const c_char,
) -> gboolean;
pub fn dzl_shortcut_controller_get_type() -> GType;
pub fn dzl_shortcut_controller_new(widget: *mut gtk::GtkWidget) -> *mut DzlShortcutController;
pub fn dzl_shortcut_controller_find(widget: *mut gtk::GtkWidget) -> *mut DzlShortcutController;
pub fn dzl_shortcut_controller_try_find(
widget: *mut gtk::GtkWidget,
) -> *mut DzlShortcutController;
pub fn dzl_shortcut_controller_add_command_action(
self_: *mut DzlShortcutController,
command_id: *const c_char,
default_accel: *const c_char,
phase: DzlShortcutPhase,
action: *const c_char,
);
pub fn dzl_shortcut_controller_add_command_callback(
self_: *mut DzlShortcutController,
command_id: *const c_char,
default_accel: *const c_char,
phase: DzlShortcutPhase,
callback: gtk::GtkCallback,
callback_data: gpointer,
callback_data_destroy: glib::GDestroyNotify,
);
pub fn dzl_shortcut_controller_add_command_signal(
self_: *mut DzlShortcutController,
command_id: *const c_char,
default_accel: *const c_char,
phase: DzlShortcutPhase,
signal_name: *const c_char,
n_args: c_uint,
...
);
pub fn dzl_shortcut_controller_execute_command(
self_: *mut DzlShortcutController,
command: *const c_char,
) -> gboolean;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_shortcut_controller_get_context(
self_: *mut DzlShortcutController,
) -> *mut DzlShortcutContext;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_shortcut_controller_get_context_for_phase(
self_: *mut DzlShortcutController,
phase: DzlShortcutPhase,
) -> *mut DzlShortcutContext;
pub fn dzl_shortcut_controller_get_current_chord(
self_: *mut DzlShortcutController,
) -> *const DzlShortcutChord;
pub fn dzl_shortcut_controller_get_manager(
self_: *mut DzlShortcutController,
) -> *mut DzlShortcutManager;
#[cfg(any(feature = "v3_34", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_34")))]
pub fn dzl_shortcut_controller_get_widget(
self_: *mut DzlShortcutController,
) -> *mut gtk::GtkWidget;
pub fn dzl_shortcut_controller_remove_accel(
self_: *mut DzlShortcutController,
accel: *const c_char,
phase: DzlShortcutPhase,
);
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_shortcut_controller_set_context_by_name(
self_: *mut DzlShortcutController,
name: *const c_char,
);
pub fn dzl_shortcut_controller_set_manager(
self_: *mut DzlShortcutController,
manager: *mut DzlShortcutManager,
);
pub fn dzl_shortcut_label_get_type() -> GType;
pub fn dzl_shortcut_label_new() -> *mut gtk::GtkWidget;
pub fn dzl_shortcut_label_get_accelerator(self_: *mut DzlShortcutLabel) -> *mut c_char;
pub fn dzl_shortcut_label_get_chord(self_: *mut DzlShortcutLabel) -> *const DzlShortcutChord;
pub fn dzl_shortcut_label_set_accelerator(
self_: *mut DzlShortcutLabel,
accelerator: *const c_char,
);
pub fn dzl_shortcut_label_set_chord(
self_: *mut DzlShortcutLabel,
chord: *const DzlShortcutChord,
);
pub fn dzl_shortcut_manager_get_type() -> GType;
pub fn dzl_shortcut_manager_get_default() -> *mut DzlShortcutManager;
pub fn dzl_shortcut_manager_add_action(
self_: *mut DzlShortcutManager,
detailed_action_name: *const c_char,
section: *const c_char,
group: *const c_char,
title: *const c_char,
subtitle: *const c_char,
);
pub fn dzl_shortcut_manager_add_command(
self_: *mut DzlShortcutManager,
command: *const c_char,
section: *const c_char,
group: *const c_char,
title: *const c_char,
subtitle: *const c_char,
);
pub fn dzl_shortcut_manager_add_shortcut_entries(
self_: *mut DzlShortcutManager,
shortcuts: *const DzlShortcutEntry,
n_shortcuts: c_uint,
translation_domain: *const c_char,
);
pub fn dzl_shortcut_manager_add_shortcuts_to_window(
self_: *mut DzlShortcutManager,
window: *mut DzlShortcutsWindow,
);
pub fn dzl_shortcut_manager_append_search_path(
self_: *mut DzlShortcutManager,
directory: *const c_char,
);
pub fn dzl_shortcut_manager_get_theme(self_: *mut DzlShortcutManager) -> *mut DzlShortcutTheme;
pub fn dzl_shortcut_manager_get_theme_by_name(
self_: *mut DzlShortcutManager,
theme_name: *const c_char,
) -> *mut DzlShortcutTheme;
pub fn dzl_shortcut_manager_get_theme_name(self_: *mut DzlShortcutManager) -> *const c_char;
pub fn dzl_shortcut_manager_get_user_dir(self_: *mut DzlShortcutManager) -> *const c_char;
pub fn dzl_shortcut_manager_handle_event(
self_: *mut DzlShortcutManager,
event: *const gdk::GdkEventKey,
toplevel: *mut gtk::GtkWidget,
) -> gboolean;
pub fn dzl_shortcut_manager_prepend_search_path(
self_: *mut DzlShortcutManager,
directory: *const c_char,
);
pub fn dzl_shortcut_manager_queue_reload(self_: *mut DzlShortcutManager);
pub fn dzl_shortcut_manager_reload(
self_: *mut DzlShortcutManager,
cancellable: *mut gio::GCancellable,
);
pub fn dzl_shortcut_manager_remove_search_path(
self_: *mut DzlShortcutManager,
directory: *const c_char,
);
pub fn dzl_shortcut_manager_set_theme(
self_: *mut DzlShortcutManager,
theme: *mut DzlShortcutTheme,
);
pub fn dzl_shortcut_manager_set_theme_name(
self_: *mut DzlShortcutManager,
theme_name: *const c_char,
);
pub fn dzl_shortcut_manager_set_user_dir(
self_: *mut DzlShortcutManager,
user_dir: *const c_char,
);
pub fn dzl_shortcut_model_get_type() -> GType;
pub fn dzl_shortcut_model_new() -> *mut gtk::GtkTreeModel;
pub fn dzl_shortcut_model_get_manager(self_: *mut DzlShortcutModel) -> *mut DzlShortcutManager;
pub fn dzl_shortcut_model_get_theme(self_: *mut DzlShortcutModel) -> *mut DzlShortcutTheme;
pub fn dzl_shortcut_model_rebuild(self_: *mut DzlShortcutModel);
pub fn dzl_shortcut_model_set_chord(
self_: *mut DzlShortcutModel,
iter: *mut gtk::GtkTreeIter,
chord: *const DzlShortcutChord,
);
pub fn dzl_shortcut_model_set_manager(
self_: *mut DzlShortcutModel,
manager: *mut DzlShortcutManager,
);
pub fn dzl_shortcut_model_set_theme(self_: *mut DzlShortcutModel, theme: *mut DzlShortcutTheme);
pub fn dzl_shortcut_simple_label_get_type() -> GType;
pub fn dzl_shortcut_simple_label_new() -> *mut gtk::GtkWidget;
pub fn dzl_shortcut_simple_label_get_accel(self_: *mut DzlShortcutSimpleLabel)
-> *const c_char;
pub fn dzl_shortcut_simple_label_get_action(
self_: *mut DzlShortcutSimpleLabel,
) -> *const c_char;
pub fn dzl_shortcut_simple_label_get_command(
self_: *mut DzlShortcutSimpleLabel,
) -> *const c_char;
pub fn dzl_shortcut_simple_label_get_title(self_: *mut DzlShortcutSimpleLabel)
-> *const c_char;
pub fn dzl_shortcut_simple_label_set_accel(
self_: *mut DzlShortcutSimpleLabel,
accel: *const c_char,
);
pub fn dzl_shortcut_simple_label_set_action(
self_: *mut DzlShortcutSimpleLabel,
action: *const c_char,
);
pub fn dzl_shortcut_simple_label_set_command(
self_: *mut DzlShortcutSimpleLabel,
command: *const c_char,
);
pub fn dzl_shortcut_simple_label_set_title(
self_: *mut DzlShortcutSimpleLabel,
title: *const c_char,
);
pub fn dzl_shortcut_theme_get_type() -> GType;
pub fn dzl_shortcut_theme_new(name: *const c_char) -> *mut DzlShortcutTheme;
pub fn dzl_shortcut_theme_add_command(
self_: *mut DzlShortcutTheme,
accelerator: *const c_char,
command: *const c_char,
);
pub fn dzl_shortcut_theme_add_context(
self_: *mut DzlShortcutTheme,
context: *mut DzlShortcutContext,
);
pub fn dzl_shortcut_theme_add_css_resource(self_: *mut DzlShortcutTheme, path: *const c_char);
pub fn dzl_shortcut_theme_find_context_by_name(
self_: *mut DzlShortcutTheme,
name: *const c_char,
) -> *mut DzlShortcutContext;
pub fn dzl_shortcut_theme_find_default_context(
self_: *mut DzlShortcutTheme,
widget: *mut gtk::GtkWidget,
) -> *mut DzlShortcutContext;
pub fn dzl_shortcut_theme_get_chord_for_action(
self_: *mut DzlShortcutTheme,
detailed_action_name: *const c_char,
) -> *const DzlShortcutChord;
pub fn dzl_shortcut_theme_get_chord_for_command(
self_: *mut DzlShortcutTheme,
command: *const c_char,
) -> *const DzlShortcutChord;
pub fn dzl_shortcut_theme_get_name(self_: *mut DzlShortcutTheme) -> *const c_char;
pub fn dzl_shortcut_theme_get_parent(self_: *mut DzlShortcutTheme) -> *mut DzlShortcutTheme;
pub fn dzl_shortcut_theme_get_parent_name(self_: *mut DzlShortcutTheme) -> *const c_char;
pub fn dzl_shortcut_theme_get_subtitle(self_: *mut DzlShortcutTheme) -> *const c_char;
pub fn dzl_shortcut_theme_get_title(self_: *mut DzlShortcutTheme) -> *const c_char;
pub fn dzl_shortcut_theme_load_from_data(
self_: *mut DzlShortcutTheme,
data: *const c_char,
len: ssize_t,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_shortcut_theme_load_from_file(
self_: *mut DzlShortcutTheme,
file: *mut gio::GFile,
cancellable: *mut gio::GCancellable,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_shortcut_theme_load_from_path(
self_: *mut DzlShortcutTheme,
path: *const c_char,
cancellable: *mut gio::GCancellable,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_shortcut_theme_remove_css_resource(
self_: *mut DzlShortcutTheme,
path: *const c_char,
);
pub fn dzl_shortcut_theme_save_to_file(
self_: *mut DzlShortcutTheme,
file: *mut gio::GFile,
cancellable: *mut gio::GCancellable,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_shortcut_theme_save_to_path(
self_: *mut DzlShortcutTheme,
path: *const c_char,
cancellable: *mut gio::GCancellable,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_shortcut_theme_save_to_stream(
self_: *mut DzlShortcutTheme,
stream: *mut gio::GOutputStream,
cancellable: *mut gio::GCancellable,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn dzl_shortcut_theme_set_accel_for_action(
self_: *mut DzlShortcutTheme,
detailed_action_name: *const c_char,
accel: *const c_char,
phase: DzlShortcutPhase,
);
pub fn dzl_shortcut_theme_set_accel_for_command(
self_: *mut DzlShortcutTheme,
command: *const c_char,
accel: *const c_char,
phase: DzlShortcutPhase,
);
pub fn dzl_shortcut_theme_set_chord_for_action(
self_: *mut DzlShortcutTheme,
detailed_action_name: *const c_char,
chord: *const DzlShortcutChord,
phase: DzlShortcutPhase,
);
pub fn dzl_shortcut_theme_set_chord_for_command(
self_: *mut DzlShortcutTheme,
command: *const c_char,
chord: *const DzlShortcutChord,
phase: DzlShortcutPhase,
);
pub fn dzl_shortcut_theme_set_parent_name(
self_: *mut DzlShortcutTheme,
parent_name: *const c_char,
);
pub fn dzl_shortcut_theme_editor_get_type() -> GType;
pub fn dzl_shortcut_theme_editor_new() -> *mut gtk::GtkWidget;
pub fn dzl_shortcut_theme_editor_get_theme(
self_: *mut DzlShortcutThemeEditor,
) -> *mut DzlShortcutTheme;
pub fn dzl_shortcut_theme_editor_set_theme(
self_: *mut DzlShortcutThemeEditor,
theme: *mut DzlShortcutTheme,
);
pub fn dzl_shortcut_tooltip_get_type() -> GType;
#[cfg(any(feature = "v3_32", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_32")))]
pub fn dzl_shortcut_tooltip_new() -> *mut DzlShortcutTooltip;
#[cfg(any(feature = "v3_32", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_32")))]
pub fn dzl_shortcut_tooltip_get_accel(self_: *mut DzlShortcutTooltip) -> *const c_char;
#[cfg(any(feature = "v3_32", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_32")))]
pub fn dzl_shortcut_tooltip_get_command_id(self_: *mut DzlShortcutTooltip) -> *const c_char;
#[cfg(any(feature = "v3_32", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_32")))]
pub fn dzl_shortcut_tooltip_get_title(self_: *mut DzlShortcutTooltip) -> *const c_char;
#[cfg(any(feature = "v3_32", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_32")))]
pub fn dzl_shortcut_tooltip_get_widget(self_: *mut DzlShortcutTooltip) -> *mut gtk::GtkWidget;
#[cfg(any(feature = "v3_32", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_32")))]
pub fn dzl_shortcut_tooltip_set_accel(self_: *mut DzlShortcutTooltip, accel: *const c_char);
#[cfg(any(feature = "v3_32", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_32")))]
pub fn dzl_shortcut_tooltip_set_command_id(
self_: *mut DzlShortcutTooltip,
command_id: *const c_char,
);
#[cfg(any(feature = "v3_32", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_32")))]
pub fn dzl_shortcut_tooltip_set_title(self_: *mut DzlShortcutTooltip, title: *const c_char);
#[cfg(any(feature = "v3_32", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_32")))]
pub fn dzl_shortcut_tooltip_set_widget(
self_: *mut DzlShortcutTooltip,
widget: *mut gtk::GtkWidget,
);
pub fn dzl_shortcuts_group_get_type() -> GType;
pub fn dzl_shortcuts_section_get_type() -> GType;
pub fn dzl_shortcuts_shortcut_get_type() -> GType;
pub fn dzl_shortcuts_window_get_type() -> GType;
pub fn dzl_signal_group_get_type() -> GType;
pub fn dzl_signal_group_new(target_type: GType) -> *mut DzlSignalGroup;
pub fn dzl_signal_group_block(self_: *mut DzlSignalGroup);
pub fn dzl_signal_group_connect(
self_: *mut DzlSignalGroup,
detailed_signal: *const c_char,
c_handler: gobject::GCallback,
data: gpointer,
);
pub fn dzl_signal_group_connect_after(
self_: *mut DzlSignalGroup,
detailed_signal: *const c_char,
c_handler: gobject::GCallback,
data: gpointer,
);
pub fn dzl_signal_group_connect_data(
self_: *mut DzlSignalGroup,
detailed_signal: *const c_char,
c_handler: gobject::GCallback,
data: gpointer,
notify: gobject::GClosureNotify,
flags: gobject::GConnectFlags,
);
pub fn dzl_signal_group_connect_object(
self_: *mut DzlSignalGroup,
detailed_signal: *const c_char,
c_handler: gobject::GCallback,
object: gpointer,
flags: gobject::GConnectFlags,
);
pub fn dzl_signal_group_connect_swapped(
self_: *mut DzlSignalGroup,
detailed_signal: *const c_char,
c_handler: gobject::GCallback,
data: gpointer,
);
pub fn dzl_signal_group_get_target(self_: *mut DzlSignalGroup) -> *mut gobject::GObject;
pub fn dzl_signal_group_set_target(self_: *mut DzlSignalGroup, target: *mut gobject::GObject);
pub fn dzl_signal_group_unblock(self_: *mut DzlSignalGroup);
pub fn dzl_simple_label_get_type() -> GType;
pub fn dzl_simple_label_new(label: *const c_char) -> *mut gtk::GtkWidget;
pub fn dzl_simple_label_get_label(self_: *mut DzlSimpleLabel) -> *const c_char;
pub fn dzl_simple_label_get_width_chars(self_: *mut DzlSimpleLabel) -> c_int;
pub fn dzl_simple_label_get_xalign(self_: *mut DzlSimpleLabel) -> c_float;
pub fn dzl_simple_label_set_label(self_: *mut DzlSimpleLabel, label: *const c_char);
pub fn dzl_simple_label_set_width_chars(self_: *mut DzlSimpleLabel, width_chars: c_int);
pub fn dzl_simple_label_set_xalign(self_: *mut DzlSimpleLabel, xalign: c_float);
pub fn dzl_simple_popover_get_type() -> GType;
pub fn dzl_simple_popover_new() -> *mut gtk::GtkWidget;
pub fn dzl_simple_popover_get_button_text(self_: *mut DzlSimplePopover) -> *const c_char;
pub fn dzl_simple_popover_get_message(self_: *mut DzlSimplePopover) -> *const c_char;
pub fn dzl_simple_popover_get_ready(self_: *mut DzlSimplePopover) -> gboolean;
pub fn dzl_simple_popover_get_text(self_: *mut DzlSimplePopover) -> *const c_char;
pub fn dzl_simple_popover_get_title(self_: *mut DzlSimplePopover) -> *const c_char;
pub fn dzl_simple_popover_set_button_text(
self_: *mut DzlSimplePopover,
button_text: *const c_char,
);
pub fn dzl_simple_popover_set_message(self_: *mut DzlSimplePopover, message: *const c_char);
pub fn dzl_simple_popover_set_ready(self_: *mut DzlSimplePopover, ready: gboolean);
pub fn dzl_simple_popover_set_text(self_: *mut DzlSimplePopover, text: *const c_char);
pub fn dzl_simple_popover_set_title(self_: *mut DzlSimplePopover, title: *const c_char);
pub fn dzl_slider_get_type() -> GType;
pub fn dzl_slider_new() -> *mut gtk::GtkWidget;
pub fn dzl_slider_add_slider(
self_: *mut DzlSlider,
widget: *mut gtk::GtkWidget,
position: DzlSliderPosition,
);
pub fn dzl_slider_get_position(self_: *mut DzlSlider) -> DzlSliderPosition;
pub fn dzl_slider_set_position(self_: *mut DzlSlider, position: DzlSliderPosition);
pub fn dzl_stack_list_get_type() -> GType;
pub fn dzl_stack_list_new() -> *mut gtk::GtkWidget;
pub fn dzl_stack_list_clear(self_: *mut DzlStackList);
pub fn dzl_stack_list_get_depth(self_: *mut DzlStackList) -> c_uint;
pub fn dzl_stack_list_get_model(self_: *mut DzlStackList) -> *mut gio::GListModel;
pub fn dzl_stack_list_pop(self_: *mut DzlStackList);
pub fn dzl_stack_list_push(
self_: *mut DzlStackList,
header: *mut gtk::GtkWidget,
model: *mut gio::GListModel,
create_widget_func: DzlStackListCreateWidgetFunc,
user_data: gpointer,
user_data_free_func: glib::GDestroyNotify,
);
pub fn dzl_state_machine_get_type() -> GType;
pub fn dzl_state_machine_new() -> *mut DzlStateMachine;
pub fn dzl_state_machine_buildable_iface_init(iface: *mut gtk::GtkBuildableIface);
pub fn dzl_state_machine_add_binding(
self_: *mut DzlStateMachine,
state: *const c_char,
source_object: gpointer,
source_property: *const c_char,
target_object: gpointer,
target_property: *const c_char,
flags: gobject::GBindingFlags,
);
pub fn dzl_state_machine_add_property(
self_: *mut DzlStateMachine,
state: *const c_char,
object: gpointer,
property: *const c_char,
...
);
pub fn dzl_state_machine_add_propertyv(
self_: *mut DzlStateMachine,
state: *const c_char,
object: gpointer,
property: *const c_char,
value: *const gobject::GValue,
);
pub fn dzl_state_machine_add_style(
self_: *mut DzlStateMachine,
state: *const c_char,
widget: *mut gtk::GtkWidget,
style: *const c_char,
);
pub fn dzl_state_machine_connect_object(
self_: *mut DzlStateMachine,
state: *const c_char,
source: gpointer,
detailed_signal: *const c_char,
callback: gobject::GCallback,
user_data: gpointer,
flags: gobject::GConnectFlags,
);
pub fn dzl_state_machine_create_action(
self_: *mut DzlStateMachine,
name: *const c_char,
) -> *mut gio::GAction;
pub fn dzl_state_machine_get_state(self_: *mut DzlStateMachine) -> *const c_char;
#[cfg(any(feature = "v3_28", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_28")))]
pub fn dzl_state_machine_is_state(
self_: *mut DzlStateMachine,
state: *const c_char,
) -> gboolean;
pub fn dzl_state_machine_set_state(self_: *mut DzlStateMachine, state: *const c_char);
pub fn dzl_suggestion_get_type() -> GType;
pub fn dzl_suggestion_new() -> *mut DzlSuggestion;
#[cfg(any(feature = "v3_30", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_30")))]
pub fn dzl_suggestion_get_icon(self_: *mut DzlSuggestion) -> *mut gio::GIcon;
pub fn dzl_suggestion_get_icon_name(self_: *mut DzlSuggestion) -> *const c_char;
#[cfg(any(feature = "v3_30", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_30")))]
pub fn dzl_suggestion_get_icon_surface(
self_: *mut DzlSuggestion,
widget: *mut gtk::GtkWidget,
) -> *mut cairo::cairo_surface_t;
pub fn dzl_suggestion_get_id(self_: *mut DzlSuggestion) -> *const c_char;
#[cfg(any(feature = "v3_36", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_36")))]
pub fn dzl_suggestion_get_secondary_icon(self_: *mut DzlSuggestion) -> *mut gio::GIcon;
pub fn dzl_suggestion_get_secondary_icon_name(self_: *mut DzlSuggestion) -> *const c_char;
#[cfg(any(feature = "v3_36", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_36")))]
pub fn dzl_suggestion_get_secondary_icon_surface(
self_: *mut DzlSuggestion,
widget: *mut gtk::GtkWidget,
) -> *mut cairo::cairo_surface_t;
pub fn dzl_suggestion_get_subtitle(self_: *mut DzlSuggestion) -> *const c_char;
pub fn dzl_suggestion_get_title(self_: *mut DzlSuggestion) -> *const c_char;
pub fn dzl_suggestion_replace_typed_text(
self_: *mut DzlSuggestion,
typed_text: *const c_char,
) -> *mut c_char;
pub fn dzl_suggestion_set_icon_name(self_: *mut DzlSuggestion, icon_name: *const c_char);
pub fn dzl_suggestion_set_id(self_: *mut DzlSuggestion, id: *const c_char);
pub fn dzl_suggestion_set_secondary_icon_name(
self_: *mut DzlSuggestion,
icon_name: *const c_char,
);
pub fn dzl_suggestion_set_subtitle(self_: *mut DzlSuggestion, subtitle: *const c_char);
pub fn dzl_suggestion_set_title(self_: *mut DzlSuggestion, title: *const c_char);
pub fn dzl_suggestion_suggest_suffix(
self_: *mut DzlSuggestion,
typed_text: *const c_char,
) -> *mut c_char;
pub fn dzl_suggestion_button_get_type() -> GType;
pub fn dzl_suggestion_button_new() -> *mut gtk::GtkWidget;
#[cfg(any(feature = "v3_34", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_34")))]
pub fn dzl_suggestion_button_get_button(self_: *mut DzlSuggestionButton)
-> *mut gtk::GtkButton;
#[cfg(any(feature = "v3_34", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_34")))]
pub fn dzl_suggestion_button_get_entry(
self_: *mut DzlSuggestionButton,
) -> *mut DzlSuggestionEntry;
pub fn dzl_suggestion_entry_get_type() -> GType;
pub fn dzl_suggestion_entry_new() -> *mut gtk::GtkWidget;
pub fn dzl_suggestion_entry_default_position_func(
self_: *mut DzlSuggestionEntry,
area: *mut gdk::GdkRectangle,
is_absolute: *mut gboolean,
user_data: gpointer,
);
pub fn dzl_suggestion_entry_get_activate_on_single_click(
self_: *mut DzlSuggestionEntry,
) -> gboolean;
#[cfg(any(feature = "v3_34", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_34")))]
pub fn dzl_suggestion_entry_get_compact(self_: *mut DzlSuggestionEntry) -> gboolean;
pub fn dzl_suggestion_entry_get_model(self_: *mut DzlSuggestionEntry) -> *mut gio::GListModel;
#[cfg(any(feature = "v3_32", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_32")))]
pub fn dzl_suggestion_entry_get_popover(self_: *mut DzlSuggestionEntry) -> *mut gtk::GtkWidget;
pub fn dzl_suggestion_entry_get_suggestion(
self_: *mut DzlSuggestionEntry,
) -> *mut DzlSuggestion;
pub fn dzl_suggestion_entry_get_typed_text(self_: *mut DzlSuggestionEntry) -> *const c_char;
pub fn dzl_suggestion_entry_hide_suggestions(self_: *mut DzlSuggestionEntry);
pub fn dzl_suggestion_entry_set_activate_on_single_click(
self_: *mut DzlSuggestionEntry,
activate_on_single_click: gboolean,
);
#[cfg(any(feature = "v3_34", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_34")))]
pub fn dzl_suggestion_entry_set_compact(self_: *mut DzlSuggestionEntry, compact: gboolean);
pub fn dzl_suggestion_entry_set_model(
self_: *mut DzlSuggestionEntry,
model: *mut gio::GListModel,
);
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_suggestion_entry_set_position_func(
self_: *mut DzlSuggestionEntry,
func: DzlSuggestionPositionFunc,
func_data: gpointer,
func_data_destroy: glib::GDestroyNotify,
);
pub fn dzl_suggestion_entry_set_suggestion(
self_: *mut DzlSuggestionEntry,
suggestion: *mut DzlSuggestion,
);
pub fn dzl_suggestion_entry_window_position_func(
self_: *mut DzlSuggestionEntry,
area: *mut gdk::GdkRectangle,
is_absolute: *mut gboolean,
user_data: gpointer,
);
pub fn dzl_suggestion_entry_buffer_get_type() -> GType;
pub fn dzl_suggestion_entry_buffer_new() -> *mut DzlSuggestionEntryBuffer;
pub fn dzl_suggestion_entry_buffer_clear(self_: *mut DzlSuggestionEntryBuffer);
pub fn dzl_suggestion_entry_buffer_commit(self_: *mut DzlSuggestionEntryBuffer);
pub fn dzl_suggestion_entry_buffer_get_suggestion(
self_: *mut DzlSuggestionEntryBuffer,
) -> *mut DzlSuggestion;
pub fn dzl_suggestion_entry_buffer_get_typed_length(
self_: *mut DzlSuggestionEntryBuffer,
) -> c_uint;
pub fn dzl_suggestion_entry_buffer_get_typed_text(
self_: *mut DzlSuggestionEntryBuffer,
) -> *const c_char;
pub fn dzl_suggestion_entry_buffer_set_suggestion(
self_: *mut DzlSuggestionEntryBuffer,
suggestion: *mut DzlSuggestion,
);
pub fn dzl_suggestion_popover_get_type() -> GType;
pub fn dzl_suggestion_popover_new() -> *mut gtk::GtkWidget;
pub fn dzl_suggestion_popover_activate_selected(self_: *mut DzlSuggestionPopover);
pub fn dzl_suggestion_popover_get_model(
self_: *mut DzlSuggestionPopover,
) -> *mut gio::GListModel;
pub fn dzl_suggestion_popover_get_relative_to(
self_: *mut DzlSuggestionPopover,
) -> *mut gtk::GtkWidget;
pub fn dzl_suggestion_popover_get_selected(
self_: *mut DzlSuggestionPopover,
) -> *mut DzlSuggestion;
pub fn dzl_suggestion_popover_move_by(self_: *mut DzlSuggestionPopover, amount: c_int);
pub fn dzl_suggestion_popover_popdown(self_: *mut DzlSuggestionPopover);
pub fn dzl_suggestion_popover_popup(self_: *mut DzlSuggestionPopover);
pub fn dzl_suggestion_popover_set_model(
self_: *mut DzlSuggestionPopover,
model: *mut gio::GListModel,
);
pub fn dzl_suggestion_popover_set_relative_to(
self_: *mut DzlSuggestionPopover,
widget: *mut gtk::GtkWidget,
);
pub fn dzl_suggestion_popover_set_selected(
self_: *mut DzlSuggestionPopover,
suggestion: *mut DzlSuggestion,
);
pub fn dzl_suggestion_row_get_type() -> GType;
pub fn dzl_suggestion_row_new() -> *mut gtk::GtkWidget;
pub fn dzl_suggestion_row_get_suggestion(self_: *mut DzlSuggestionRow) -> *mut DzlSuggestion;
pub fn dzl_suggestion_row_set_suggestion(
self_: *mut DzlSuggestionRow,
suggestion: *mut DzlSuggestion,
);
pub fn dzl_tab_get_type() -> GType;
pub fn dzl_tab_get_active(self_: *mut DzlTab) -> gboolean;
pub fn dzl_tab_get_can_close(self_: *mut DzlTab) -> gboolean;
pub fn dzl_tab_get_edge(self_: *mut DzlTab) -> gtk::GtkPositionType;
pub fn dzl_tab_get_icon_name(self_: *mut DzlTab) -> *const c_char;
pub fn dzl_tab_get_style(self_: *mut DzlTab) -> DzlTabStyle;
pub fn dzl_tab_get_title(self_: *mut DzlTab) -> *const c_char;
pub fn dzl_tab_get_widget(self_: *mut DzlTab) -> *mut gtk::GtkWidget;
pub fn dzl_tab_set_active(self_: *mut DzlTab, active: gboolean);
pub fn dzl_tab_set_can_close(self_: *mut DzlTab, can_close: gboolean);
pub fn dzl_tab_set_edge(self_: *mut DzlTab, edge: gtk::GtkPositionType);
pub fn dzl_tab_set_gicon(self_: *mut DzlTab, gicon: *mut gio::GIcon);
pub fn dzl_tab_set_icon_name(self_: *mut DzlTab, icon_name: *const c_char);
pub fn dzl_tab_set_style(self_: *mut DzlTab, style: DzlTabStyle);
pub fn dzl_tab_set_title(self_: *mut DzlTab, title: *const c_char);
pub fn dzl_tab_set_widget(self_: *mut DzlTab, widget: *mut gtk::GtkWidget);
pub fn dzl_tab_strip_get_type() -> GType;
pub fn dzl_tab_strip_new() -> *mut gtk::GtkWidget;
pub fn dzl_tab_strip_add_control(self_: *mut DzlTabStrip, widget: *mut gtk::GtkWidget);
pub fn dzl_tab_strip_get_edge(self_: *mut DzlTabStrip) -> gtk::GtkPositionType;
pub fn dzl_tab_strip_get_stack(self_: *mut DzlTabStrip) -> *mut gtk::GtkStack;
pub fn dzl_tab_strip_get_style(self_: *mut DzlTabStrip) -> DzlTabStyle;
pub fn dzl_tab_strip_set_edge(self_: *mut DzlTabStrip, edge: gtk::GtkPositionType);
pub fn dzl_tab_strip_set_stack(self_: *mut DzlTabStrip, stack: *mut gtk::GtkStack);
pub fn dzl_tab_strip_set_style(self_: *mut DzlTabStrip, style: DzlTabStyle);
pub fn dzl_task_cache_get_type() -> GType;
pub fn dzl_task_cache_new(
key_hash_func: glib::GHashFunc,
key_equal_func: glib::GEqualFunc,
key_copy_func: gobject::GBoxedCopyFunc,
key_destroy_func: gobject::GBoxedFreeFunc,
value_copy_func: gobject::GBoxedCopyFunc,
value_free_func: gobject::GBoxedFreeFunc,
time_to_live_msec: i64,
populate_callback: DzlTaskCacheCallback,
populate_callback_data: gpointer,
populate_callback_data_destroy: glib::GDestroyNotify,
) -> *mut DzlTaskCache;
pub fn dzl_task_cache_evict(self_: *mut DzlTaskCache, key: gconstpointer) -> gboolean;
pub fn dzl_task_cache_evict_all(self_: *mut DzlTaskCache);
pub fn dzl_task_cache_get_async(
self_: *mut DzlTaskCache,
key: gconstpointer,
force_update: gboolean,
cancellable: *mut gio::GCancellable,
callback: gio::GAsyncReadyCallback,
user_data: gpointer,
);
pub fn dzl_task_cache_get_finish(
self_: *mut DzlTaskCache,
result: *mut gio::GAsyncResult,
error: *mut *mut glib::GError,
) -> gpointer;
pub fn dzl_task_cache_get_values(self_: *mut DzlTaskCache) -> *mut glib::GPtrArray;
pub fn dzl_task_cache_peek(
self_: *mut DzlTaskCache,
key: gconstpointer,
) -> *mut gobject::GObject;
pub fn dzl_task_cache_set_name(self_: *mut DzlTaskCache, name: *const c_char);
pub fn dzl_theme_manager_get_type() -> GType;
pub fn dzl_theme_manager_new() -> *mut DzlThemeManager;
pub fn dzl_theme_manager_add_resources(
self_: *mut DzlThemeManager,
resource_path: *const c_char,
);
pub fn dzl_theme_manager_remove_resources(
self_: *mut DzlThemeManager,
resource_path: *const c_char,
);
pub fn dzl_three_grid_get_type() -> GType;
pub fn dzl_three_grid_new() -> *mut gtk::GtkWidget;
pub fn dzl_tree_get_type() -> GType;
pub fn dzl_tree_add_builder(self_: *mut DzlTree, builder: *mut DzlTreeBuilder);
pub fn dzl_tree_expand_to_node(self_: *mut DzlTree, node: *mut DzlTreeNode);
pub fn dzl_tree_find_child_node(
self_: *mut DzlTree,
node: *mut DzlTreeNode,
find_func: DzlTreeFindFunc,
user_data: gpointer,
) -> *mut DzlTreeNode;
pub fn dzl_tree_find_custom(
self_: *mut DzlTree,
equal_func: glib::GEqualFunc,
key: gpointer,
) -> *mut DzlTreeNode;
pub fn dzl_tree_find_item(self_: *mut DzlTree, item: *mut gobject::GObject)
-> *mut DzlTreeNode;
pub fn dzl_tree_get_context_menu(self_: *mut DzlTree) -> *mut gio::GMenuModel;
pub fn dzl_tree_get_root(self_: *mut DzlTree) -> *mut DzlTreeNode;
pub fn dzl_tree_get_selected(self_: *mut DzlTree) -> *mut DzlTreeNode;
pub fn dzl_tree_get_show_icons(self_: *mut DzlTree) -> gboolean;
pub fn dzl_tree_rebuild(self_: *mut DzlTree);
pub fn dzl_tree_remove_builder(self_: *mut DzlTree, builder: *mut DzlTreeBuilder);
pub fn dzl_tree_scroll_to_node(self_: *mut DzlTree, node: *mut DzlTreeNode);
pub fn dzl_tree_set_context_menu(self_: *mut DzlTree, context_menu: *mut gio::GMenuModel);
pub fn dzl_tree_set_filter(
self_: *mut DzlTree,
filter_func: DzlTreeFilterFunc,
filter_data: gpointer,
filter_data_destroy: glib::GDestroyNotify,
);
pub fn dzl_tree_set_root(self_: *mut DzlTree, node: *mut DzlTreeNode);
pub fn dzl_tree_set_show_icons(self_: *mut DzlTree, show_icons: gboolean);
pub fn dzl_tree_unselect_all(self_: *mut DzlTree);
pub fn dzl_tree_builder_get_type() -> GType;
pub fn dzl_tree_builder_new() -> *mut DzlTreeBuilder;
pub fn dzl_tree_builder_get_tree(builder: *mut DzlTreeBuilder) -> *mut DzlTree;
pub fn dzl_tree_node_get_type() -> GType;
pub fn dzl_tree_node_new() -> *mut DzlTreeNode;
pub fn dzl_tree_node_add_emblem(self_: *mut DzlTreeNode, emblem_name: *const c_char);
pub fn dzl_tree_node_append(node: *mut DzlTreeNode, child: *mut DzlTreeNode);
pub fn dzl_tree_node_clear_emblems(self_: *mut DzlTreeNode);
pub fn dzl_tree_node_collapse(node: *mut DzlTreeNode);
pub fn dzl_tree_node_expand(node: *mut DzlTreeNode, expand_ancestors: gboolean) -> gboolean;
pub fn dzl_tree_node_get_area(node: *mut DzlTreeNode, area: *mut gdk::GdkRectangle);
pub fn dzl_tree_node_get_children_possible(self_: *mut DzlTreeNode) -> gboolean;
pub fn dzl_tree_node_get_expanded(node: *mut DzlTreeNode) -> gboolean;
#[cfg(any(feature = "v3_28", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_28")))]
pub fn dzl_tree_node_get_foreground_rgba(self_: *mut DzlTreeNode) -> *const gdk::GdkRGBA;
pub fn dzl_tree_node_get_gicon(self_: *mut DzlTreeNode) -> *mut gio::GIcon;
pub fn dzl_tree_node_get_icon_name(node: *mut DzlTreeNode) -> *const c_char;
pub fn dzl_tree_node_get_item(node: *mut DzlTreeNode) -> *mut gobject::GObject;
pub fn dzl_tree_node_get_iter(node: *mut DzlTreeNode, iter: *mut gtk::GtkTreeIter) -> gboolean;
pub fn dzl_tree_node_get_parent(node: *mut DzlTreeNode) -> *mut DzlTreeNode;
pub fn dzl_tree_node_get_path(node: *mut DzlTreeNode) -> *mut gtk::GtkTreePath;
pub fn dzl_tree_node_get_reset_on_collapse(self_: *mut DzlTreeNode) -> gboolean;
pub fn dzl_tree_node_get_text(node: *mut DzlTreeNode) -> *const c_char;
pub fn dzl_tree_node_get_tree(node: *mut DzlTreeNode) -> *mut DzlTree;
pub fn dzl_tree_node_get_use_dim_label(self_: *mut DzlTreeNode) -> gboolean;
pub fn dzl_tree_node_get_use_markup(self_: *mut DzlTreeNode) -> gboolean;
pub fn dzl_tree_node_has_emblem(
self_: *mut DzlTreeNode,
emblem_name: *const c_char,
) -> gboolean;
#[cfg(any(feature = "v3_28", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_28")))]
pub fn dzl_tree_node_insert(self_: *mut DzlTreeNode, child: *mut DzlTreeNode, position: c_uint);
pub fn dzl_tree_node_insert_sorted(
node: *mut DzlTreeNode,
child: *mut DzlTreeNode,
compare_func: DzlTreeNodeCompareFunc,
user_data: gpointer,
);
pub fn dzl_tree_node_invalidate(node: *mut DzlTreeNode);
pub fn dzl_tree_node_is_root(node: *mut DzlTreeNode) -> gboolean;
pub fn dzl_tree_node_n_children(self_: *mut DzlTreeNode) -> c_uint;
pub fn dzl_tree_node_nth_child(self_: *mut DzlTreeNode, nth: c_uint) -> *mut DzlTreeNode;
pub fn dzl_tree_node_prepend(node: *mut DzlTreeNode, child: *mut DzlTreeNode);
#[cfg(any(feature = "v3_28", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_28")))]
pub fn dzl_tree_node_rebuild(self_: *mut DzlTreeNode);
pub fn dzl_tree_node_remove(node: *mut DzlTreeNode, child: *mut DzlTreeNode);
pub fn dzl_tree_node_remove_emblem(self_: *mut DzlTreeNode, emblem_name: *const c_char);
pub fn dzl_tree_node_select(node: *mut DzlTreeNode);
pub fn dzl_tree_node_set_children_possible(
self_: *mut DzlTreeNode,
children_possible: gboolean,
);
pub fn dzl_tree_node_set_emblems(self_: *mut DzlTreeNode, emblems: *const *const c_char);
#[cfg(any(feature = "v3_28", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_28")))]
pub fn dzl_tree_node_set_foreground_rgba(
self_: *mut DzlTreeNode,
foreground_rgba: *const gdk::GdkRGBA,
);
pub fn dzl_tree_node_set_gicon(self_: *mut DzlTreeNode, icon: *mut gio::GIcon);
pub fn dzl_tree_node_set_icon_name(node: *mut DzlTreeNode, icon_name: *const c_char);
pub fn dzl_tree_node_set_item(node: *mut DzlTreeNode, item: *mut gobject::GObject);
pub fn dzl_tree_node_set_reset_on_collapse(
self_: *mut DzlTreeNode,
reset_on_collapse: gboolean,
);
pub fn dzl_tree_node_set_text(node: *mut DzlTreeNode, text: *const c_char);
pub fn dzl_tree_node_set_use_dim_label(self_: *mut DzlTreeNode, use_dim_label: gboolean);
pub fn dzl_tree_node_set_use_markup(self_: *mut DzlTreeNode, use_markup: gboolean);
pub fn dzl_tree_node_show_popover(node: *mut DzlTreeNode, popover: *mut gtk::GtkPopover);
pub fn dzl_widget_action_group_get_type() -> GType;
pub fn dzl_widget_action_group_attach(widget: *mut gtk::GtkWidget, group_name: *const c_char);
pub fn dzl_widget_action_group_new(widget: *mut gtk::GtkWidget) -> *mut gio::GActionGroup;
pub fn dzl_widget_action_group_set_action_enabled(
self_: *mut DzlWidgetActionGroup,
action_name: *const c_char,
enabled: gboolean,
);
pub fn dzl_dock_get_type() -> GType;
pub fn dzl_dock_item_get_type() -> GType;
pub fn dzl_dock_item_adopt(self_: *mut DzlDockItem, child: *mut DzlDockItem) -> gboolean;
pub fn dzl_dock_item_close(self_: *mut DzlDockItem) -> gboolean;
#[cfg(any(feature = "v3_30", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_30")))]
pub fn dzl_dock_item_emit_presented(self_: *mut DzlDockItem);
pub fn dzl_dock_item_get_can_close(self_: *mut DzlDockItem) -> gboolean;
pub fn dzl_dock_item_get_can_minimize(self_: *mut DzlDockItem) -> gboolean;
pub fn dzl_dock_item_get_child_visible(
self_: *mut DzlDockItem,
child: *mut DzlDockItem,
) -> gboolean;
pub fn dzl_dock_item_get_icon_name(self_: *mut DzlDockItem) -> *mut c_char;
pub fn dzl_dock_item_get_manager(self_: *mut DzlDockItem) -> *mut DzlDockManager;
pub fn dzl_dock_item_get_parent(self_: *mut DzlDockItem) -> *mut DzlDockItem;
pub fn dzl_dock_item_get_title(self_: *mut DzlDockItem) -> *mut c_char;
pub fn dzl_dock_item_has_widgets(self_: *mut DzlDockItem) -> gboolean;
pub fn dzl_dock_item_minimize(
self_: *mut DzlDockItem,
child: *mut DzlDockItem,
position: *mut gtk::GtkPositionType,
) -> gboolean;
#[cfg(any(feature = "v3_34", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_34")))]
pub fn dzl_dock_item_needs_attention(self_: *mut DzlDockItem);
pub fn dzl_dock_item_present(self_: *mut DzlDockItem);
pub fn dzl_dock_item_present_child(self_: *mut DzlDockItem, child: *mut DzlDockItem);
#[cfg(any(feature = "v3_34", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_34")))]
pub fn dzl_dock_item_ref_gicon(self_: *mut DzlDockItem) -> *mut gio::GIcon;
pub fn dzl_dock_item_release(self_: *mut DzlDockItem, child: *mut DzlDockItem);
pub fn dzl_dock_item_set_child_visible(
self_: *mut DzlDockItem,
child: *mut DzlDockItem,
child_visible: gboolean,
);
pub fn dzl_dock_item_set_manager(self_: *mut DzlDockItem, manager: *mut DzlDockManager);
pub fn dzl_dock_item_update_visibility(self_: *mut DzlDockItem);
pub fn dzl_graph_view_renderer_get_type() -> GType;
pub fn dzl_graph_view_renderer_render(
self_: *mut DzlGraphRenderer,
table: *mut DzlGraphModel,
x_begin: i64,
x_end: i64,
y_begin: c_double,
y_end: c_double,
cr: *mut cairo::cairo_t,
area: *const cairo::cairo_rectangle_int_t,
);
pub fn dzl_preferences_get_type() -> GType;
pub fn dzl_preferences_add_custom(
self_: *mut DzlPreferences,
page_name: *const c_char,
group_name: *const c_char,
widget: *mut gtk::GtkWidget,
keywords: *const c_char,
priority: c_int,
) -> c_uint;
pub fn dzl_preferences_add_file_chooser(
self_: *mut DzlPreferences,
page_name: *const c_char,
group_name: *const c_char,
schema_id: *const c_char,
key: *const c_char,
path: *const c_char,
title: *const c_char,
subtitle: *const c_char,
action: gtk::GtkFileChooserAction,
keywords: *const c_char,
priority: c_int,
) -> c_uint;
pub fn dzl_preferences_add_font_button(
self_: *mut DzlPreferences,
page_name: *const c_char,
group_name: *const c_char,
schema_id: *const c_char,
key: *const c_char,
title: *const c_char,
keywords: *const c_char,
priority: c_int,
) -> c_uint;
pub fn dzl_preferences_add_group(
self_: *mut DzlPreferences,
page_name: *const c_char,
group_name: *const c_char,
title: *const c_char,
priority: c_int,
);
pub fn dzl_preferences_add_list_group(
self_: *mut DzlPreferences,
page_name: *const c_char,
group_name: *const c_char,
title: *const c_char,
mode: gtk::GtkSelectionMode,
priority: c_int,
);
pub fn dzl_preferences_add_page(
self_: *mut DzlPreferences,
page_name: *const c_char,
title: *const c_char,
priority: c_int,
);
pub fn dzl_preferences_add_radio(
self_: *mut DzlPreferences,
page_name: *const c_char,
group_name: *const c_char,
schema_id: *const c_char,
key: *const c_char,
path: *const c_char,
variant_string: *const c_char,
title: *const c_char,
subtitle: *const c_char,
keywords: *const c_char,
priority: c_int,
) -> c_uint;
pub fn dzl_preferences_add_spin_button(
self_: *mut DzlPreferences,
page_name: *const c_char,
group_name: *const c_char,
schema_id: *const c_char,
key: *const c_char,
path: *const c_char,
title: *const c_char,
subtitle: *const c_char,
keywords: *const c_char,
priority: c_int,
) -> c_uint;
pub fn dzl_preferences_add_switch(
self_: *mut DzlPreferences,
page_name: *const c_char,
group_name: *const c_char,
schema_id: *const c_char,
key: *const c_char,
path: *const c_char,
variant_string: *const c_char,
title: *const c_char,
subtitle: *const c_char,
keywords: *const c_char,
priority: c_int,
) -> c_uint;
pub fn dzl_preferences_add_table_row(
self_: *mut DzlPreferences,
page_name: *const c_char,
group_name: *const c_char,
first_widget: *mut gtk::GtkWidget,
...
) -> c_uint;
pub fn dzl_preferences_get_widget(
self_: *mut DzlPreferences,
widget_id: c_uint,
) -> *mut gtk::GtkWidget;
pub fn dzl_preferences_remove_id(self_: *mut DzlPreferences, widget_id: c_uint) -> gboolean;
pub fn dzl_preferences_set_page(
self_: *mut DzlPreferences,
page_name: *const c_char,
map: *mut glib::GHashTable,
);
pub fn dzl_cairo_region_create_from_clip_extents(
cr: *mut cairo::cairo_t,
) -> *mut cairo::cairo_region_t;
pub fn dzl_cairo_rounded_rectangle(
cr: *mut cairo::cairo_t,
rect: *const gdk::GdkRectangle,
x_radius: c_int,
y_radius: c_int,
);
#[cfg(any(feature = "v3_28", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_28")))]
pub fn dzl_cancellable_chain(
self_: *mut gio::GCancellable,
other: *mut gio::GCancellable,
) -> *mut gio::GCancellable;
pub fn dzl_dnd_get_uri_list(selection_data: *mut gtk::GtkSelectionData) -> *mut *mut c_char;
pub fn dzl_file_manager_show(file: *mut gio::GFile, error: *mut *mut glib::GError) -> gboolean;
pub fn dzl_frame_source_add(
frames_per_sec: c_uint,
callback: glib::GSourceFunc,
user_data: gpointer,
) -> c_uint;
pub fn dzl_frame_source_add_full(
priority: c_int,
frames_per_sec: c_uint,
callback: glib::GSourceFunc,
user_data: gpointer,
notify: glib::GDestroyNotify,
) -> c_uint;
pub fn dzl_fuzzy_highlight(
str: *const c_char,
query: *const c_char,
case_sensitive: gboolean,
) -> *mut c_char;
pub fn dzl_g_date_time_format_for_display(self_: *mut glib::GDateTime) -> *mut c_char;
pub fn dzl_g_time_span_to_label(span: glib::GTimeSpan) -> *mut c_char;
pub fn dzl_g_time_span_to_label_mapping(
binding: *mut gobject::GBinding,
from_value: *const gobject::GValue,
to_value: *mut gobject::GValue,
user_data: gpointer,
) -> gboolean;
pub fn dzl_g_variant_hash(data: gconstpointer) -> c_uint;
pub fn dzl_gdk_synthesize_event_key(
window: *mut gdk::GdkWindow,
ch: u32,
) -> *mut gdk::GdkEventKey;
pub fn dzl_gdk_synthesize_event_keyval(
window: *mut gdk::GdkWindow,
keyval: c_uint,
) -> *mut gdk::GdkEventKey;
pub fn dzl_get_current_cpu_call() -> c_uint;
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_gtk_list_store_insert_sorted(
store: *mut gtk::GtkListStore,
iter: *mut gtk::GtkTreeIter,
key: gconstpointer,
compare_column: c_uint,
compare_func: glib::GCompareDataFunc,
compare_data: gpointer,
);
pub fn dzl_gtk_text_buffer_remove_tag(
buffer: *mut gtk::GtkTextBuffer,
tag: *mut gtk::GtkTextTag,
start: *const gtk::GtkTextIter,
end: *const gtk::GtkTextIter,
minimal_damage: gboolean,
);
pub fn dzl_gtk_widget_action(
widget: *mut gtk::GtkWidget,
group: *const c_char,
name: *const c_char,
param: *mut glib::GVariant,
) -> gboolean;
pub fn dzl_gtk_widget_action_set(
widget: *mut gtk::GtkWidget,
group: *const c_char,
name: *const c_char,
first_property: *const c_char,
...
);
pub fn dzl_gtk_widget_action_with_string(
widget: *mut gtk::GtkWidget,
group: *const c_char,
name: *const c_char,
param: *const c_char,
) -> gboolean;
pub fn dzl_gtk_widget_add_style_class(widget: *mut gtk::GtkWidget, class_name: *const c_char);
pub fn dzl_gtk_widget_find_child_typed(
widget: *mut gtk::GtkWidget,
type_: GType,
) -> *mut gtk::GtkWidget;
pub fn dzl_gtk_widget_get_relative(
widget: *mut gtk::GtkWidget,
relative_type: GType,
) -> *mut gtk::GtkWidget;
pub fn dzl_gtk_widget_hide_with_fade(widget: *mut gtk::GtkWidget);
#[cfg(any(feature = "v3_26", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_26")))]
pub fn dzl_gtk_widget_is_ancestor_or_relative(
widget: *mut gtk::GtkWidget,
ancestor: *mut gtk::GtkWidget,
) -> gboolean;
pub fn dzl_gtk_widget_mux_action_groups(
widget: *mut gtk::GtkWidget,
from_widget: *mut gtk::GtkWidget,
mux_key: *const c_char,
);
pub fn dzl_gtk_widget_remove_style_class(
widget: *mut gtk::GtkWidget,
class_name: *const c_char,
);
pub fn dzl_gtk_widget_show_with_fade(widget: *mut gtk::GtkWidget);
pub fn dzl_levenshtein(needle: *const c_char, haystack: *const c_char) -> c_int;
pub fn dzl_object_animate(
object: gpointer,
mode: DzlAnimationMode,
duration_msec: c_uint,
frame_clock: *mut gdk::GdkFrameClock,
first_property: *const c_char,
...
) -> *mut DzlAnimation;
pub fn dzl_object_animate_full(
object: gpointer,
mode: DzlAnimationMode,
duration_msec: c_uint,
frame_clock: *mut gdk::GdkFrameClock,
notify: glib::GDestroyNotify,
notify_data: gpointer,
first_property: *const c_char,
...
) -> *mut DzlAnimation;
pub fn dzl_overlay_add_child(
self_: *mut DzlDockOverlay,
child: *mut gtk::GtkWidget,
type_: *const c_char,
);
pub fn dzl_pango_font_description_to_css(
font_desc: *const pango::PangoFontDescription,
) -> *mut c_char;
pub fn dzl_rgba_shade(rgba: *const gdk::GdkRGBA, dst: *mut gdk::GdkRGBA, k: c_double);
pub fn dzl_shortcut_chord_table_get_type() -> GType;
}