// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files.git)
// DO NOT EDIT

use crate::AppLaunchContext;
use crate::Clipboard;
use crate::Device;
use crate::Event;
#[cfg(any(feature = "v4_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v4_6")))]
use crate::GLContext;
use crate::Monitor;
use crate::Seat;
use crate::Surface;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;
#[cfg(any(feature = "v4_4", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v4_4")))]
use std::ptr;

glib::wrapper! {
    /// [`Display`][crate::Display] objects are the GDK representation of a workstation.
    ///
    /// Their purpose are two-fold:
    ///
    /// - To manage and provide information about input devices (pointers, keyboards, etc)
    /// - To manage and provide information about output devices (monitors, projectors, etc)
    ///
    /// Most of the input device handling has been factored out into separate
    /// [`Seat`][crate::Seat] objects. Every display has a one or more seats, which
    /// can be accessed with [`DisplayExt::default_seat()`][crate::prelude::DisplayExt::default_seat()] and
    /// [`DisplayExt::list_seats()`][crate::prelude::DisplayExt::list_seats()].
    ///
    /// Output devices are represented by [`Monitor`][crate::Monitor] objects, which can
    /// be accessed with [`DisplayExt::monitor_at_surface()`][crate::prelude::DisplayExt::monitor_at_surface()] and similar APIs.
    ///
    /// # Implements
    ///
    /// [`DisplayExt`][trait@crate::prelude::DisplayExt], [`DisplayExtManual`][trait@crate::prelude::DisplayExtManual]
    #[doc(alias = "GdkDisplay")]
    pub struct Display(Object<ffi::GdkDisplay>);

    match fn {
        type_ => || ffi::gdk_display_get_type(),
    }
}

impl Display {
    pub const NONE: Option<&'static Display> = None;

    /// Gets the default [`Display`][crate::Display].
    ///
    /// This is a convenience function for:
    ///
    ///     gdk_display_manager_get_default_display (gdk_display_manager_get ())
    ///
    /// # Returns
    ///
    /// a [`Display`][crate::Display], or [`None`] if
    ///   there is no default display
    #[doc(alias = "gdk_display_get_default")]
    #[doc(alias = "get_default")]
    pub fn default() -> Option<Display> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gdk_display_get_default()) }
    }

    /// Opens a display.
    ///
    /// If opening the display fails, `NULL` is returned.
    /// ## `display_name`
    /// the name of the display to open
    ///
    /// # Returns
    ///
    /// a [`Display`][crate::Display]
    #[doc(alias = "gdk_display_open")]
    pub fn open(display_name: &str) -> Option<Display> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gdk_display_open(display_name.to_glib_none().0)) }
    }
}

impl fmt::Display for Display {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&DisplayExt::name(self))
    }
}

/// Trait containing all [`struct@Display`] methods.
///
/// # Implementors
///
/// [`Display`][struct@crate::Display]
pub trait DisplayExt: 'static {
    /// Emits a short beep on @self
    #[doc(alias = "gdk_display_beep")]
    fn beep(&self);

    /// Closes the connection to the windowing system for the given display.
    ///
    /// This cleans up associated resources.
    #[doc(alias = "gdk_display_close")]
    fn close(&self);

    /// Creates a new [`GLContext`][crate::GLContext] for the [`Display`][crate::Display].
    ///
    /// The context is disconnected from any particular surface or surface
    /// and cannot be used to draw to any surface. It can only be used to
    /// draw to non-surface framebuffers like textures.
    ///
    /// If the creation of the [`GLContext`][crate::GLContext] failed, @error will be set.
    /// Before using the returned [`GLContext`][crate::GLContext], you will need to
    /// call [`GLContextExt::make_current()`][crate::prelude::GLContextExt::make_current()] or [`GLContextExt::realize()`][crate::prelude::GLContextExt::realize()].
    ///
    /// # Returns
    ///
    /// the newly created [`GLContext`][crate::GLContext]
    #[cfg(any(feature = "v4_6", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_6")))]
    #[doc(alias = "gdk_display_create_gl_context")]
    fn create_gl_context(&self) -> Result<GLContext, glib::Error>;

    /// Returns [`true`] if there is an ongoing grab on @device for @self.
    /// ## `device`
    /// a [`Device`][crate::Device]
    ///
    /// # Returns
    ///
    /// [`true`] if there is a grab in effect for @device.
    #[doc(alias = "gdk_display_device_is_grabbed")]
    fn device_is_grabbed(&self, device: &impl IsA<Device>) -> bool;

    /// Flushes any requests queued for the windowing system.
    ///
    /// This happens automatically when the main loop blocks waiting for new events,
    /// but if your application is drawing without returning control to the main loop,
    /// you may need to call this function explicitly. A common case where this function
    /// needs to be called is when an application is executing drawing commands
    /// from a thread other than the thread where the main loop is running.
    ///
    /// This is most useful for X11. On windowing systems where requests are
    /// handled synchronously, this function will do nothing.
    #[doc(alias = "gdk_display_flush")]
    fn flush(&self);

    /// Returns a [`AppLaunchContext`][crate::AppLaunchContext] suitable for launching
    /// applications on the given display.
    ///
    /// # Returns
    ///
    /// a new [`AppLaunchContext`][crate::AppLaunchContext] for @self
    #[doc(alias = "gdk_display_get_app_launch_context")]
    #[doc(alias = "get_app_launch_context")]
    fn app_launch_context(&self) -> AppLaunchContext;

    /// Gets the clipboard used for copy/paste operations.
    ///
    /// # Returns
    ///
    /// the display's clipboard
    #[doc(alias = "gdk_display_get_clipboard")]
    #[doc(alias = "get_clipboard")]
    fn clipboard(&self) -> Clipboard;

    /// Returns the default [`Seat`][crate::Seat] for this display.
    ///
    /// Note that a display may not have a seat. In this case,
    /// this function will return [`None`].
    ///
    /// # Returns
    ///
    /// the default seat.
    #[doc(alias = "gdk_display_get_default_seat")]
    #[doc(alias = "get_default_seat")]
    fn default_seat(&self) -> Option<Seat>;

    /// Gets the monitor in which the largest area of @surface
    /// resides.
    ///
    /// Returns a monitor close to @surface if it is outside
    /// of all monitors.
    /// ## `surface`
    /// a [`Surface`][crate::Surface]
    ///
    /// # Returns
    ///
    /// the monitor with the largest
    ///   overlap with @surface
    #[doc(alias = "gdk_display_get_monitor_at_surface")]
    #[doc(alias = "get_monitor_at_surface")]
    fn monitor_at_surface(&self, surface: &impl IsA<Surface>) -> Monitor;

    /// Gets the list of monitors associated with this display.
    ///
    /// Subsequent calls to this function will always return the
    /// same list for the same display.
    ///
    /// You can listen to the GListModel::items-changed signal on
    /// this list to monitor changes to the monitor of this display.
    ///
    /// # Returns
    ///
    /// a `GListModel` of [`Monitor`][crate::Monitor]
    #[doc(alias = "gdk_display_get_monitors")]
    #[doc(alias = "get_monitors")]
    fn monitors(&self) -> gio::ListModel;

    /// Gets the name of the display.
    ///
    /// # Returns
    ///
    /// a string representing the display name. This string is owned
    ///   by GDK and should not be modified or freed.
    #[doc(alias = "gdk_display_get_name")]
    #[doc(alias = "get_name")]
    fn name(&self) -> glib::GString;

    /// Gets the clipboard used for the primary selection.
    ///
    /// On backends where the primary clipboard is not supported natively,
    /// GDK emulates this clipboard locally.
    ///
    /// # Returns
    ///
    /// the primary clipboard
    #[doc(alias = "gdk_display_get_primary_clipboard")]
    #[doc(alias = "get_primary_clipboard")]
    fn primary_clipboard(&self) -> Clipboard;

    /// Gets the startup notification ID for a Wayland display, or [`None`]
    /// if no ID has been defined.
    ///
    /// # Returns
    ///
    /// the startup notification ID for @self
    #[doc(alias = "gdk_display_get_startup_notification_id")]
    #[doc(alias = "get_startup_notification_id")]
    fn startup_notification_id(&self) -> Option<glib::GString>;

    /// Finds out if the display has been closed.
    ///
    /// # Returns
    ///
    /// [`true`] if the display is closed.
    #[doc(alias = "gdk_display_is_closed")]
    fn is_closed(&self) -> bool;

    /// Returns whether surfaces can reasonably be expected to have
    /// their alpha channel drawn correctly on the screen.
    ///
    /// Check [`is_rgba()`][Self::is_rgba()] for whether the display
    /// supports an alpha channel.
    ///
    /// On X11 this function returns whether a compositing manager is
    /// compositing on @self.
    ///
    /// On modern displays, this value is always [`true`].
    ///
    /// # Returns
    ///
    /// Whether surfaces with RGBA visuals can reasonably
    ///   be expected to have their alpha channels drawn correctly
    ///   on the screen.
    #[doc(alias = "gdk_display_is_composited")]
    fn is_composited(&self) -> bool;

    /// Returns whether surfaces on this @self are created with an
    /// alpha channel.
    ///
    /// Even if a [`true`] is returned, it is possible that the
    /// surface’s alpha channel won’t be honored when displaying the
    /// surface on the screen: in particular, for X an appropriate
    /// windowing manager and compositing manager must be running to
    /// provide appropriate display. Use [`is_composited()`][Self::is_composited()]
    /// to check if that is the case.
    ///
    /// On modern displays, this value is always [`true`].
    ///
    /// # Returns
    ///
    /// [`true`] if surfaces are created with an alpha channel or
    ///   [`false`] if the display does not support this functionality.
    #[doc(alias = "gdk_display_is_rgba")]
    fn is_rgba(&self) -> bool;

    /// Returns the list of seats known to @self.
    ///
    /// # Returns
    ///
    /// the
    ///   list of seats known to the [`Display`][crate::Display]
    #[doc(alias = "gdk_display_list_seats")]
    fn list_seats(&self) -> Vec<Seat>;

    /// Indicates to the GUI environment that the application has
    /// finished loading, using a given identifier.
    ///
    /// GTK will call this function automatically for `Gtk::Window`
    /// with custom startup-notification identifier unless
    /// `Gtk::Window::set_auto_startup_notification()`
    /// is called to disable that feature.
    /// ## `startup_id`
    /// a startup-notification identifier, for which
    ///   notification process should be completed
    #[doc(alias = "gdk_display_notify_startup_complete")]
    fn notify_startup_complete(&self, startup_id: &str);

    /// Checks that OpenGL is available for @self and ensures that it is
    /// properly initialized.
    /// When this fails, an @error will be set describing the error and this
    /// function returns [`false`].
    ///
    /// Note that even if this function succeeds, creating a [`GLContext`][crate::GLContext]
    /// may still fail.
    ///
    /// This function is idempotent. Calling it multiple times will just
    /// return the same value or error.
    ///
    /// You never need to call this function, GDK will call it automatically
    /// as needed. But you can use it as a check when setting up code that
    /// might make use of OpenGL.
    ///
    /// # Returns
    ///
    /// [`true`] if the display supports OpenGL
    #[cfg(any(feature = "v4_4", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_4")))]
    #[doc(alias = "gdk_display_prepare_gl")]
    fn prepare_gl(&self) -> Result<(), glib::Error>;

    /// Appends the given event onto the front of the event
    /// queue for @self.
    ///
    /// This function is only useful in very special situations
    /// and should not be used by applications.
    /// ## `event`
    /// a [`Event`][crate::Event]
    #[doc(alias = "gdk_display_put_event")]
    fn put_event(&self, event: impl AsRef<Event>);

    #[doc(alias = "gdk_display_supports_input_shapes")]
    fn supports_input_shapes(&self) -> bool;

    #[doc(alias = "gdk_display_sync")]
    fn sync(&self);

    #[doc(alias = "input-shapes")]
    fn is_input_shapes(&self) -> bool;

    #[doc(alias = "closed")]
    fn connect_closed<F: Fn(&Self, bool) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "opened")]
    fn connect_opened<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "seat-added")]
    fn connect_seat_added<F: Fn(&Self, &Seat) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "seat-removed")]
    fn connect_seat_removed<F: Fn(&Self, &Seat) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "setting-changed")]
    fn connect_setting_changed<F: Fn(&Self, &str) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "composited")]
    fn connect_composited_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "input-shapes")]
    fn connect_input_shapes_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "rgba")]
    fn connect_rgba_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<Display>> DisplayExt for O {
    fn beep(&self) {
        unsafe {
            ffi::gdk_display_beep(self.as_ref().to_glib_none().0);
        }
    }

    fn close(&self) {
        unsafe {
            ffi::gdk_display_close(self.as_ref().to_glib_none().0);
        }
    }

    #[cfg(any(feature = "v4_6", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_6")))]
    fn create_gl_context(&self) -> Result<GLContext, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret =
                ffi::gdk_display_create_gl_context(self.as_ref().to_glib_none().0, &mut error);
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn device_is_grabbed(&self, device: &impl IsA<Device>) -> bool {
        unsafe {
            from_glib(ffi::gdk_display_device_is_grabbed(
                self.as_ref().to_glib_none().0,
                device.as_ref().to_glib_none().0,
            ))
        }
    }

    fn flush(&self) {
        unsafe {
            ffi::gdk_display_flush(self.as_ref().to_glib_none().0);
        }
    }

    fn app_launch_context(&self) -> AppLaunchContext {
        unsafe {
            from_glib_full(ffi::gdk_display_get_app_launch_context(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn clipboard(&self) -> Clipboard {
        unsafe {
            from_glib_none(ffi::gdk_display_get_clipboard(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn default_seat(&self) -> Option<Seat> {
        unsafe {
            from_glib_none(ffi::gdk_display_get_default_seat(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn monitor_at_surface(&self, surface: &impl IsA<Surface>) -> Monitor {
        unsafe {
            from_glib_none(ffi::gdk_display_get_monitor_at_surface(
                self.as_ref().to_glib_none().0,
                surface.as_ref().to_glib_none().0,
            ))
        }
    }

    fn monitors(&self) -> gio::ListModel {
        unsafe {
            from_glib_none(ffi::gdk_display_get_monitors(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn name(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::gdk_display_get_name(self.as_ref().to_glib_none().0)) }
    }

    fn primary_clipboard(&self) -> Clipboard {
        unsafe {
            from_glib_none(ffi::gdk_display_get_primary_clipboard(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn startup_notification_id(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gdk_display_get_startup_notification_id(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn is_closed(&self) -> bool {
        unsafe { from_glib(ffi::gdk_display_is_closed(self.as_ref().to_glib_none().0)) }
    }

    fn is_composited(&self) -> bool {
        unsafe {
            from_glib(ffi::gdk_display_is_composited(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn is_rgba(&self) -> bool {
        unsafe { from_glib(ffi::gdk_display_is_rgba(self.as_ref().to_glib_none().0)) }
    }

    fn list_seats(&self) -> Vec<Seat> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gdk_display_list_seats(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn notify_startup_complete(&self, startup_id: &str) {
        unsafe {
            ffi::gdk_display_notify_startup_complete(
                self.as_ref().to_glib_none().0,
                startup_id.to_glib_none().0,
            );
        }
    }

    #[cfg(any(feature = "v4_4", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_4")))]
    fn prepare_gl(&self) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let is_ok = ffi::gdk_display_prepare_gl(self.as_ref().to_glib_none().0, &mut error);
            assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn put_event(&self, event: impl AsRef<Event>) {
        unsafe {
            ffi::gdk_display_put_event(
                self.as_ref().to_glib_none().0,
                event.as_ref().to_glib_none().0,
            );
        }
    }

    fn supports_input_shapes(&self) -> bool {
        unsafe {
            from_glib(ffi::gdk_display_supports_input_shapes(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn sync(&self) {
        unsafe {
            ffi::gdk_display_sync(self.as_ref().to_glib_none().0);
        }
    }

    fn is_input_shapes(&self) -> bool {
        glib::ObjectExt::property(self.as_ref(), "input-shapes")
    }

    fn connect_closed<F: Fn(&Self, bool) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn closed_trampoline<P: IsA<Display>, F: Fn(&P, bool) + 'static>(
            this: *mut ffi::GdkDisplay,
            is_error: glib::ffi::gboolean,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Display::from_glib_borrow(this).unsafe_cast_ref(),
                from_glib(is_error),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"closed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    closed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_opened<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn opened_trampoline<P: IsA<Display>, F: Fn(&P) + 'static>(
            this: *mut ffi::GdkDisplay,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Display::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"opened\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    opened_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_seat_added<F: Fn(&Self, &Seat) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn seat_added_trampoline<P: IsA<Display>, F: Fn(&P, &Seat) + 'static>(
            this: *mut ffi::GdkDisplay,
            seat: *mut ffi::GdkSeat,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Display::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(seat),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"seat-added\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    seat_added_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_seat_removed<F: Fn(&Self, &Seat) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn seat_removed_trampoline<
            P: IsA<Display>,
            F: Fn(&P, &Seat) + 'static,
        >(
            this: *mut ffi::GdkDisplay,
            seat: *mut ffi::GdkSeat,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Display::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(seat),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"seat-removed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    seat_removed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_setting_changed<F: Fn(&Self, &str) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn setting_changed_trampoline<
            P: IsA<Display>,
            F: Fn(&P, &str) + 'static,
        >(
            this: *mut ffi::GdkDisplay,
            setting: *mut libc::c_char,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Display::from_glib_borrow(this).unsafe_cast_ref(),
                &glib::GString::from_glib_borrow(setting),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"setting-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    setting_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_composited_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_composited_trampoline<P: IsA<Display>, F: Fn(&P) + 'static>(
            this: *mut ffi::GdkDisplay,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Display::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::composited\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_composited_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_input_shapes_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_input_shapes_trampoline<
            P: IsA<Display>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GdkDisplay,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Display::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::input-shapes\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_input_shapes_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_rgba_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_rgba_trampoline<P: IsA<Display>, F: Fn(&P) + 'static>(
            this: *mut ffi::GdkDisplay,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Display::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::rgba\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_rgba_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}