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

use glib::object::IsA;
use glib::translate::*;
use std::fmt;
use std::mem;
use std::ptr;

glib::wrapper! {
    ///
    ///
    /// # Implements
    ///
    /// [`trait@gdk::prelude::DisplayExt`]
    #[doc(alias = "GdkX11Display")]
    pub struct X11Display(Object<ffi::GdkX11Display, ffi::GdkX11DisplayClass>) @extends gdk::Display;

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

impl X11Display {
    //#[doc(alias = "gdk_x11_display_broadcast_startup_message")]
    //pub fn broadcast_startup_message(&self, message_type: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
    //    unsafe { TODO: call ffi:gdk_x11_display_broadcast_startup_message() }
    //}

    /// Pops the error trap pushed by [`error_trap_push()`][Self::error_trap_push()].
    /// Will XSync() if necessary and will always block until
    /// the error is known to have occurred or not occurred,
    /// so the error code can be returned.
    ///
    /// If you don’t need to use the return value,
    /// [`error_trap_pop_ignored()`][Self::error_trap_pop_ignored()] would be more efficient.
    ///
    /// See `gdk_error_trap_pop()` for the all-displays-at-once
    /// equivalent.
    ///
    /// # Returns
    ///
    /// X error code or 0 on success
    #[doc(alias = "gdk_x11_display_error_trap_pop")]
    pub fn error_trap_pop(&self) -> i32 {
        unsafe { ffi::gdk_x11_display_error_trap_pop(self.to_glib_none().0) }
    }

    /// Pops the error trap pushed by [`error_trap_push()`][Self::error_trap_push()].
    /// Does not block to see if an error occurred; merely records the
    /// range of requests to ignore errors for, and ignores those errors
    /// if they arrive asynchronously.
    ///
    /// See `gdk_error_trap_pop_ignored()` for the all-displays-at-once
    /// equivalent.
    #[doc(alias = "gdk_x11_display_error_trap_pop_ignored")]
    pub fn error_trap_pop_ignored(&self) {
        unsafe {
            ffi::gdk_x11_display_error_trap_pop_ignored(self.to_glib_none().0);
        }
    }

    /// Begins a range of X requests on `self` for which X error events
    /// will be ignored. Unignored errors (when no trap is pushed) will abort
    /// the application. Use [`error_trap_pop()`][Self::error_trap_pop()] or
    /// [`error_trap_pop_ignored()`][Self::error_trap_pop_ignored()]to lift a trap pushed
    /// with this function.
    ///
    /// See also `gdk_error_trap_push()` to push a trap on all displays.
    #[doc(alias = "gdk_x11_display_error_trap_push")]
    pub fn error_trap_push(&self) {
        unsafe {
            ffi::gdk_x11_display_error_trap_push(self.to_glib_none().0);
        }
    }

    /// Gets the startup notification ID for a display.
    ///
    /// # Returns
    ///
    /// the startup notification ID for `self`
    #[doc(alias = "gdk_x11_display_get_startup_notification_id")]
    #[doc(alias = "get_startup_notification_id")]
    pub fn startup_notification_id(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gdk_x11_display_get_startup_notification_id(
                self.to_glib_none().0,
            ))
        }
    }

    /// Returns the timestamp of the last user interaction on
    /// `self`. The timestamp is taken from events caused
    /// by user interaction such as key presses or pointer
    /// movements. See [`X11Window::set_user_time()`][crate::X11Window::set_user_time()].
    ///
    /// # Returns
    ///
    /// the timestamp of the last user interaction
    #[doc(alias = "gdk_x11_display_get_user_time")]
    #[doc(alias = "get_user_time")]
    pub fn user_time(&self) -> u32 {
        unsafe { ffi::gdk_x11_display_get_user_time(self.to_glib_none().0) }
    }

    /// Call XGrabServer() on `self`.
    /// To ungrab the display again, use [`ungrab()`][Self::ungrab()].
    ///
    /// [`grab()`][Self::grab()]/[`ungrab()`][Self::ungrab()] calls can be nested.
    #[doc(alias = "gdk_x11_display_grab")]
    pub fn grab(&self) {
        unsafe {
            ffi::gdk_x11_display_grab(self.to_glib_none().0);
        }
    }

    /// Sets the cursor theme from which the images for cursor
    /// should be taken.
    ///
    /// If the windowing system supports it, existing cursors created
    /// with `gdk_cursor_new()`, [`gdk::Cursor::for_display()`][crate::gdk::Cursor::for_display()] and
    /// [`gdk::Cursor::from_name()`][crate::gdk::Cursor::from_name()] are updated to reflect the theme
    /// change. Custom cursors constructed with
    /// [`gdk::Cursor::from_pixbuf()`][crate::gdk::Cursor::from_pixbuf()] will have to be handled
    /// by the application (GTK+ applications can learn about
    /// cursor theme changes by listening for change notification
    /// for the corresponding `GtkSetting`).
    /// ## `theme`
    /// the name of the cursor theme to use, or [`None`] to unset
    ///  a previously set value
    /// ## `size`
    /// the cursor size to use, or 0 to keep the previous size
    #[doc(alias = "gdk_x11_display_set_cursor_theme")]
    pub fn set_cursor_theme(&self, theme: Option<&str>, size: i32) {
        unsafe {
            ffi::gdk_x11_display_set_cursor_theme(
                self.to_glib_none().0,
                theme.to_glib_none().0,
                size,
            );
        }
    }

    /// Sets the startup notification ID for a display.
    ///
    /// This is usually taken from the value of the DESKTOP_STARTUP_ID
    /// environment variable, but in some cases (such as the application not
    /// being launched using `exec()`) it can come from other sources.
    ///
    /// If the ID contains the string "_TIME" then the portion following that
    /// string is taken to be the X11 timestamp of the event that triggered
    /// the application to be launched and the GDK current event time is set
    /// accordingly.
    ///
    /// The startup ID is also what is used to signal that the startup is
    /// complete (for example, when opening a window or when calling
    /// `gdk_notify_startup_complete()`).
    /// ## `startup_id`
    /// the startup notification ID (must be valid utf8)
    #[doc(alias = "gdk_x11_display_set_startup_notification_id")]
    pub fn set_startup_notification_id(&self, startup_id: &str) {
        unsafe {
            ffi::gdk_x11_display_set_startup_notification_id(
                self.to_glib_none().0,
                startup_id.to_glib_none().0,
            );
        }
    }

    /// Forces a specific window scale for all windows on this display,
    /// instead of using the default or user configured scale. This
    /// is can be used to disable scaling support by setting `scale` to
    /// 1, or to programmatically set the window scale.
    ///
    /// Once the scale is set by this call it will not change in response
    /// to later user configuration changes.
    /// ## `scale`
    /// The new scale value
    #[doc(alias = "gdk_x11_display_set_window_scale")]
    pub fn set_window_scale(&self, scale: i32) {
        unsafe {
            ffi::gdk_x11_display_set_window_scale(self.to_glib_none().0, scale);
        }
    }

    /// Convert a string from the encoding of the current
    /// locale into a form suitable for storing in a window property.
    /// ## `str`
    /// a nul-terminated string
    ///
    /// # Returns
    ///
    /// 0 upon success, non-zero upon failure
    ///
    /// ## `encoding`
    /// location to store the encoding atom
    ///  (to be used as the type for the property)
    ///
    /// ## `format`
    /// location to store the format of the property
    ///
    /// ## `ctext`
    /// location to store newly
    ///  allocated data for the property
    #[doc(alias = "gdk_x11_display_string_to_compound_text")]
    pub fn string_to_compound_text(&self, str: &str) -> (i32, gdk::Atom, i32, Vec<u8>) {
        unsafe {
            let mut encoding = gdk::Atom::uninitialized();
            let mut format = mem::MaybeUninit::uninit();
            let mut ctext = ptr::null_mut();
            let mut length = mem::MaybeUninit::uninit();
            let ret = ffi::gdk_x11_display_string_to_compound_text(
                self.to_glib_none().0,
                str.to_glib_none().0,
                encoding.to_glib_none_mut().0,
                format.as_mut_ptr(),
                &mut ctext,
                length.as_mut_ptr(),
            );
            (
                ret,
                encoding,
                format.assume_init(),
                FromGlibContainer::from_glib_full_num(ctext, length.assume_init() as usize),
            )
        }
    }

    /// Ungrab `self` after it has been grabbed with
    /// [`grab()`][Self::grab()].
    #[doc(alias = "gdk_x11_display_ungrab")]
    pub fn ungrab(&self) {
        unsafe {
            ffi::gdk_x11_display_ungrab(self.to_glib_none().0);
        }
    }

    /// Converts from UTF-8 to compound text.
    /// ## `str`
    /// a UTF-8 string
    ///
    /// # Returns
    ///
    /// [`true`] if the conversion succeeded,
    ///  otherwise [`false`]
    ///
    /// ## `encoding`
    /// location to store resulting encoding
    ///
    /// ## `format`
    /// location to store format of the result
    ///
    /// ## `ctext`
    /// location to store the data of the result
    #[doc(alias = "gdk_x11_display_utf8_to_compound_text")]
    pub fn utf8_to_compound_text(&self, str: &str) -> Option<(gdk::Atom, i32, Vec<u8>)> {
        unsafe {
            let mut encoding = gdk::Atom::uninitialized();
            let mut format = mem::MaybeUninit::uninit();
            let mut ctext = ptr::null_mut();
            let mut length = mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gdk_x11_display_utf8_to_compound_text(
                self.to_glib_none().0,
                str.to_glib_none().0,
                encoding.to_glib_none_mut().0,
                format.as_mut_ptr(),
                &mut ctext,
                length.as_mut_ptr(),
            ));
            if ret {
                Some((
                    encoding,
                    format.assume_init(),
                    FromGlibContainer::from_glib_full_num(ctext, length.assume_init() as usize),
                ))
            } else {
                None
            }
        }
    }

    /// Retrieves the version of the GLX implementation.
    /// ## `display`
    /// a [`gdk::Display`][crate::gdk::Display]
    ///
    /// # Returns
    ///
    /// [`true`] if GLX is available
    ///
    /// ## `major`
    /// return location for the GLX major version
    ///
    /// ## `minor`
    /// return location for the GLX minor version
    #[doc(alias = "gdk_x11_display_get_glx_version")]
    #[doc(alias = "get_glx_version")]
    pub fn glx_version(display: &impl IsA<gdk::Display>) -> Option<(i32, i32)> {
        assert_initialized_main_thread!();
        unsafe {
            let mut major = mem::MaybeUninit::uninit();
            let mut minor = mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gdk_x11_display_get_glx_version(
                display.as_ref().to_glib_none().0,
                major.as_mut_ptr(),
                minor.as_mut_ptr(),
            ));
            if ret {
                Some((major.assume_init(), minor.assume_init()))
            } else {
                None
            }
        }
    }
}

impl fmt::Display for X11Display {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("X11Display")
    }
}