gdk4_x11/auto/

x11_display.rs

// 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
#![allow(deprecated)]

use crate::{ffi, X11Screen};
use glib::translate::*;

glib::wrapper! {
    ///
    ///
    /// ## Signals
    ///
    ///
    /// #### `xevent`
    ///  The ::xevent signal is a low level signal that is emitted
    /// whenever an XEvent has been received.
    ///
    /// When handlers to this signal return [`true`], no other handlers will be
    /// invoked. In particular, the default handler for this function is
    /// GDK's own event handling mechanism, so by returning [`true`] for an event
    /// that GDK expects to translate, you may break GDK and/or GTK+ in
    /// interesting ways. You have been warned.
    ///
    /// If you want this signal handler to queue a [`gdk::Event`][crate::gdk::Event], you can use
    /// gdk_display_put_event().
    ///
    /// If you are interested in X GenericEvents, bear in mind that
    /// XGetEventData() has been already called on the event, and
    /// XFreeEventData() will be called afterwards.
    ///
    ///
    /// <details><summary><h4>Display</h4></summary>
    ///
    ///
    /// #### `closed`
    ///  Emitted when the connection to the windowing system for @display is closed.
    ///
    ///
    ///
    ///
    /// #### `opened`
    ///  Emitted when the connection to the windowing system for @display is opened.
    ///
    ///
    ///
    ///
    /// #### `seat-added`
    ///  Emitted whenever a new seat is made known to the windowing system.
    ///
    ///
    ///
    ///
    /// #### `seat-removed`
    ///  Emitted whenever a seat is removed by the windowing system.
    ///
    ///
    ///
    ///
    /// #### `setting-changed`
    ///  Emitted whenever a setting changes its value.
    ///
    ///
    /// </details>
    ///
    /// # 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 gdk_x11_display_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,
    /// gdk_x11_display_error_trap_pop_ignored() would be more efficient.
    ///
    /// # 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 gdk_x11_display_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.
    #[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 gdk_x11_display_error_trap_pop() or
    /// gdk_x11_display_error_trap_pop_ignored()to lift a trap pushed
    /// with this function.
    #[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);
        }
    }

    /// Returns the default group leader surface for all toplevel surfaces
    /// on @self. This surface is implicitly created by GDK.
    /// See gdk_x11_surface_set_group().
    ///
    /// # Returns
    ///
    /// The default group leader surface
    /// for @self
    #[doc(alias = "gdk_x11_display_get_default_group")]
    #[doc(alias = "get_default_group")]
    pub fn default_group(&self) -> gdk::Surface {
        unsafe {
            from_glib_none(ffi::gdk_x11_display_get_default_group(
                self.to_glib_none().0,
            ))
        }
    }

    /// Retrieves the version of the EGL implementation.
    ///
    /// # Deprecated since 4.18
    ///
    ///
    /// # Returns
    ///
    /// [`true`] if EGL is available
    ///
    /// ## `major`
    /// return location for the EGL major version
    ///
    /// ## `minor`
    /// return location for the EGL minor version
    #[cfg_attr(feature = "v4_18", deprecated = "Since 4.18")]
    #[cfg(feature = "v4_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
    #[allow(deprecated)]
    #[doc(alias = "gdk_x11_display_get_egl_version")]
    #[doc(alias = "get_egl_version")]
    pub fn egl_version(&self) -> Option<(i32, i32)> {
        unsafe {
            let mut major = std::mem::MaybeUninit::uninit();
            let mut minor = std::mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gdk_x11_display_get_egl_version(
                self.to_glib_none().0,
                major.as_mut_ptr(),
                minor.as_mut_ptr(),
            ));
            if ret {
                Some((major.assume_init(), minor.assume_init()))
            } else {
                None
            }
        }
    }

    /// Retrieves the version of the GLX implementation.
    ///
    /// # Deprecated since 4.18
    ///
    ///
    /// # Returns
    ///
    /// [`true`] if GLX is available
    ///
    /// ## `major`
    /// return location for the GLX major version
    ///
    /// ## `minor`
    /// return location for the GLX minor version
    #[cfg_attr(feature = "v4_18", deprecated = "Since 4.18")]
    #[allow(deprecated)]
    #[doc(alias = "gdk_x11_display_get_glx_version")]
    #[doc(alias = "get_glx_version")]
    pub fn glx_version(&self) -> Option<(i32, i32)> {
        unsafe {
            let mut major = std::mem::MaybeUninit::uninit();
            let mut minor = std::mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gdk_x11_display_get_glx_version(
                self.to_glib_none().0,
                major.as_mut_ptr(),
                minor.as_mut_ptr(),
            ));
            if ret {
                Some((major.assume_init(), minor.assume_init()))
            } else {
                None
            }
        }
    }

    /// Gets the primary monitor for the display.
    ///
    /// The primary monitor is considered the monitor where the “main desktop”
    /// lives. While normal application surfaces typically allow the window
    /// manager to place the surfaces, specialized desktop applications
    /// such as panels should place themselves on the primary monitor.
    ///
    /// If no monitor is the designated primary monitor, any monitor
    /// (usually the first) may be returned.
    ///
    /// # Returns
    ///
    /// the primary monitor, or any monitor if no
    ///   primary monitor is configured by the user
    #[doc(alias = "gdk_x11_display_get_primary_monitor")]
    #[doc(alias = "get_primary_monitor")]
    pub fn primary_monitor(&self) -> gdk::Monitor {
        unsafe {
            from_glib_none(ffi::gdk_x11_display_get_primary_monitor(
                self.to_glib_none().0,
            ))
        }
    }

    /// Retrieves the [`X11Screen`][crate::X11Screen] of the @self.
    ///
    /// # Returns
    ///
    /// the [`X11Screen`][crate::X11Screen]
    #[doc(alias = "gdk_x11_display_get_screen")]
    #[doc(alias = "get_screen")]
    pub fn screen(&self) -> X11Screen {
        unsafe { from_glib_none(ffi::gdk_x11_display_get_screen(self.to_glib_none().0)) }
    }

    /// Gets the startup notification ID for a display.
    ///
    /// # Deprecated since 4.10
    ///
    ///
    /// # Returns
    ///
    /// the startup notification ID for @self
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[doc(alias = "gdk_x11_display_get_startup_notification_id")]
    #[doc(alias = "get_startup_notification_id")]
    pub fn startup_notification_id(&self) -> 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 gdk_x11_surface_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 gdk_x11_display_ungrab().
    ///
    /// gdk_x11_display_grab()/gdk_x11_display_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::from_name()`][crate::gdk::Cursor::from_name()] are updated to reflect the theme
    /// change. Custom cursors constructed with [`gdk::Cursor::from_texture()`][crate::gdk::Cursor::from_texture()]
    /// 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`).
    ///
    /// # Deprecated since 4.16
    ///
    /// Use the cursor-related properties of
    ///   [GtkSettings](../gtk4/class.Settings.html) to set the cursor theme
    /// ## `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
    #[cfg_attr(feature = "v4_16", deprecated = "Since 4.16")]
    #[allow(deprecated)]
    #[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_display_notify_startup_complete()).
    ///
    /// # Deprecated since 4.10
    ///
    /// Using `Gdk::Toplevel::set_startup_id()` is sufficient
    /// ## `startup_id`
    /// the startup notification ID (must be valid utf8)
    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
    #[allow(deprecated)]
    #[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_surface_scale")]
    pub fn set_surface_scale(&self, scale: i32) {
        unsafe {
            ffi::gdk_x11_display_set_surface_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.
    ///
    /// # Deprecated since 4.18
    ///
    /// ## `str`
    /// a nul-terminated string
    ///
    /// # Returns
    ///
    /// 0 upon success, non-zero upon failure
    ///
    /// ## `encoding`
    /// location to store the encoding
    ///   (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
    #[cfg_attr(feature = "v4_18", deprecated = "Since 4.18")]
    #[allow(deprecated)]
    #[doc(alias = "gdk_x11_display_string_to_compound_text")]
    pub fn string_to_compound_text(&self, str: &str) -> (i32, glib::GString, i32, Vec<u8>) {
        unsafe {
            let mut encoding = std::ptr::null();
            let mut format = std::mem::MaybeUninit::uninit();
            let mut ctext = std::ptr::null_mut();
            let mut length = std::mem::MaybeUninit::uninit();
            let ret = ffi::gdk_x11_display_string_to_compound_text(
                self.to_glib_none().0,
                str.to_glib_none().0,
                &mut encoding,
                format.as_mut_ptr(),
                &mut ctext,
                length.as_mut_ptr(),
            );
            (
                ret,
                from_glib_none(encoding),
                format.assume_init(),
                FromGlibContainer::from_glib_full_num(ctext, length.assume_init() as _),
            )
        }
    }

    /// Ungrab @self after it has been grabbed with
    /// gdk_x11_display_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.
    ///
    /// # Deprecated since 4.18
    ///
    /// ## `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
    #[cfg_attr(feature = "v4_18", deprecated = "Since 4.18")]
    #[allow(deprecated)]
    #[doc(alias = "gdk_x11_display_utf8_to_compound_text")]
    pub fn utf8_to_compound_text(&self, str: &str) -> Option<(glib::GString, i32, Vec<u8>)> {
        unsafe {
            let mut encoding = std::ptr::null();
            let mut format = std::mem::MaybeUninit::uninit();
            let mut ctext = std::ptr::null_mut();
            let mut length = std::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,
                &mut encoding,
                format.as_mut_ptr(),
                &mut ctext,
                length.as_mut_ptr(),
            ));
            if ret {
                Some((
                    from_glib_none(encoding),
                    format.assume_init(),
                    FromGlibContainer::from_glib_full_num(ctext, length.assume_init() as _),
                ))
            } else {
                None
            }
        }
    }

    /// Tries to open a new display to the X server given by
    /// @display_name. If opening the display fails, [`None`] is
    /// returned.
    ///
    /// # Deprecated since 4.18
    ///
    /// ## `display_name`
    /// name of the X display.
    ///   See the XOpenDisplay() for details.
    ///
    /// # Returns
    ///
    /// The new display
    #[cfg_attr(feature = "v4_18", deprecated = "Since 4.18")]
    #[allow(deprecated)]
    #[doc(alias = "gdk_x11_display_open")]
    pub fn open(display_name: Option<&str>) -> Option<gdk::Display> {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gdk_x11_display_open(display_name.to_glib_none().0)) }
    }
}