2016-03-02 13:06:13 +11:00
|
|
|
#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
|
2015-04-24 17:51:23 +10:00
|
|
|
|
2017-01-28 23:03:17 +11:00
|
|
|
use std::collections::VecDeque;
|
|
|
|
use std::sync::Arc;
|
2017-06-22 03:34:16 +10:00
|
|
|
use std::env;
|
2015-05-04 15:32:02 +10:00
|
|
|
|
2017-06-02 21:19:45 +10:00
|
|
|
use {CreationError, CursorState, EventsLoopClosed, MouseCursor, ControlFlow};
|
2017-01-28 23:03:17 +11:00
|
|
|
use libc;
|
|
|
|
|
2017-03-04 06:56:27 +11:00
|
|
|
use self::x11::XConnection;
|
|
|
|
use self::x11::XError;
|
|
|
|
use self::x11::XNotSupported;
|
|
|
|
use self::x11::ffi::XVisualInfo;
|
|
|
|
|
|
|
|
mod dlopen;
|
|
|
|
pub mod wayland;
|
|
|
|
pub mod x11;
|
|
|
|
|
2017-06-22 05:10:23 +10:00
|
|
|
/// Environment variable specifying which backend should be used on unix platform.
|
|
|
|
///
|
|
|
|
/// Legal values are x11 and wayland. If this variable is set only the named backend
|
|
|
|
/// will be tried by winit. If it is not set, winit will try to connect to a wayland connection,
|
|
|
|
/// and if it fails will fallback on x11.
|
|
|
|
///
|
|
|
|
/// If this variable is set with any other value, winit will panic.
|
2017-06-22 04:54:21 +10:00
|
|
|
const BACKEND_PREFERENCE_ENV_VAR: &str = "WINIT_UNIX_BACKEND";
|
2017-06-22 03:34:16 +10:00
|
|
|
|
2017-01-28 23:03:17 +11:00
|
|
|
#[derive(Clone, Default)]
|
|
|
|
pub struct PlatformSpecificWindowBuilderAttributes {
|
|
|
|
pub visual_infos: Option<XVisualInfo>,
|
|
|
|
pub screen_id: Option<i32>,
|
|
|
|
}
|
|
|
|
|
|
|
|
pub enum UnixBackend {
|
|
|
|
X(Arc<XConnection>),
|
|
|
|
Wayland(Arc<wayland::WaylandContext>),
|
2017-06-22 04:41:26 +10:00
|
|
|
Error(Option<XNotSupported>, Option<String>),
|
2017-06-22 03:34:16 +10:00
|
|
|
}
|
2017-01-28 23:03:17 +11:00
|
|
|
|
|
|
|
lazy_static!(
|
|
|
|
pub static ref UNIX_BACKEND: UnixBackend = {
|
2017-06-22 03:34:16 +10:00
|
|
|
#[inline]
|
2017-06-22 04:41:26 +10:00
|
|
|
fn x_backend() -> Result<UnixBackend, XNotSupported> {
|
2017-01-28 23:03:17 +11:00
|
|
|
match XConnection::new(Some(x_error_callback)) {
|
2017-06-22 04:41:26 +10:00
|
|
|
Ok(x) => Ok(UnixBackend::X(Arc::new(x))),
|
|
|
|
Err(e) => Err(e),
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
2017-06-22 04:41:26 +10:00
|
|
|
#[inline]
|
|
|
|
fn wayland_backend() -> Result<UnixBackend, ()> {
|
|
|
|
wayland::WaylandContext::init()
|
|
|
|
.map(|ctx| UnixBackend::Wayland(Arc::new(ctx)))
|
|
|
|
.ok_or(())
|
|
|
|
}
|
2017-06-22 03:34:16 +10:00
|
|
|
match env::var(BACKEND_PREFERENCE_ENV_VAR) {
|
2017-06-22 04:41:26 +10:00
|
|
|
Ok(s) => match s.as_str() {
|
|
|
|
"x11" => x_backend().unwrap_or_else(|e| UnixBackend::Error(Some(e), None)),
|
|
|
|
"wayland" => wayland_backend().unwrap_or_else(|_| {
|
|
|
|
UnixBackend::Error(None, Some("Wayland not available".into()))
|
|
|
|
}),
|
|
|
|
_ => panic!("Unknown environment variable value for {}, try one of `x11`,`wayland`",
|
|
|
|
BACKEND_PREFERENCE_ENV_VAR),
|
2017-06-22 03:34:16 +10:00
|
|
|
},
|
2017-06-22 04:41:26 +10:00
|
|
|
Err(_) => {
|
|
|
|
// Try wayland, fallback to X11
|
|
|
|
wayland_backend().unwrap_or_else(|_| {
|
|
|
|
x_backend().unwrap_or_else(|x_err| {
|
|
|
|
UnixBackend::Error(Some(x_err), Some("Wayland not available".into()))
|
|
|
|
})
|
|
|
|
})
|
2017-06-22 03:34:16 +10:00
|
|
|
},
|
|
|
|
}
|
2017-01-28 23:03:17 +11:00
|
|
|
};
|
|
|
|
);
|
|
|
|
|
|
|
|
|
2017-03-04 07:41:51 +11:00
|
|
|
pub enum Window2 {
|
2017-01-28 23:03:17 +11:00
|
|
|
#[doc(hidden)]
|
2017-03-04 07:41:51 +11:00
|
|
|
X(x11::Window2),
|
2017-01-28 23:03:17 +11:00
|
|
|
#[doc(hidden)]
|
2017-03-11 09:56:31 +11:00
|
|
|
Wayland(wayland::Window)
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
|
2017-03-04 07:41:51 +11:00
|
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
|
|
pub enum WindowId {
|
2017-01-28 23:03:17 +11:00
|
|
|
#[doc(hidden)]
|
2017-03-04 07:41:51 +11:00
|
|
|
X(x11::WindowId),
|
2017-01-28 23:03:17 +11:00
|
|
|
#[doc(hidden)]
|
2017-03-04 07:41:51 +11:00
|
|
|
Wayland(wayland::WindowId)
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
|
2017-04-23 06:52:35 +10:00
|
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
|
|
pub enum DeviceId {
|
|
|
|
#[doc(hidden)]
|
|
|
|
X(x11::DeviceId),
|
|
|
|
#[doc(hidden)]
|
|
|
|
Wayland(wayland::DeviceId)
|
|
|
|
}
|
|
|
|
|
2017-01-28 23:03:17 +11:00
|
|
|
#[derive(Clone)]
|
|
|
|
pub enum MonitorId {
|
|
|
|
#[doc(hidden)]
|
|
|
|
X(x11::MonitorId),
|
|
|
|
#[doc(hidden)]
|
|
|
|
Wayland(wayland::MonitorId),
|
|
|
|
#[doc(hidden)]
|
|
|
|
None,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn get_available_monitors() -> VecDeque<MonitorId> {
|
|
|
|
match *UNIX_BACKEND {
|
|
|
|
UnixBackend::Wayland(ref ctxt) => wayland::get_available_monitors(ctxt)
|
|
|
|
.into_iter()
|
|
|
|
.map(MonitorId::Wayland)
|
|
|
|
.collect(),
|
|
|
|
UnixBackend::X(ref connec) => x11::get_available_monitors(connec)
|
|
|
|
.into_iter()
|
|
|
|
.map(MonitorId::X)
|
|
|
|
.collect(),
|
2017-06-22 04:41:26 +10:00
|
|
|
UnixBackend::Error(..) => { let mut d = VecDeque::new(); d.push_back(MonitorId::None); d},
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn get_primary_monitor() -> MonitorId {
|
|
|
|
match *UNIX_BACKEND {
|
|
|
|
UnixBackend::Wayland(ref ctxt) => MonitorId::Wayland(wayland::get_primary_monitor(ctxt)),
|
|
|
|
UnixBackend::X(ref connec) => MonitorId::X(x11::get_primary_monitor(connec)),
|
2017-06-22 04:41:26 +10:00
|
|
|
UnixBackend::Error(..) => MonitorId::None,
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl MonitorId {
|
|
|
|
#[inline]
|
|
|
|
pub fn get_name(&self) -> Option<String> {
|
|
|
|
match self {
|
|
|
|
&MonitorId::X(ref m) => m.get_name(),
|
|
|
|
&MonitorId::Wayland(ref m) => m.get_name(),
|
|
|
|
&MonitorId::None => None,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn get_native_identifier(&self) -> ::native_monitor::NativeMonitorId {
|
|
|
|
match self {
|
|
|
|
&MonitorId::X(ref m) => m.get_native_identifier(),
|
|
|
|
&MonitorId::Wayland(ref m) => m.get_native_identifier(),
|
|
|
|
&MonitorId::None => unimplemented!() // FIXME:
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn get_dimensions(&self) -> (u32, u32) {
|
|
|
|
match self {
|
|
|
|
&MonitorId::X(ref m) => m.get_dimensions(),
|
|
|
|
&MonitorId::Wayland(ref m) => m.get_dimensions(),
|
|
|
|
&MonitorId::None => (800, 600), // FIXME:
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-04 07:41:51 +11:00
|
|
|
impl Window2 {
|
2017-01-28 23:03:17 +11:00
|
|
|
#[inline]
|
2017-06-02 21:19:45 +10:00
|
|
|
pub fn new(events_loop: &EventsLoop,
|
|
|
|
window: &::WindowAttributes,
|
2017-03-04 07:41:51 +11:00
|
|
|
pl_attribs: &PlatformSpecificWindowBuilderAttributes)
|
2017-06-02 21:19:45 +10:00
|
|
|
-> Result<Self, CreationError>
|
2017-01-28 23:03:17 +11:00
|
|
|
{
|
|
|
|
match *UNIX_BACKEND {
|
|
|
|
UnixBackend::Wayland(ref ctxt) => {
|
2017-03-05 00:04:01 +11:00
|
|
|
if let EventsLoop::Wayland(ref evlp) = *events_loop {
|
2017-03-11 09:56:31 +11:00
|
|
|
wayland::Window::new(evlp, ctxt.clone(), window).map(Window2::Wayland)
|
2017-03-05 00:04:01 +11:00
|
|
|
} else {
|
|
|
|
// It is not possible to instanciate an EventsLoop not matching its backend
|
|
|
|
unreachable!()
|
|
|
|
}
|
2017-01-28 23:03:17 +11:00
|
|
|
},
|
|
|
|
|
2017-04-23 06:52:35 +10:00
|
|
|
UnixBackend::X(_) => {
|
|
|
|
x11::Window2::new(events_loop, window, pl_attribs).map(Window2::X)
|
2017-01-28 23:03:17 +11:00
|
|
|
},
|
2017-06-22 04:41:26 +10:00
|
|
|
UnixBackend::Error(..) => {
|
2017-03-04 07:41:51 +11:00
|
|
|
// If the Backend is Error(), it is not possible to instanciate an EventsLoop at all,
|
|
|
|
// thus this function cannot be called!
|
|
|
|
unreachable!()
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-04 07:41:51 +11:00
|
|
|
#[inline]
|
|
|
|
pub fn id(&self) -> WindowId {
|
2017-03-04 20:48:44 +11:00
|
|
|
match self {
|
|
|
|
&Window2::X(ref w) => WindowId::X(w.id()),
|
|
|
|
&Window2::Wayland(ref w) => WindowId::Wayland(w.id())
|
|
|
|
}
|
2017-03-04 07:41:51 +11:00
|
|
|
}
|
|
|
|
|
2017-01-28 23:03:17 +11:00
|
|
|
#[inline]
|
|
|
|
pub fn set_title(&self, title: &str) {
|
|
|
|
match self {
|
2017-03-04 07:41:51 +11:00
|
|
|
&Window2::X(ref w) => w.set_title(title),
|
|
|
|
&Window2::Wayland(ref w) => w.set_title(title)
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn show(&self) {
|
|
|
|
match self {
|
2017-03-04 07:41:51 +11:00
|
|
|
&Window2::X(ref w) => w.show(),
|
|
|
|
&Window2::Wayland(ref w) => w.show()
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn hide(&self) {
|
|
|
|
match self {
|
2017-03-04 07:41:51 +11:00
|
|
|
&Window2::X(ref w) => w.hide(),
|
|
|
|
&Window2::Wayland(ref w) => w.hide()
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn get_position(&self) -> Option<(i32, i32)> {
|
|
|
|
match self {
|
2017-03-04 07:41:51 +11:00
|
|
|
&Window2::X(ref w) => w.get_position(),
|
|
|
|
&Window2::Wayland(ref w) => w.get_position()
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn set_position(&self, x: i32, y: i32) {
|
|
|
|
match self {
|
2017-03-04 07:41:51 +11:00
|
|
|
&Window2::X(ref w) => w.set_position(x, y),
|
|
|
|
&Window2::Wayland(ref w) => w.set_position(x, y)
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn get_inner_size(&self) -> Option<(u32, u32)> {
|
|
|
|
match self {
|
2017-03-04 07:41:51 +11:00
|
|
|
&Window2::X(ref w) => w.get_inner_size(),
|
|
|
|
&Window2::Wayland(ref w) => w.get_inner_size()
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn get_outer_size(&self) -> Option<(u32, u32)> {
|
|
|
|
match self {
|
2017-03-04 07:41:51 +11:00
|
|
|
&Window2::X(ref w) => w.get_outer_size(),
|
|
|
|
&Window2::Wayland(ref w) => w.get_outer_size()
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn set_inner_size(&self, x: u32, y: u32) {
|
|
|
|
match self {
|
2017-03-04 07:41:51 +11:00
|
|
|
&Window2::X(ref w) => w.set_inner_size(x, y),
|
|
|
|
&Window2::Wayland(ref w) => w.set_inner_size(x, y)
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn set_cursor(&self, cursor: MouseCursor) {
|
|
|
|
match self {
|
2017-03-04 07:41:51 +11:00
|
|
|
&Window2::X(ref w) => w.set_cursor(cursor),
|
|
|
|
&Window2::Wayland(ref w) => w.set_cursor(cursor)
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn set_cursor_state(&self, state: CursorState) -> Result<(), String> {
|
|
|
|
match self {
|
2017-03-04 07:41:51 +11:00
|
|
|
&Window2::X(ref w) => w.set_cursor_state(state),
|
|
|
|
&Window2::Wayland(ref w) => w.set_cursor_state(state)
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn hidpi_factor(&self) -> f32 {
|
|
|
|
match self {
|
2017-03-04 07:41:51 +11:00
|
|
|
&Window2::X(ref w) => w.hidpi_factor(),
|
|
|
|
&Window2::Wayland(ref w) => w.hidpi_factor()
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn set_cursor_position(&self, x: i32, y: i32) -> Result<(), ()> {
|
|
|
|
match self {
|
2017-03-04 07:41:51 +11:00
|
|
|
&Window2::X(ref w) => w.set_cursor_position(x, y),
|
|
|
|
&Window2::Wayland(ref w) => w.set_cursor_position(x, y)
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn platform_display(&self) -> *mut libc::c_void {
|
|
|
|
use wayland_client::Proxy;
|
|
|
|
match self {
|
2017-03-04 07:41:51 +11:00
|
|
|
&Window2::X(ref w) => w.platform_display(),
|
|
|
|
&Window2::Wayland(ref w) => w.get_display().ptr() as *mut _
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn platform_window(&self) -> *mut libc::c_void {
|
|
|
|
use wayland_client::Proxy;
|
|
|
|
match self {
|
2017-03-04 07:41:51 +11:00
|
|
|
&Window2::X(ref w) => w.platform_window(),
|
|
|
|
&Window2::Wayland(ref w) => w.get_surface().ptr() as *mut _
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
}
|
2017-08-28 09:19:26 +10:00
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn set_maximized(&self, maximized: bool) {
|
|
|
|
match self {
|
|
|
|
&Window2::X(ref w) => w.set_maximized(maximized),
|
|
|
|
&Window2::Wayland(ref _w) => {},
|
|
|
|
}
|
|
|
|
}
|
2017-01-28 23:03:17 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
unsafe extern "C" fn x_error_callback(dpy: *mut x11::ffi::Display, event: *mut x11::ffi::XErrorEvent)
|
|
|
|
-> libc::c_int
|
|
|
|
{
|
|
|
|
use std::ffi::CStr;
|
|
|
|
|
|
|
|
if let UnixBackend::X(ref x) = *UNIX_BACKEND {
|
|
|
|
let mut buff: Vec<u8> = Vec::with_capacity(1024);
|
|
|
|
(x.xlib.XGetErrorText)(dpy, (*event).error_code as i32, buff.as_mut_ptr() as *mut libc::c_char, buff.capacity() as i32);
|
|
|
|
let description = CStr::from_ptr(buff.as_mut_ptr() as *const libc::c_char).to_string_lossy();
|
|
|
|
|
|
|
|
let error = XError {
|
|
|
|
description: description.into_owned(),
|
|
|
|
error_code: (*event).error_code,
|
|
|
|
request_code: (*event).request_code,
|
|
|
|
minor_code: (*event).minor_code,
|
|
|
|
};
|
|
|
|
|
|
|
|
*x.latest_error.lock().unwrap() = Some(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
0
|
|
|
|
}
|
2017-03-04 07:41:51 +11:00
|
|
|
|
|
|
|
pub enum EventsLoop {
|
|
|
|
#[doc(hidden)]
|
|
|
|
Wayland(wayland::EventsLoop),
|
|
|
|
#[doc(hidden)]
|
|
|
|
X(x11::EventsLoop)
|
|
|
|
}
|
|
|
|
|
2017-05-25 23:19:13 +10:00
|
|
|
pub enum EventsLoopProxy {
|
|
|
|
X(x11::EventsLoopProxy),
|
|
|
|
Wayland(wayland::EventsLoopProxy),
|
|
|
|
}
|
|
|
|
|
2017-03-04 07:41:51 +11:00
|
|
|
impl EventsLoop {
|
|
|
|
pub fn new() -> EventsLoop {
|
|
|
|
match *UNIX_BACKEND {
|
2017-03-05 00:04:01 +11:00
|
|
|
UnixBackend::Wayland(ref ctxt) => {
|
|
|
|
EventsLoop::Wayland(wayland::EventsLoop::new(ctxt.clone()))
|
2017-03-04 07:41:51 +11:00
|
|
|
},
|
|
|
|
|
2017-04-23 06:52:35 +10:00
|
|
|
UnixBackend::X(ref ctxt) => {
|
|
|
|
EventsLoop::X(x11::EventsLoop::new(ctxt.clone()))
|
2017-03-04 07:41:51 +11:00
|
|
|
},
|
|
|
|
|
2017-06-22 04:41:26 +10:00
|
|
|
UnixBackend::Error(..) => {
|
2017-03-04 07:41:51 +11:00
|
|
|
panic!("Attempted to create an EventsLoop while no backend was available.")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-25 23:19:13 +10:00
|
|
|
pub fn create_proxy(&self) -> EventsLoopProxy {
|
|
|
|
match *self {
|
|
|
|
EventsLoop::Wayland(ref evlp) => EventsLoopProxy::Wayland(evlp.create_proxy()),
|
|
|
|
EventsLoop::X(ref evlp) => EventsLoopProxy::X(evlp.create_proxy()),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-02 21:19:45 +10:00
|
|
|
pub fn poll_events<F>(&mut self, callback: F)
|
2017-03-04 07:41:51 +11:00
|
|
|
where F: FnMut(::Event)
|
|
|
|
{
|
|
|
|
match *self {
|
2017-06-02 21:19:45 +10:00
|
|
|
EventsLoop::Wayland(ref mut evlp) => evlp.poll_events(callback),
|
|
|
|
EventsLoop::X(ref mut evlp) => evlp.poll_events(callback)
|
2017-03-04 07:41:51 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-02 21:19:45 +10:00
|
|
|
pub fn run_forever<F>(&mut self, callback: F)
|
|
|
|
where F: FnMut(::Event) -> ControlFlow
|
2017-03-04 07:41:51 +11:00
|
|
|
{
|
|
|
|
match *self {
|
2017-06-02 21:19:45 +10:00
|
|
|
EventsLoop::Wayland(ref mut evlp) => evlp.run_forever(callback),
|
|
|
|
EventsLoop::X(ref mut evlp) => evlp.run_forever(callback)
|
2017-03-04 07:41:51 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-05-25 23:19:13 +10:00
|
|
|
|
|
|
|
impl EventsLoopProxy {
|
|
|
|
pub fn wakeup(&self) -> Result<(), EventsLoopClosed> {
|
|
|
|
match *self {
|
|
|
|
EventsLoopProxy::Wayland(ref proxy) => proxy.wakeup(),
|
|
|
|
EventsLoopProxy::X(ref proxy) => proxy.wakeup(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|