libpanel_sys/

lib.rs

// Generated by gir (https://github.com/gtk-rs/gir @ 9eb6e0c1e572)
// from
// from gir-files (https://github.com/gtk-rs/gir-files.git @ 5c1e490fe50a)
// DO NOT EDIT

#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
    clippy::approx_constant,
    clippy::type_complexity,
    clippy::unreadable_literal,
    clippy::upper_case_acronyms
)]
#![cfg_attr(docsrs, feature(doc_cfg))]

use adw_sys as adw;
use gio_sys as gio;
use glib_sys as glib;
use gobject_sys as gobject;
use gtk_sys as gtk;

#[cfg(unix)]
#[allow(unused_imports)]
use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
#[allow(unused_imports)]
use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
#[allow(unused_imports)]
use std::ffi::{
    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
};

#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};

// Enums
pub type PanelArea = c_int;
pub const PANEL_AREA_START: PanelArea = 0;
pub const PANEL_AREA_END: PanelArea = 1;
pub const PANEL_AREA_TOP: PanelArea = 2;
pub const PANEL_AREA_BOTTOM: PanelArea = 3;
pub const PANEL_AREA_CENTER: PanelArea = 4;

// Constants
pub const PANEL_MAJOR_VERSION: c_int = 1;
pub const PANEL_MICRO_VERSION: c_int = 1;
pub const PANEL_MINOR_VERSION: c_int = 10;
pub const PANEL_VERSION_S: &[u8] = b"1.10.1\0";
pub const PANEL_WIDGET_KIND_ANY: &[u8] = b"*\0";
pub const PANEL_WIDGET_KIND_DOCUMENT: &[u8] = b"document\0";
pub const PANEL_WIDGET_KIND_UNKNOWN: &[u8] = b"unknown\0";
pub const PANEL_WIDGET_KIND_UTILITY: &[u8] = b"utility\0";

// Callbacks
pub type PanelActionActivateFunc =
    Option<unsafe extern "C" fn(gpointer, *const c_char, *mut glib::GVariant)>;
pub type PanelFrameCallback = Option<unsafe extern "C" fn(*mut PanelFrame, gpointer)>;
pub type PanelWorkspaceForeach = Option<unsafe extern "C" fn(*mut PanelWorkspace, gpointer)>;

// Records
#[repr(C)]
#[allow(dead_code)]
pub struct _PanelAction {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type PanelAction = _PanelAction;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelActionMuxerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PanelActionMuxerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelActionMuxerClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelApplicationClass {
    pub parent_class: adw::AdwApplicationClass,
    pub _reserved: [gpointer; 8],
}

impl ::std::fmt::Debug for PanelApplicationClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelApplicationClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelChangesDialogClass {
    pub parent_class: adw::AdwAlertDialogClass,
}

impl ::std::fmt::Debug for PanelChangesDialogClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelChangesDialogClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelDockClass {
    pub parent_class: gtk::GtkWidgetClass,
    pub panel_drag_begin: Option<unsafe extern "C" fn(*mut PanelDock, *mut PanelWidget)>,
    pub panel_drag_end: Option<unsafe extern "C" fn(*mut PanelDock, *mut PanelWidget)>,
}

impl ::std::fmt::Debug for PanelDockClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelDockClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("panel_drag_begin", &self.panel_drag_begin)
            .field("panel_drag_end", &self.panel_drag_end)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelDocumentWorkspaceClass {
    pub parent_class: PanelWorkspaceClass,
    pub create_frame: Option<
        unsafe extern "C" fn(*mut PanelDocumentWorkspace, *mut PanelPosition) -> *mut PanelFrame,
    >,
    pub add_widget: Option<
        unsafe extern "C" fn(
            *mut PanelDocumentWorkspace,
            *mut PanelWidget,
            *mut PanelPosition,
        ) -> gboolean,
    >,
    pub _reserved: [gpointer; 16],
}

impl ::std::fmt::Debug for PanelDocumentWorkspaceClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelDocumentWorkspaceClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("create_frame", &self.create_frame)
            .field("add_widget", &self.add_widget)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelFrameClass {
    pub parent_class: gtk::GtkWidgetClass,
    pub page_closed: Option<unsafe extern "C" fn(*mut PanelFrame, *mut PanelWidget)>,
    pub adopt_widget: Option<unsafe extern "C" fn(*mut PanelFrame, *mut PanelWidget) -> gboolean>,
    pub _reserved: [gpointer; 6],
}

impl ::std::fmt::Debug for PanelFrameClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelFrameClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("page_closed", &self.page_closed)
            .field("adopt_widget", &self.adopt_widget)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelFrameHeaderBarClass {
    pub parent_class: gtk::GtkWidgetClass,
}

impl ::std::fmt::Debug for PanelFrameHeaderBarClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelFrameHeaderBarClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelFrameHeaderInterface {
    pub parent_iface: gobject::GTypeInterface,
    pub page_changed: Option<unsafe extern "C" fn(*mut PanelFrameHeader, *mut PanelWidget)>,
    pub can_drop: Option<unsafe extern "C" fn(*mut PanelFrameHeader, *mut PanelWidget) -> gboolean>,
    pub add_prefix: Option<unsafe extern "C" fn(*mut PanelFrameHeader, c_int, *mut gtk::GtkWidget)>,
    pub add_suffix: Option<unsafe extern "C" fn(*mut PanelFrameHeader, c_int, *mut gtk::GtkWidget)>,
}

impl ::std::fmt::Debug for PanelFrameHeaderInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelFrameHeaderInterface @ {self:p}"))
            .field("parent_iface", &self.parent_iface)
            .field("page_changed", &self.page_changed)
            .field("can_drop", &self.can_drop)
            .field("add_prefix", &self.add_prefix)
            .field("add_suffix", &self.add_suffix)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelFrameSwitcherClass {
    pub parent_class: gtk::GtkWidgetClass,
}

impl ::std::fmt::Debug for PanelFrameSwitcherClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelFrameSwitcherClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelFrameTabBarClass {
    pub parent_class: gtk::GtkWidgetClass,
}

impl ::std::fmt::Debug for PanelFrameTabBarClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelFrameTabBarClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelGSettingsActionGroupClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PanelGSettingsActionGroupClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelGSettingsActionGroupClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelGridClass {
    pub parent_class: gtk::GtkWidgetClass,
    pub create_frame: Option<unsafe extern "C" fn(*mut PanelGrid) -> *mut PanelFrame>,
    pub _reserved: [gpointer; 12],
}

impl ::std::fmt::Debug for PanelGridClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelGridClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("create_frame", &self.create_frame)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelGridColumnClass {
    pub parent_class: gtk::GtkWidgetClass,
}

impl ::std::fmt::Debug for PanelGridColumnClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelGridColumnClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelInhibitorClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PanelInhibitorClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelInhibitorClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelLayeredSettingsClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PanelLayeredSettingsClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelLayeredSettingsClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelMenuManagerClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PanelMenuManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelMenuManagerClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelOmniBarClass {
    pub parent_class: gtk::GtkWidgetClass,
    pub _reserved: [gpointer; 8],
}

impl ::std::fmt::Debug for PanelOmniBarClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelOmniBarClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelPanedClass {
    pub parent_class: gtk::GtkWidgetClass,
}

impl ::std::fmt::Debug for PanelPanedClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelPanedClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelPositionClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PanelPositionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelPositionClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelSaveDelegateClass {
    pub parent_class: gobject::GObjectClass,
    pub save_async: Option<
        unsafe extern "C" fn(
            *mut PanelSaveDelegate,
            *mut gio::GCancellable,
            gio::GAsyncReadyCallback,
            gpointer,
        ),
    >,
    pub save_finish: Option<
        unsafe extern "C" fn(
            *mut PanelSaveDelegate,
            *mut gio::GAsyncResult,
            *mut *mut glib::GError,
        ) -> gboolean,
    >,
    pub save: Option<unsafe extern "C" fn(*mut PanelSaveDelegate, *mut gio::GTask) -> gboolean>,
    pub discard: Option<unsafe extern "C" fn(*mut PanelSaveDelegate)>,
    pub close: Option<unsafe extern "C" fn(*mut PanelSaveDelegate)>,
    pub _reserved: [gpointer; 8],
}

impl ::std::fmt::Debug for PanelSaveDelegateClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelSaveDelegateClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("save_async", &self.save_async)
            .field("save_finish", &self.save_finish)
            .field("save", &self.save)
            .field("discard", &self.discard)
            .field("close", &self.close)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelSaveDialogClass {
    pub parent_class: adw::AdwMessageDialogClass,
}

impl ::std::fmt::Debug for PanelSaveDialogClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelSaveDialogClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelSessionClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PanelSessionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelSessionClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelSessionItemClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PanelSessionItemClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelSessionItemClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelSettingsClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for PanelSettingsClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelSettingsClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelStatusbarClass {
    pub parent_class: gtk::GtkWidgetClass,
}

impl ::std::fmt::Debug for PanelStatusbarClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelStatusbarClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelThemeSelectorClass {
    pub parent_class: gtk::GtkWidgetClass,
}

impl ::std::fmt::Debug for PanelThemeSelectorClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelThemeSelectorClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelToggleButtonClass {
    pub parent_class: gtk::GtkWidgetClass,
}

impl ::std::fmt::Debug for PanelToggleButtonClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelToggleButtonClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelWidgetClass {
    pub parent_instance: gtk::GtkWidgetClass,
    pub get_default_focus: Option<unsafe extern "C" fn(*mut PanelWidget) -> *mut gtk::GtkWidget>,
    pub presented: Option<unsafe extern "C" fn(*mut PanelWidget)>,
    pub _reserved: [gpointer; 8],
}

impl ::std::fmt::Debug for PanelWidgetClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelWidgetClass @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .field("get_default_focus", &self.get_default_focus)
            .field("presented", &self.presented)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelWorkbenchClass {
    pub parent_class: gtk::GtkWindowGroupClass,
    pub activate: Option<unsafe extern "C" fn(*mut PanelWorkbench)>,
    pub unload_async: Option<
        unsafe extern "C" fn(
            *mut PanelWorkbench,
            *mut gio::GCancellable,
            gio::GAsyncReadyCallback,
            gpointer,
        ),
    >,
    pub unload_finish: Option<
        unsafe extern "C" fn(
            *mut PanelWorkbench,
            *mut gio::GAsyncResult,
            *mut *mut glib::GError,
        ) -> gboolean,
    >,
    pub _reserved: [gpointer; 8],
}

impl ::std::fmt::Debug for PanelWorkbenchClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelWorkbenchClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("activate", &self.activate)
            .field("unload_async", &self.unload_async)
            .field("unload_finish", &self.unload_finish)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelWorkspaceClass {
    pub parent_class: adw::AdwApplicationWindowClass,
    pub _reserved: [gpointer; 8],
}

impl ::std::fmt::Debug for PanelWorkspaceClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelWorkspaceClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

// Classes
#[repr(C)]
#[allow(dead_code)]
pub struct PanelActionMuxer {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelActionMuxer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelActionMuxer @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelApplication {
    pub parent_instance: adw::AdwApplication,
}

impl ::std::fmt::Debug for PanelApplication {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelApplication @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelChangesDialog {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelChangesDialog {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelChangesDialog @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelDock {
    pub parent_instance: gtk::GtkWidget,
}

impl ::std::fmt::Debug for PanelDock {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelDock @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelDocumentWorkspace {
    pub parent_instance: PanelWorkspace,
}

impl ::std::fmt::Debug for PanelDocumentWorkspace {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelDocumentWorkspace @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelFrame {
    pub parent_instance: gtk::GtkWidget,
}

impl ::std::fmt::Debug for PanelFrame {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelFrame @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelFrameHeaderBar {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelFrameHeaderBar {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelFrameHeaderBar @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelFrameSwitcher {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelFrameSwitcher {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelFrameSwitcher @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelFrameTabBar {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelFrameTabBar {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelFrameTabBar @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelGSettingsActionGroup {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelGSettingsActionGroup {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelGSettingsActionGroup @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelGrid {
    pub parent_instance: gtk::GtkWidget,
}

impl ::std::fmt::Debug for PanelGrid {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelGrid @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelGridColumn {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelGridColumn {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelGridColumn @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelInhibitor {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelInhibitor {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelInhibitor @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelLayeredSettings {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelLayeredSettings {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelLayeredSettings @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelMenuManager {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelMenuManager {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelMenuManager @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelOmniBar {
    pub parent_instance: gtk::GtkWidget,
}

impl ::std::fmt::Debug for PanelOmniBar {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelOmniBar @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelPaned {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelPaned {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelPaned @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelPosition {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelPosition {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelPosition @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelSaveDelegate {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for PanelSaveDelegate {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelSaveDelegate @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelSaveDialog {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelSaveDialog {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelSaveDialog @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelSession {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelSession {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelSession @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelSessionItem {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelSessionItem {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelSessionItem @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelSettings {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelSettings {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelSettings @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelStatusbar {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelStatusbar {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelStatusbar @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelThemeSelector {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelThemeSelector {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelThemeSelector @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct PanelToggleButton {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelToggleButton {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelToggleButton @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelWidget {
    pub parent_instance: gtk::GtkWidget,
}

impl ::std::fmt::Debug for PanelWidget {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelWidget @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelWorkbench {
    pub parent_instance: gtk::GtkWindowGroup,
}

impl ::std::fmt::Debug for PanelWorkbench {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelWorkbench @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct PanelWorkspace {
    pub parent_instance: adw::AdwApplicationWindow,
}

impl ::std::fmt::Debug for PanelWorkspace {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("PanelWorkspace @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

// Interfaces
#[repr(C)]
#[allow(dead_code)]
pub struct PanelFrameHeader {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for PanelFrameHeader {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "PanelFrameHeader @ {self:p}")
    }
}

extern "C" {

    //=========================================================================
    // PanelArea
    //=========================================================================
    pub fn panel_area_get_type() -> GType;

    //=========================================================================
    // PanelWidgetClass
    //=========================================================================
    pub fn panel_widget_class_install_action(
        widget_class: *mut PanelWidgetClass,
        action_name: *const c_char,
        parameter_type: *const c_char,
        activate: gtk::GtkWidgetActionActivateFunc,
    );
    pub fn panel_widget_class_install_property_action(
        widget_class: *mut PanelWidgetClass,
        action_name: *const c_char,
        property_name: *const c_char,
    );

    //=========================================================================
    // PanelWorkbenchClass
    //=========================================================================
    pub fn panel_workbench_class_install_action(
        workbench_class: *mut PanelWorkbenchClass,
        action_name: *const c_char,
        parameter_type: *const c_char,
        activate: PanelActionActivateFunc,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_workbench_class_install_property_action(
        workbench_class: *mut PanelWorkbenchClass,
        action_name: *const c_char,
        property_name: *const c_char,
    );

    //=========================================================================
    // PanelWorkspaceClass
    //=========================================================================
    pub fn panel_workspace_class_install_action(
        workspace_class: *mut PanelWorkspaceClass,
        action_name: *const c_char,
        parameter_type: *const c_char,
        activate: PanelActionActivateFunc,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_workspace_class_install_property_action(
        workspace_class: *mut PanelWorkspaceClass,
        action_name: *const c_char,
        property_name: *const c_char,
    );

    //=========================================================================
    // PanelActionMuxer
    //=========================================================================
    pub fn panel_action_muxer_get_type() -> GType;
    pub fn panel_action_muxer_new() -> *mut PanelActionMuxer;
    pub fn panel_action_muxer_get_action_group(
        self_: *mut PanelActionMuxer,
        prefix: *const c_char,
    ) -> *mut gio::GActionGroup;
    pub fn panel_action_muxer_insert_action_group(
        self_: *mut PanelActionMuxer,
        prefix: *const c_char,
        action_group: *mut gio::GActionGroup,
    );
    pub fn panel_action_muxer_list_groups(self_: *mut PanelActionMuxer) -> *mut *mut c_char;
    pub fn panel_action_muxer_remove_action_group(
        self_: *mut PanelActionMuxer,
        prefix: *const c_char,
    );
    pub fn panel_action_muxer_remove_all(self_: *mut PanelActionMuxer);

    //=========================================================================
    // PanelApplication
    //=========================================================================
    pub fn panel_application_get_type() -> GType;
    pub fn panel_application_new(
        application_id: *const c_char,
        flags: gio::GApplicationFlags,
    ) -> *mut PanelApplication;

    //=========================================================================
    // PanelChangesDialog
    //=========================================================================
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn panel_changes_dialog_get_type() -> GType;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn panel_changes_dialog_new() -> *mut gtk::GtkWidget;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn panel_changes_dialog_add_delegate(
        self_: *mut PanelChangesDialog,
        delegate: *mut PanelSaveDelegate,
    );
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn panel_changes_dialog_get_close_after_save(self_: *mut PanelChangesDialog) -> gboolean;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn panel_changes_dialog_run_async(
        self_: *mut PanelChangesDialog,
        parent: *mut gtk::GtkWidget,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn panel_changes_dialog_run_finish(
        self_: *mut PanelChangesDialog,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    pub fn panel_changes_dialog_set_close_after_save(
        self_: *mut PanelChangesDialog,
        close_after_save: gboolean,
    );

    //=========================================================================
    // PanelDock
    //=========================================================================
    pub fn panel_dock_get_type() -> GType;
    pub fn panel_dock_new() -> *mut gtk::GtkWidget;
    pub fn panel_dock_foreach_frame(
        self_: *mut PanelDock,
        callback: PanelFrameCallback,
        user_data: gpointer,
    );
    pub fn panel_dock_get_can_reveal_area(self_: *mut PanelDock, area: PanelArea) -> gboolean;
    pub fn panel_dock_get_can_reveal_bottom(self_: *mut PanelDock) -> gboolean;
    pub fn panel_dock_get_can_reveal_end(self_: *mut PanelDock) -> gboolean;
    pub fn panel_dock_get_can_reveal_start(self_: *mut PanelDock) -> gboolean;
    pub fn panel_dock_get_can_reveal_top(self_: *mut PanelDock) -> gboolean;
    pub fn panel_dock_get_reveal_area(self_: *mut PanelDock, area: PanelArea) -> gboolean;
    pub fn panel_dock_get_reveal_bottom(self_: *mut PanelDock) -> gboolean;
    pub fn panel_dock_get_reveal_end(self_: *mut PanelDock) -> gboolean;
    pub fn panel_dock_get_reveal_start(self_: *mut PanelDock) -> gboolean;
    pub fn panel_dock_get_reveal_top(self_: *mut PanelDock) -> gboolean;
    pub fn panel_dock_remove(self_: *mut PanelDock, widget: *mut gtk::GtkWidget);
    pub fn panel_dock_set_bottom_height(self_: *mut PanelDock, height: c_int);
    pub fn panel_dock_set_end_width(self_: *mut PanelDock, width: c_int);
    pub fn panel_dock_set_reveal_area(self_: *mut PanelDock, area: PanelArea, reveal: gboolean);
    pub fn panel_dock_set_reveal_bottom(self_: *mut PanelDock, reveal_bottom: gboolean);
    pub fn panel_dock_set_reveal_end(self_: *mut PanelDock, reveal_end: gboolean);
    pub fn panel_dock_set_reveal_start(self_: *mut PanelDock, reveal_start: gboolean);
    pub fn panel_dock_set_reveal_top(self_: *mut PanelDock, reveal_top: gboolean);
    pub fn panel_dock_set_start_width(self_: *mut PanelDock, width: c_int);
    pub fn panel_dock_set_top_height(self_: *mut PanelDock, height: c_int);

    //=========================================================================
    // PanelDocumentWorkspace
    //=========================================================================
    pub fn panel_document_workspace_get_type() -> GType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_document_workspace_new() -> *mut PanelDocumentWorkspace;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_document_workspace_add_widget(
        self_: *mut PanelDocumentWorkspace,
        widget: *mut PanelWidget,
        position: *mut PanelPosition,
    ) -> gboolean;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_document_workspace_get_dock(self_: *mut PanelDocumentWorkspace) -> *mut PanelDock;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_document_workspace_get_grid(self_: *mut PanelDocumentWorkspace) -> *mut PanelGrid;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_document_workspace_get_statusbar(
        self_: *mut PanelDocumentWorkspace,
    ) -> *mut PanelStatusbar;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_document_workspace_get_titlebar(
        self_: *mut PanelDocumentWorkspace,
    ) -> *mut gtk::GtkWidget;
    pub fn panel_document_workspace_set_titlebar(
        self_: *mut PanelDocumentWorkspace,
        titlebar: *mut gtk::GtkWidget,
    );

    //=========================================================================
    // PanelFrame
    //=========================================================================
    pub fn panel_frame_get_type() -> GType;
    pub fn panel_frame_new() -> *mut gtk::GtkWidget;
    pub fn panel_frame_add(self_: *mut PanelFrame, panel: *mut PanelWidget);
    pub fn panel_frame_add_before(
        self_: *mut PanelFrame,
        panel: *mut PanelWidget,
        sibling: *mut PanelWidget,
    );
    pub fn panel_frame_get_closeable(self_: *mut PanelFrame) -> gboolean;
    pub fn panel_frame_get_empty(self_: *mut PanelFrame) -> gboolean;
    pub fn panel_frame_get_header(self_: *mut PanelFrame) -> *mut PanelFrameHeader;
    pub fn panel_frame_get_n_pages(self_: *mut PanelFrame) -> c_uint;
    pub fn panel_frame_get_page(self_: *mut PanelFrame, n: c_uint) -> *mut PanelWidget;
    pub fn panel_frame_get_pages(self_: *mut PanelFrame) -> *mut gtk::GtkSelectionModel;
    pub fn panel_frame_get_placeholder(self_: *mut PanelFrame) -> *mut gtk::GtkWidget;
    pub fn panel_frame_get_position(self_: *mut PanelFrame) -> *mut PanelPosition;
    pub fn panel_frame_get_requested_size(self_: *mut PanelFrame) -> c_int;
    pub fn panel_frame_get_visible_child(self_: *mut PanelFrame) -> *mut PanelWidget;
    pub fn panel_frame_remove(self_: *mut PanelFrame, panel: *mut PanelWidget);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn panel_frame_set_child_pinned(
        self_: *mut PanelFrame,
        child: *mut PanelWidget,
        pinned: gboolean,
    );
    pub fn panel_frame_set_header(self_: *mut PanelFrame, header: *mut PanelFrameHeader);
    pub fn panel_frame_set_placeholder(self_: *mut PanelFrame, placeholder: *mut gtk::GtkWidget);
    pub fn panel_frame_set_requested_size(self_: *mut PanelFrame, requested_size: c_int);
    pub fn panel_frame_set_visible_child(self_: *mut PanelFrame, widget: *mut PanelWidget);

    //=========================================================================
    // PanelFrameHeaderBar
    //=========================================================================
    pub fn panel_frame_header_bar_get_type() -> GType;
    pub fn panel_frame_header_bar_new() -> *mut gtk::GtkWidget;
    pub fn panel_frame_header_bar_get_menu_popover(
        self_: *mut PanelFrameHeaderBar,
    ) -> *mut gtk::GtkPopoverMenu;
    pub fn panel_frame_header_bar_get_show_icon(self_: *mut PanelFrameHeaderBar) -> gboolean;
    pub fn panel_frame_header_bar_set_show_icon(
        self_: *mut PanelFrameHeaderBar,
        show_icon: gboolean,
    );

    //=========================================================================
    // PanelFrameSwitcher
    //=========================================================================
    pub fn panel_frame_switcher_get_type() -> GType;
    pub fn panel_frame_switcher_new() -> *mut gtk::GtkWidget;

    //=========================================================================
    // PanelFrameTabBar
    //=========================================================================
    pub fn panel_frame_tab_bar_get_type() -> GType;
    pub fn panel_frame_tab_bar_new() -> *mut gtk::GtkWidget;
    pub fn panel_frame_tab_bar_get_autohide(self_: *mut PanelFrameTabBar) -> gboolean;
    pub fn panel_frame_tab_bar_get_expand_tabs(self_: *mut PanelFrameTabBar) -> gboolean;
    pub fn panel_frame_tab_bar_get_inverted(self_: *mut PanelFrameTabBar) -> gboolean;
    pub fn panel_frame_tab_bar_set_autohide(self_: *mut PanelFrameTabBar, autohide: gboolean);
    pub fn panel_frame_tab_bar_set_expand_tabs(self_: *mut PanelFrameTabBar, expand_tabs: gboolean);
    pub fn panel_frame_tab_bar_set_inverted(self_: *mut PanelFrameTabBar, inverted: gboolean);

    //=========================================================================
    // PanelGSettingsActionGroup
    //=========================================================================
    pub fn panel_gsettings_action_group_get_type() -> GType;
    pub fn panel_gsettings_action_group_new(
        settings: *mut gio::GSettings,
    ) -> *mut gio::GActionGroup;

    //=========================================================================
    // PanelGrid
    //=========================================================================
    pub fn panel_grid_get_type() -> GType;
    pub fn panel_grid_new() -> *mut gtk::GtkWidget;
    pub fn panel_grid_add(self_: *mut PanelGrid, widget: *mut PanelWidget);
    pub fn panel_grid_agree_to_close_async(
        self_: *mut PanelGrid,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn panel_grid_agree_to_close_finish(
        self_: *mut PanelGrid,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn panel_grid_foreach_frame(
        self_: *mut PanelGrid,
        callback: PanelFrameCallback,
        user_data: gpointer,
    );
    pub fn panel_grid_get_column(self_: *mut PanelGrid, column: c_uint) -> *mut PanelGridColumn;
    pub fn panel_grid_get_most_recent_column(self_: *mut PanelGrid) -> *mut PanelGridColumn;
    pub fn panel_grid_get_most_recent_frame(self_: *mut PanelGrid) -> *mut PanelFrame;
    pub fn panel_grid_get_n_columns(self_: *mut PanelGrid) -> c_uint;
    pub fn panel_grid_insert_column(self_: *mut PanelGrid, position: c_uint);

    //=========================================================================
    // PanelGridColumn
    //=========================================================================
    pub fn panel_grid_column_get_type() -> GType;
    pub fn panel_grid_column_new() -> *mut gtk::GtkWidget;
    pub fn panel_grid_column_foreach_frame(
        self_: *mut PanelGridColumn,
        callback: PanelFrameCallback,
        user_data: gpointer,
    );
    pub fn panel_grid_column_get_empty(self_: *mut PanelGridColumn) -> gboolean;
    pub fn panel_grid_column_get_most_recent_frame(self_: *mut PanelGridColumn) -> *mut PanelFrame;
    pub fn panel_grid_column_get_n_rows(self_: *mut PanelGridColumn) -> c_uint;
    pub fn panel_grid_column_get_row(self_: *mut PanelGridColumn, row: c_uint) -> *mut PanelFrame;

    //=========================================================================
    // PanelInhibitor
    //=========================================================================
    pub fn panel_inhibitor_get_type() -> GType;
    pub fn panel_inhibitor_uninhibit(self_: *mut PanelInhibitor);

    //=========================================================================
    // PanelLayeredSettings
    //=========================================================================
    pub fn panel_layered_settings_get_type() -> GType;
    pub fn panel_layered_settings_new(
        schema_id: *const c_char,
        path: *const c_char,
    ) -> *mut PanelLayeredSettings;
    pub fn panel_layered_settings_append(
        self_: *mut PanelLayeredSettings,
        settings: *mut gio::GSettings,
    );
    pub fn panel_layered_settings_bind(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
        object: gpointer,
        property: *const c_char,
        flags: gio::GSettingsBindFlags,
    );
    pub fn panel_layered_settings_bind_with_mapping(
        self_: *mut PanelLayeredSettings,
        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 panel_layered_settings_get_boolean(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
    ) -> gboolean;
    pub fn panel_layered_settings_get_default_value(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
    ) -> *mut glib::GVariant;
    pub fn panel_layered_settings_get_double(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
    ) -> c_double;
    pub fn panel_layered_settings_get_int(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
    ) -> c_int;
    pub fn panel_layered_settings_get_key(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
    ) -> *mut gio::GSettingsSchemaKey;
    pub fn panel_layered_settings_get_string(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
    ) -> *mut c_char;
    pub fn panel_layered_settings_get_uint(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
    ) -> c_uint;
    pub fn panel_layered_settings_get_user_value(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
    ) -> *mut glib::GVariant;
    pub fn panel_layered_settings_get_value(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
    ) -> *mut glib::GVariant;
    pub fn panel_layered_settings_list_keys(self_: *mut PanelLayeredSettings) -> *mut *mut c_char;
    pub fn panel_layered_settings_set_boolean(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
        val: gboolean,
    );
    pub fn panel_layered_settings_set_double(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
        val: c_double,
    );
    pub fn panel_layered_settings_set_int(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
        val: c_int,
    );
    pub fn panel_layered_settings_set_string(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
        val: *const c_char,
    );
    pub fn panel_layered_settings_set_uint(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
        val: c_uint,
    );
    pub fn panel_layered_settings_set_value(
        self_: *mut PanelLayeredSettings,
        key: *const c_char,
        value: *mut glib::GVariant,
    );
    pub fn panel_layered_settings_unbind(self_: *mut PanelLayeredSettings, property: *const c_char);

    //=========================================================================
    // PanelMenuManager
    //=========================================================================
    pub fn panel_menu_manager_get_type() -> GType;
    pub fn panel_menu_manager_new() -> *mut PanelMenuManager;
    pub fn panel_menu_manager_add_filename(
        self_: *mut PanelMenuManager,
        filename: *const c_char,
        error: *mut *mut glib::GError,
    ) -> c_uint;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_menu_manager_add_resource(
        self_: *mut PanelMenuManager,
        resource: *const c_char,
        error: *mut *mut glib::GError,
    ) -> c_uint;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_menu_manager_find_item_by_id(
        self_: *mut PanelMenuManager,
        id: *const c_char,
        position: *mut c_uint,
    ) -> *mut gio::GMenu;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_menu_manager_get_menu_by_id(
        self_: *mut PanelMenuManager,
        menu_id: *const c_char,
    ) -> *mut gio::GMenu;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_menu_manager_get_menu_ids(self_: *mut PanelMenuManager) -> *const *const c_char;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_menu_manager_merge(
        self_: *mut PanelMenuManager,
        menu_id: *const c_char,
        menu_model: *mut gio::GMenuModel,
    ) -> c_uint;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_menu_manager_remove(self_: *mut PanelMenuManager, merge_id: c_uint);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_menu_manager_set_attribute_string(
        self_: *mut PanelMenuManager,
        menu: *mut gio::GMenu,
        position: c_uint,
        attribute: *const c_char,
        value: *const c_char,
    );

    //=========================================================================
    // PanelOmniBar
    //=========================================================================
    pub fn panel_omni_bar_get_type() -> GType;
    pub fn panel_omni_bar_new() -> *mut gtk::GtkWidget;
    pub fn panel_omni_bar_add_prefix(
        self_: *mut PanelOmniBar,
        priority: c_int,
        widget: *mut gtk::GtkWidget,
    );
    pub fn panel_omni_bar_add_suffix(
        self_: *mut PanelOmniBar,
        priority: c_int,
        widget: *mut gtk::GtkWidget,
    );
    pub fn panel_omni_bar_get_popover(self_: *mut PanelOmniBar) -> *mut gtk::GtkPopover;
    pub fn panel_omni_bar_get_progress(self_: *mut PanelOmniBar) -> c_double;
    pub fn panel_omni_bar_remove(self_: *mut PanelOmniBar, widget: *mut gtk::GtkWidget);
    pub fn panel_omni_bar_set_popover(self_: *mut PanelOmniBar, popover: *mut gtk::GtkPopover);
    pub fn panel_omni_bar_set_progress(self_: *mut PanelOmniBar, progress: c_double);
    pub fn panel_omni_bar_start_pulsing(self_: *mut PanelOmniBar);
    pub fn panel_omni_bar_stop_pulsing(self_: *mut PanelOmniBar);

    //=========================================================================
    // PanelPaned
    //=========================================================================
    pub fn panel_paned_get_type() -> GType;
    pub fn panel_paned_new() -> *mut gtk::GtkWidget;
    pub fn panel_paned_append(self_: *mut PanelPaned, child: *mut gtk::GtkWidget);
    pub fn panel_paned_get_n_children(self_: *mut PanelPaned) -> c_uint;
    pub fn panel_paned_get_nth_child(self_: *mut PanelPaned, nth: c_uint) -> *mut gtk::GtkWidget;
    pub fn panel_paned_insert(self_: *mut PanelPaned, position: c_int, child: *mut gtk::GtkWidget);
    pub fn panel_paned_insert_after(
        self_: *mut PanelPaned,
        child: *mut gtk::GtkWidget,
        sibling: *mut gtk::GtkWidget,
    );
    pub fn panel_paned_prepend(self_: *mut PanelPaned, child: *mut gtk::GtkWidget);
    pub fn panel_paned_remove(self_: *mut PanelPaned, child: *mut gtk::GtkWidget);

    //=========================================================================
    // PanelPosition
    //=========================================================================
    pub fn panel_position_get_type() -> GType;
    pub fn panel_position_new() -> *mut PanelPosition;
    pub fn panel_position_new_from_variant(variant: *mut glib::GVariant) -> *mut PanelPosition;
    pub fn panel_position_equal(a: *mut PanelPosition, b: *mut PanelPosition) -> gboolean;
    pub fn panel_position_get_area(self_: *mut PanelPosition) -> PanelArea;
    pub fn panel_position_get_area_set(self_: *mut PanelPosition) -> gboolean;
    pub fn panel_position_get_column(self_: *mut PanelPosition) -> c_uint;
    pub fn panel_position_get_column_set(self_: *mut PanelPosition) -> gboolean;
    pub fn panel_position_get_depth(self_: *mut PanelPosition) -> c_uint;
    pub fn panel_position_get_depth_set(self_: *mut PanelPosition) -> gboolean;
    pub fn panel_position_get_row(self_: *mut PanelPosition) -> c_uint;
    pub fn panel_position_get_row_set(self_: *mut PanelPosition) -> gboolean;
    pub fn panel_position_is_indeterminate(self_: *mut PanelPosition) -> gboolean;
    pub fn panel_position_set_area(self_: *mut PanelPosition, area: PanelArea);
    pub fn panel_position_set_area_set(self_: *mut PanelPosition, area_set: gboolean);
    pub fn panel_position_set_column(self_: *mut PanelPosition, column: c_uint);
    pub fn panel_position_set_column_set(self_: *mut PanelPosition, column_set: gboolean);
    pub fn panel_position_set_depth(self_: *mut PanelPosition, depth: c_uint);
    pub fn panel_position_set_depth_set(self_: *mut PanelPosition, depth_set: gboolean);
    pub fn panel_position_set_row(self_: *mut PanelPosition, row: c_uint);
    pub fn panel_position_set_row_set(self_: *mut PanelPosition, row_set: gboolean);
    pub fn panel_position_to_variant(self_: *mut PanelPosition) -> *mut glib::GVariant;

    //=========================================================================
    // PanelSaveDelegate
    //=========================================================================
    pub fn panel_save_delegate_get_type() -> GType;
    pub fn panel_save_delegate_new() -> *mut PanelSaveDelegate;
    pub fn panel_save_delegate_close(self_: *mut PanelSaveDelegate);
    pub fn panel_save_delegate_discard(self_: *mut PanelSaveDelegate);
    pub fn panel_save_delegate_get_icon(self_: *mut PanelSaveDelegate) -> *mut gio::GIcon;
    pub fn panel_save_delegate_get_icon_name(self_: *mut PanelSaveDelegate) -> *const c_char;
    pub fn panel_save_delegate_get_is_draft(self_: *mut PanelSaveDelegate) -> gboolean;
    pub fn panel_save_delegate_get_progress(self_: *mut PanelSaveDelegate) -> c_double;
    pub fn panel_save_delegate_get_subtitle(self_: *mut PanelSaveDelegate) -> *const c_char;
    pub fn panel_save_delegate_get_title(self_: *mut PanelSaveDelegate) -> *const c_char;
    pub fn panel_save_delegate_save_async(
        self_: *mut PanelSaveDelegate,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn panel_save_delegate_save_finish(
        self_: *mut PanelSaveDelegate,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn panel_save_delegate_set_icon(self_: *mut PanelSaveDelegate, icon: *mut gio::GIcon);
    pub fn panel_save_delegate_set_icon_name(self_: *mut PanelSaveDelegate, icon: *const c_char);
    pub fn panel_save_delegate_set_is_draft(self_: *mut PanelSaveDelegate, is_draft: gboolean);
    pub fn panel_save_delegate_set_progress(self_: *mut PanelSaveDelegate, progress: c_double);
    pub fn panel_save_delegate_set_subtitle(self_: *mut PanelSaveDelegate, subtitle: *const c_char);
    pub fn panel_save_delegate_set_title(self_: *mut PanelSaveDelegate, title: *const c_char);

    //=========================================================================
    // PanelSaveDialog
    //=========================================================================
    pub fn panel_save_dialog_get_type() -> GType;
    pub fn panel_save_dialog_new() -> *mut gtk::GtkWidget;
    pub fn panel_save_dialog_add_delegate(
        self_: *mut PanelSaveDialog,
        delegate: *mut PanelSaveDelegate,
    );
    pub fn panel_save_dialog_get_close_after_save(self_: *mut PanelSaveDialog) -> gboolean;
    pub fn panel_save_dialog_run_async(
        self_: *mut PanelSaveDialog,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn panel_save_dialog_run_finish(
        self_: *mut PanelSaveDialog,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn panel_save_dialog_set_close_after_save(
        self_: *mut PanelSaveDialog,
        close_after_save: gboolean,
    );

    //=========================================================================
    // PanelSession
    //=========================================================================
    pub fn panel_session_get_type() -> GType;
    pub fn panel_session_new() -> *mut PanelSession;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_session_new_from_variant(
        variant: *mut glib::GVariant,
        error: *mut *mut glib::GError,
    ) -> *mut PanelSession;
    pub fn panel_session_append(self_: *mut PanelSession, item: *mut PanelSessionItem);
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_session_get_item(
        self_: *mut PanelSession,
        position: c_uint,
    ) -> *mut PanelSessionItem;
    pub fn panel_session_get_n_items(self_: *mut PanelSession) -> c_uint;
    pub fn panel_session_insert(
        self_: *mut PanelSession,
        position: c_uint,
        item: *mut PanelSessionItem,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_session_lookup_by_id(
        self_: *mut PanelSession,
        id: *const c_char,
    ) -> *mut PanelSessionItem;
    pub fn panel_session_prepend(self_: *mut PanelSession, item: *mut PanelSessionItem);
    pub fn panel_session_remove(self_: *mut PanelSession, item: *mut PanelSessionItem);
    pub fn panel_session_remove_at(self_: *mut PanelSession, position: c_uint);
    pub fn panel_session_to_variant(self_: *mut PanelSession) -> *mut glib::GVariant;

    //=========================================================================
    // PanelSessionItem
    //=========================================================================
    pub fn panel_session_item_get_type() -> GType;
    pub fn panel_session_item_new() -> *mut PanelSessionItem;
    pub fn panel_session_item_get_id(self_: *mut PanelSessionItem) -> *const c_char;
    pub fn panel_session_item_get_metadata(
        self_: *mut PanelSessionItem,
        key: *const c_char,
        format: *const c_char,
        ...
    ) -> gboolean;
    pub fn panel_session_item_get_metadata_value(
        self_: *mut PanelSessionItem,
        key: *const c_char,
        expected_type: *const glib::GVariantType,
    ) -> *mut glib::GVariant;
    pub fn panel_session_item_get_module_name(self_: *mut PanelSessionItem) -> *const c_char;
    pub fn panel_session_item_get_position(self_: *mut PanelSessionItem) -> *mut PanelPosition;
    pub fn panel_session_item_get_type_hint(self_: *mut PanelSessionItem) -> *const c_char;
    pub fn panel_session_item_get_workspace(self_: *mut PanelSessionItem) -> *const c_char;
    pub fn panel_session_item_has_metadata(
        self_: *mut PanelSessionItem,
        key: *const c_char,
        value_type: *mut *const glib::GVariantType,
    ) -> gboolean;
    pub fn panel_session_item_has_metadata_with_type(
        self_: *mut PanelSessionItem,
        key: *const c_char,
        expected_type: *const glib::GVariantType,
    ) -> gboolean;
    pub fn panel_session_item_set_id(self_: *mut PanelSessionItem, id: *const c_char);
    pub fn panel_session_item_set_metadata(
        self_: *mut PanelSessionItem,
        key: *const c_char,
        format: *const c_char,
        ...
    );
    pub fn panel_session_item_set_metadata_value(
        self_: *mut PanelSessionItem,
        key: *const c_char,
        value: *mut glib::GVariant,
    );
    pub fn panel_session_item_set_module_name(
        self_: *mut PanelSessionItem,
        module_name: *const c_char,
    );
    pub fn panel_session_item_set_position(
        self_: *mut PanelSessionItem,
        position: *mut PanelPosition,
    );
    pub fn panel_session_item_set_type_hint(self_: *mut PanelSessionItem, type_hint: *const c_char);
    pub fn panel_session_item_set_workspace(self_: *mut PanelSessionItem, workspace: *const c_char);

    //=========================================================================
    // PanelSettings
    //=========================================================================
    pub fn panel_settings_get_type() -> GType;
    pub fn panel_settings_new(
        identifier: *const c_char,
        schema_id: *const c_char,
    ) -> *mut PanelSettings;
    pub fn panel_settings_new_relocatable(
        identifier: *const c_char,
        schema_id: *const c_char,
        schema_id_prefix: *const c_char,
        path_prefix: *const c_char,
        path_suffix: *const c_char,
    ) -> *mut PanelSettings;
    pub fn panel_settings_new_with_path(
        identifier: *const c_char,
        schema_id: *const c_char,
        path: *const c_char,
    ) -> *mut PanelSettings;
    pub fn panel_settings_resolve_schema_path(
        schema_id_prefix: *const c_char,
        schema_id: *const c_char,
        identifier: *const c_char,
        path_prefix: *const c_char,
        path_suffix: *const c_char,
    ) -> *mut c_char;
    pub fn panel_settings_bind(
        self_: *mut PanelSettings,
        key: *const c_char,
        object: gpointer,
        property: *const c_char,
        flags: gio::GSettingsBindFlags,
    );
    pub fn panel_settings_bind_with_mapping(
        self_: *mut PanelSettings,
        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 panel_settings_get_boolean(self_: *mut PanelSettings, key: *const c_char) -> gboolean;
    pub fn panel_settings_get_default_value(
        self_: *mut PanelSettings,
        key: *const c_char,
    ) -> *mut glib::GVariant;
    pub fn panel_settings_get_double(self_: *mut PanelSettings, key: *const c_char) -> c_double;
    pub fn panel_settings_get_int(self_: *mut PanelSettings, key: *const c_char) -> c_int;
    pub fn panel_settings_get_schema_id(self_: *mut PanelSettings) -> *const c_char;
    pub fn panel_settings_get_string(self_: *mut PanelSettings, key: *const c_char) -> *mut c_char;
    pub fn panel_settings_get_uint(self_: *mut PanelSettings, key: *const c_char) -> c_uint;
    pub fn panel_settings_get_user_value(
        self_: *mut PanelSettings,
        key: *const c_char,
    ) -> *mut glib::GVariant;
    pub fn panel_settings_get_value(
        self_: *mut PanelSettings,
        key: *const c_char,
    ) -> *mut glib::GVariant;
    pub fn panel_settings_set_boolean(self_: *mut PanelSettings, key: *const c_char, val: gboolean);
    pub fn panel_settings_set_double(self_: *mut PanelSettings, key: *const c_char, val: c_double);
    pub fn panel_settings_set_int(self_: *mut PanelSettings, key: *const c_char, val: c_int);
    pub fn panel_settings_set_string(
        self_: *mut PanelSettings,
        key: *const c_char,
        val: *const c_char,
    );
    pub fn panel_settings_set_uint(self_: *mut PanelSettings, key: *const c_char, val: c_uint);
    pub fn panel_settings_set_value(
        self_: *mut PanelSettings,
        key: *const c_char,
        value: *mut glib::GVariant,
    );
    pub fn panel_settings_unbind(self_: *mut PanelSettings, property: *const c_char);

    //=========================================================================
    // PanelStatusbar
    //=========================================================================
    pub fn panel_statusbar_get_type() -> GType;
    pub fn panel_statusbar_new() -> *mut gtk::GtkWidget;
    pub fn panel_statusbar_add_prefix(
        self_: *mut PanelStatusbar,
        priority: c_int,
        widget: *mut gtk::GtkWidget,
    );
    pub fn panel_statusbar_add_suffix(
        self_: *mut PanelStatusbar,
        priority: c_int,
        widget: *mut gtk::GtkWidget,
    );
    pub fn panel_statusbar_remove(self_: *mut PanelStatusbar, widget: *mut gtk::GtkWidget);

    //=========================================================================
    // PanelThemeSelector
    //=========================================================================
    pub fn panel_theme_selector_get_type() -> GType;
    pub fn panel_theme_selector_new() -> *mut gtk::GtkWidget;
    pub fn panel_theme_selector_get_action_name(self_: *mut PanelThemeSelector) -> *const c_char;
    pub fn panel_theme_selector_set_action_name(
        self_: *mut PanelThemeSelector,
        action_name: *const c_char,
    );

    //=========================================================================
    // PanelToggleButton
    //=========================================================================
    pub fn panel_toggle_button_get_type() -> GType;
    pub fn panel_toggle_button_new(dock: *mut PanelDock, area: PanelArea) -> *mut gtk::GtkWidget;

    //=========================================================================
    // PanelWidget
    //=========================================================================
    pub fn panel_widget_get_type() -> GType;
    pub fn panel_widget_new() -> *mut gtk::GtkWidget;
    pub fn panel_widget_action_set_enabled(
        widget: *mut PanelWidget,
        action_name: *const c_char,
        enabled: gboolean,
    );
    pub fn panel_widget_close(self_: *mut PanelWidget);
    pub fn panel_widget_focus_default(self_: *mut PanelWidget) -> gboolean;
    pub fn panel_widget_force_close(self_: *mut PanelWidget);
    pub fn panel_widget_get_busy(self_: *mut PanelWidget) -> gboolean;
    pub fn panel_widget_get_can_maximize(self_: *mut PanelWidget) -> gboolean;
    pub fn panel_widget_get_child(self_: *mut PanelWidget) -> *mut gtk::GtkWidget;
    pub fn panel_widget_get_default_focus(self_: *mut PanelWidget) -> *mut gtk::GtkWidget;
    pub fn panel_widget_get_icon(self_: *mut PanelWidget) -> *mut gio::GIcon;
    pub fn panel_widget_get_icon_name(self_: *mut PanelWidget) -> *const c_char;
    pub fn panel_widget_get_id(self_: *mut PanelWidget) -> *const c_char;
    pub fn panel_widget_get_kind(self_: *mut PanelWidget) -> *const c_char;
    pub fn panel_widget_get_menu_model(self_: *mut PanelWidget) -> *mut gio::GMenuModel;
    pub fn panel_widget_get_modified(self_: *mut PanelWidget) -> gboolean;
    pub fn panel_widget_get_needs_attention(self_: *mut PanelWidget) -> gboolean;
    pub fn panel_widget_get_position(self_: *mut PanelWidget) -> *mut PanelPosition;
    pub fn panel_widget_get_reorderable(self_: *mut PanelWidget) -> gboolean;
    pub fn panel_widget_get_save_delegate(self_: *mut PanelWidget) -> *mut PanelSaveDelegate;
    pub fn panel_widget_get_title(self_: *mut PanelWidget) -> *const c_char;
    pub fn panel_widget_get_tooltip(self_: *mut PanelWidget) -> *const c_char;
    pub fn panel_widget_insert_action_group(
        self_: *mut PanelWidget,
        prefix: *const c_char,
        group: *mut gio::GActionGroup,
    );
    pub fn panel_widget_mark_busy(self_: *mut PanelWidget);
    pub fn panel_widget_maximize(self_: *mut PanelWidget);
    pub fn panel_widget_raise(self_: *mut PanelWidget);
    pub fn panel_widget_set_can_maximize(self_: *mut PanelWidget, can_maximize: gboolean);
    pub fn panel_widget_set_child(self_: *mut PanelWidget, child: *mut gtk::GtkWidget);
    pub fn panel_widget_set_icon(self_: *mut PanelWidget, icon: *mut gio::GIcon);
    pub fn panel_widget_set_icon_name(self_: *mut PanelWidget, icon_name: *const c_char);
    pub fn panel_widget_set_id(self_: *mut PanelWidget, id: *const c_char);
    pub fn panel_widget_set_kind(self_: *mut PanelWidget, kind: *const c_char);
    pub fn panel_widget_set_menu_model(self_: *mut PanelWidget, menu_model: *mut gio::GMenuModel);
    pub fn panel_widget_set_modified(self_: *mut PanelWidget, modified: gboolean);
    pub fn panel_widget_set_needs_attention(self_: *mut PanelWidget, needs_attention: gboolean);
    pub fn panel_widget_set_reorderable(self_: *mut PanelWidget, reorderable: gboolean);
    pub fn panel_widget_set_save_delegate(
        self_: *mut PanelWidget,
        save_delegate: *mut PanelSaveDelegate,
    );
    pub fn panel_widget_set_title(self_: *mut PanelWidget, title: *const c_char);
    pub fn panel_widget_set_tooltip(self_: *mut PanelWidget, tooltip: *const c_char);
    pub fn panel_widget_unmark_busy(self_: *mut PanelWidget);
    pub fn panel_widget_unmaximize(self_: *mut PanelWidget);

    //=========================================================================
    // PanelWorkbench
    //=========================================================================
    pub fn panel_workbench_get_type() -> GType;
    pub fn panel_workbench_new() -> *mut PanelWorkbench;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_workbench_find_from_widget(widget: *mut gtk::GtkWidget) -> *mut PanelWorkbench;
    pub fn panel_workbench_action_set_enabled(
        self_: *mut PanelWorkbench,
        action_name: *const c_char,
        enabled: gboolean,
    );
    pub fn panel_workbench_activate(self_: *mut PanelWorkbench);
    pub fn panel_workbench_add_workspace(
        self_: *mut PanelWorkbench,
        workspace: *mut PanelWorkspace,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_workbench_find_workspace_typed(
        self_: *mut PanelWorkbench,
        workspace_type: GType,
    ) -> *mut PanelWorkspace;
    pub fn panel_workbench_focus_workspace(
        self_: *mut PanelWorkbench,
        workspace: *mut PanelWorkspace,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_workbench_foreach_workspace(
        self_: *mut PanelWorkbench,
        foreach_func: PanelWorkspaceForeach,
        foreach_func_data: gpointer,
    );
    pub fn panel_workbench_get_id(self_: *mut PanelWorkbench) -> *const c_char;
    pub fn panel_workbench_remove_workspace(
        self_: *mut PanelWorkbench,
        workspace: *mut PanelWorkspace,
    );
    pub fn panel_workbench_set_id(self_: *mut PanelWorkbench, id: *const c_char);

    //=========================================================================
    // PanelWorkspace
    //=========================================================================
    pub fn panel_workspace_get_type() -> GType;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_workspace_find_from_widget(widget: *mut gtk::GtkWidget) -> *mut PanelWorkspace;
    pub fn panel_workspace_action_set_enabled(
        self_: *mut PanelWorkspace,
        action_name: *const c_char,
        enabled: gboolean,
    );
    pub fn panel_workspace_get_id(self_: *mut PanelWorkspace) -> *const c_char;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_workspace_get_workbench(self_: *mut PanelWorkspace) -> *mut PanelWorkbench;
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn panel_workspace_inhibit(
        self_: *mut PanelWorkspace,
        flags: gtk::GtkApplicationInhibitFlags,
        reason: *const c_char,
    ) -> *mut PanelInhibitor;
    pub fn panel_workspace_set_id(self_: *mut PanelWorkspace, id: *const c_char);

    //=========================================================================
    // PanelFrameHeader
    //=========================================================================
    pub fn panel_frame_header_get_type() -> GType;
    pub fn panel_frame_header_add_prefix(
        self_: *mut PanelFrameHeader,
        priority: c_int,
        child: *mut gtk::GtkWidget,
    );
    pub fn panel_frame_header_add_suffix(
        self_: *mut PanelFrameHeader,
        priority: c_int,
        child: *mut gtk::GtkWidget,
    );
    pub fn panel_frame_header_can_drop(
        self_: *mut PanelFrameHeader,
        widget: *mut PanelWidget,
    ) -> gboolean;
    pub fn panel_frame_header_get_frame(self_: *mut PanelFrameHeader) -> *mut PanelFrame;
    pub fn panel_frame_header_page_changed(self_: *mut PanelFrameHeader, widget: *mut PanelWidget);
    pub fn panel_frame_header_set_frame(self_: *mut PanelFrameHeader, frame: *mut PanelFrame);

    //=========================================================================
    // Other functions
    //=========================================================================
    pub fn panel_check_version(major: c_uint, minor: c_uint, micro: c_uint) -> gboolean;
    pub fn panel_finalize();
    pub fn panel_get_major_version() -> c_uint;
    pub fn panel_get_micro_version() -> c_uint;
    pub fn panel_get_minor_version() -> c_uint;
    pub fn panel_get_resource() -> *mut gio::GResource;
    pub fn panel_init();
    pub fn panel_marshal_BOOLEAN__OBJECT_OBJECT(
        closure: *mut gobject::GClosure,
        return_value: *mut gobject::GValue,
        n_param_values: c_uint,
        param_values: *const gobject::GValue,
        invocation_hint: gpointer,
        marshal_data: gpointer,
    );
    //pub fn panel_marshal_BOOLEAN__OBJECT_OBJECTv(closure: *mut gobject::GClosure, return_value: *mut gobject::GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
    pub fn panel_marshal_OBJECT__OBJECT(
        closure: *mut gobject::GClosure,
        return_value: *mut gobject::GValue,
        n_param_values: c_uint,
        param_values: *const gobject::GValue,
        invocation_hint: gpointer,
        marshal_data: gpointer,
    );
    //pub fn panel_marshal_OBJECT__OBJECTv(closure: *mut gobject::GClosure, return_value: *mut gobject::GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);

}