1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
// 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 crate::Display;
use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;
glib::wrapper! {
/// The purpose of the [`DisplayManager`][crate::DisplayManager] singleton object is to offer
/// notification when displays appear or disappear or the default display
/// changes.
///
/// You can use [`get()`][Self::get()] to obtain the [`DisplayManager`][crate::DisplayManager]
/// singleton, but that should be rarely necessary. Typically, initializing
/// GTK+ opens a display that you can work with without ever accessing the
/// [`DisplayManager`][crate::DisplayManager].
///
/// The GDK library can be built with support for multiple backends.
/// The [`DisplayManager`][crate::DisplayManager] object determines which backend is used
/// at runtime.
///
/// When writing backend-specific code that is supposed to work with
/// multiple GDK backends, you have to consider both compile time and
/// runtime. At compile time, use the `GDK_WINDOWING_X11`, `GDK_WINDOWING_WIN32`
/// macros, etc. to find out which backends are present in the GDK library
/// you are building your application against. At runtime, use type-check
/// macros like GDK_IS_X11_DISPLAY() to find out which backend is in use:
///
/// ## Backend-specific code ## {`backend`-specific}
///
///
///
/// **⚠️ The following code is in C ⚠️**
///
/// ```C
/// #ifdef GDK_WINDOWING_X11
/// if (GDK_IS_X11_DISPLAY (display))
/// {
/// // make X11-specific calls here
/// }
/// else
/// #endif
/// #ifdef GDK_WINDOWING_QUARTZ
/// if (GDK_IS_QUARTZ_DISPLAY (display))
/// {
/// // make Quartz-specific calls here
/// }
/// else
/// #endif
/// g_error ("Unsupported GDK backend");
/// ```
#[doc(alias = "GdkDisplayManager")]
pub struct DisplayManager(Object<ffi::GdkDisplayManager>);
match fn {
type_ => || ffi::gdk_display_manager_get_type(),
}
}
impl DisplayManager {
/// Gets the default [`Display`][crate::Display].
///
/// # Returns
///
/// a [`Display`][crate::Display], or [`None`] if
/// there is no default display.
#[doc(alias = "gdk_display_manager_get_default_display")]
#[doc(alias = "get_default_display")]
pub fn default_display(&self) -> Option<Display> {
unsafe {
from_glib_none(ffi::gdk_display_manager_get_default_display(
self.to_glib_none().0,
))
}
}
/// List all currently open displays.
///
/// # Returns
///
/// a newly
/// allocated `GSList` of [`Display`][crate::Display] objects. Free with `g_slist_free()`
/// when you are done with it.
#[doc(alias = "gdk_display_manager_list_displays")]
pub fn list_displays(&self) -> Vec<Display> {
unsafe {
FromGlibPtrContainer::from_glib_container(ffi::gdk_display_manager_list_displays(
self.to_glib_none().0,
))
}
}
/// Opens a display.
/// ## `name`
/// the name of the display to open
///
/// # Returns
///
/// a [`Display`][crate::Display], or [`None`] if the
/// display could not be opened
#[doc(alias = "gdk_display_manager_open_display")]
pub fn open_display(&self, name: &str) -> Option<Display> {
unsafe {
from_glib_none(ffi::gdk_display_manager_open_display(
self.to_glib_none().0,
name.to_glib_none().0,
))
}
}
/// Sets `display` as the default display.
/// ## `display`
/// a [`Display`][crate::Display]
#[doc(alias = "gdk_display_manager_set_default_display")]
pub fn set_default_display(&self, display: &Display) {
unsafe {
ffi::gdk_display_manager_set_default_display(
self.to_glib_none().0,
display.to_glib_none().0,
);
}
}
/// Gets the singleton [`DisplayManager`][crate::DisplayManager] object.
///
/// When called for the first time, this function consults the
/// `GDK_BACKEND` environment variable to find out which
/// of the supported GDK backends to use (in case GDK has been compiled
/// with multiple backends). Applications can use [`set_allowed_backends()`][crate::set_allowed_backends()]
/// to limit what backends can be used.
///
/// # Returns
///
/// The global [`DisplayManager`][crate::DisplayManager] singleton;
/// `gdk_parse_args()`, `gdk_init()`, or `gdk_init_check()` must have
/// been called first.
#[doc(alias = "gdk_display_manager_get")]
pub fn get() -> DisplayManager {
assert_initialized_main_thread!();
unsafe { from_glib_none(ffi::gdk_display_manager_get()) }
}
/// The ::display-opened signal is emitted when a display is opened.
/// ## `display`
/// the opened display
#[doc(alias = "display-opened")]
pub fn connect_display_opened<F: Fn(&Self, &Display) + 'static>(
&self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn display_opened_trampoline<
F: Fn(&DisplayManager, &Display) + 'static,
>(
this: *mut ffi::GdkDisplayManager,
display: *mut ffi::GdkDisplay,
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(display))
}
unsafe {
let f: Box_<F> = Box_::new(f);
connect_raw(
self.as_ptr() as *mut _,
b"display-opened\0".as_ptr() as *const _,
Some(transmute::<_, unsafe extern "C" fn()>(
display_opened_trampoline::<F> as *const (),
)),
Box_::into_raw(f),
)
}
}
#[doc(alias = "default-display")]
pub fn connect_default_display_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_default_display_trampoline<F: Fn(&DisplayManager) + 'static>(
this: *mut ffi::GdkDisplayManager,
_param_spec: glib::ffi::gpointer,
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe {
let f: Box_<F> = Box_::new(f);
connect_raw(
self.as_ptr() as *mut _,
b"notify::default-display\0".as_ptr() as *const _,
Some(transmute::<_, unsafe extern "C" fn()>(
notify_default_display_trampoline::<F> as *const (),
)),
Box_::into_raw(f),
)
}
}
}
impl fmt::Display for DisplayManager {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str("DisplayManager")
}
}