Merge branch 'web' into webmerge2

src/platform/android.rs

@@ -1,18 +1,16 @@
 #![cfg(any(target_os = "android"))]
 
+use crate::{EventLoop, Window, WindowBuilder};
 use std::os::raw::c_void;
-use EventLoop;
-use Window;
-use WindowBuilder;
 
 /// Additional methods on `EventLoop` that are specific to Android.
 pub trait EventLoopExtAndroid {
     /// Makes it possible for glutin to register a callback when a suspend event happens on Android
-    fn set_suspend_callback(&self, cb: Option<Box<Fn(bool) -> ()>>);
+    fn set_suspend_callback(&self, cb: Option<Box<dyn Fn(bool) -> ()>>);
 }
 
 impl EventLoopExtAndroid for EventLoop {
-    fn set_suspend_callback(&self, cb: Option<Box<Fn(bool) -> ()>>) {
+    fn set_suspend_callback(&self, cb: Option<Box<dyn Fn(bool) -> ()>>) {
         self.event_loop.set_suspend_callback(cb);
     }
 }
@@ -30,9 +28,6 @@ impl WindowExtAndroid for Window {
 }
 
 /// Additional methods on `WindowBuilder` that are specific to Android.
-pub trait WindowBuilderExtAndroid {
+pub trait WindowBuilderExtAndroid {}
 
-}
-
-impl WindowBuilderExtAndroid for WindowBuilder {
-}
+impl WindowBuilderExtAndroid for WindowBuilder {}

src/platform/desktop.rs

@@ -4,8 +4,10 @@
     target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"
 ))]
 
-use event::Event;
-use event_loop::{EventLoop, EventLoopWindowTarget, ControlFlow};
+use crate::{
+    event::Event,
+    event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
+};
 
 /// Additional methods on `EventLoop` that are specific to desktop platforms.
 pub trait EventLoopExtDesktop {
@@ -16,15 +18,27 @@ pub trait EventLoopExtDesktop {
     ///
     /// Unlike `run`, this function accepts non-`'static` (i.e. non-`move`) closures and returns
     /// control flow to the caller when `control_flow` is set to `ControlFlow::Exit`.
+    ///
+    /// # Caveats
+    /// Despite its apperance at first glance, this is *not* a perfect replacement for
+    /// `poll_events`. For example, this function will not return on Windows or macOS while a
+    /// window is getting resized, resulting in all application logic outside of the
+    /// `event_handler` closure not running until the resize operation ends. Other OS operations
+    /// may also result in such freezes. This behavior is caused by fundamental limitations in the
+    /// underyling OS APIs, which cannot be hidden by Winit without severe stability reprecussions.
+    ///
+    /// You are strongly encouraged to use `run`, unless the use of this is absolutely necessary.
     fn run_return<F>(&mut self, event_handler: F)
-        where F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>, &mut ControlFlow);
+    where
+        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>, &mut ControlFlow);
 }
 
 impl<T> EventLoopExtDesktop for EventLoop<T> {
     type UserEvent = T;
 
     fn run_return<F>(&mut self, event_handler: F)
-        where F: FnMut(Event<T>, &EventLoopWindowTarget<T>, &mut ControlFlow)
+    where
+        F: FnMut(Event<T>, &EventLoopWindowTarget<T>, &mut ControlFlow),
     {
         self.event_loop.run_return(event_handler)
     }

src/platform/ios.rs

@@ -2,9 +2,11 @@
 
 use std::os::raw::c_void;
 
-use event_loop::EventLoop;
-use monitor::MonitorHandle;
-use window::{Window, WindowBuilder};
+use crate::{
+    event_loop::EventLoop,
+    monitor::MonitorHandle,
+    window::{Window, WindowBuilder},
+};
 
 /// Additional methods on `EventLoop` that are specific to iOS.
 pub trait EventLoopExtIOS {

src/platform/macos.rs

@@ -2,29 +2,47 @@
 
 use std::os::raw::c_void;
 
-use crate::dpi::LogicalSize;
-use crate::monitor::MonitorHandle;
-use crate::window::{Window, WindowBuilder};
+use crate::{
+    dpi::LogicalSize,
+    monitor::MonitorHandle,
+    window::{Window, WindowBuilder},
+};
+
+/// Corresponds to `NSRequestUserAttentionType`.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum RequestUserAttentionType {
+    /// Corresponds to `NSCriticalRequest`.
+    ///
+    /// Dock icon will bounce until the application is focused.
+    Critical,
+
+    /// Corresponds to `NSInformationalRequest`.
+    ///
+    /// Dock icon will bounce once.
+    Informational,
+}
+
+impl Default for RequestUserAttentionType {
+    fn default() -> Self {
+        RequestUserAttentionType::Critical
+    }
+}
 
 /// Additional methods on `Window` that are specific to MacOS.
 pub trait WindowExtMacOS {
     /// Returns a pointer to the cocoa `NSWindow` that is used by this window.
     ///
     /// The pointer will become invalid when the `Window` is destroyed.
-    fn nswindow(&self) -> *mut c_void;
+    fn ns_window(&self) -> *mut c_void;
 
     /// Returns a pointer to the cocoa `NSView` that is used by this window.
     ///
     /// The pointer will become invalid when the `Window` is destroyed.
-    fn nsview(&self) -> *mut c_void;
+    fn ns_view(&self) -> *mut c_void;
 
     /// Request user attention, causing the application's dock icon to bounce.
     /// Note that this has no effect if the application is already focused.
-    ///
-    /// The `is_critical` flag has the following effects:
-    /// - `false`: the dock icon will only bounce once.
-    /// - `true`: the dock icon will bounce until the application is focused.
-    fn request_user_attention(&self, is_critical: bool);
+    fn request_user_attention(&self, request_type: RequestUserAttentionType);
 
     /// Returns whether or not the window is in simple fullscreen mode.
     fn simple_fullscreen(&self) -> bool;
@@ -41,18 +59,18 @@ pub trait WindowExtMacOS {
 
 impl WindowExtMacOS for Window {
     #[inline]
-    fn nswindow(&self) -> *mut c_void {
-        self.window.nswindow()
+    fn ns_window(&self) -> *mut c_void {
+        self.window.ns_window()
     }
 
     #[inline]
-    fn nsview(&self) -> *mut c_void {
-        self.window.nsview()
+    fn ns_view(&self) -> *mut c_void {
+        self.window.ns_view()
     }
 
     #[inline]
-    fn request_user_attention(&self, is_critical: bool) {
-        self.window.request_user_attention(is_critical)
+    fn request_user_attention(&self, request_type: RequestUserAttentionType) {
+        self.window.request_user_attention(request_type)
     }
 
     #[inline]
@@ -97,7 +115,8 @@ pub trait WindowBuilderExtMacOS {
     /// Sets the activation policy for the window being built.
     fn with_activation_policy(self, activation_policy: ActivationPolicy) -> WindowBuilder;
     /// Enables click-and-drag behavior for the entire window, not just the titlebar.
-    fn with_movable_by_window_background(self, movable_by_window_background: bool) -> WindowBuilder;
+    fn with_movable_by_window_background(self, movable_by_window_background: bool)
+        -> WindowBuilder;
     /// Makes the titlebar transparent and allows the content to appear behind it.
     fn with_titlebar_transparent(self, titlebar_transparent: bool) -> WindowBuilder;
     /// Hides the window title.
@@ -120,7 +139,10 @@ impl WindowBuilderExtMacOS for WindowBuilder {
     }
 
     #[inline]
-    fn with_movable_by_window_background(mut self, movable_by_window_background: bool) -> WindowBuilder {
+    fn with_movable_by_window_background(
+        mut self,
+        movable_by_window_background: bool,
+    ) -> WindowBuilder {
         self.platform_specific.movable_by_window_background = movable_by_window_background;
         self
     }
@@ -167,7 +189,7 @@ pub trait MonitorHandleExtMacOS {
     /// Returns the identifier of the monitor for Cocoa.
     fn native_id(&self) -> u32;
     /// Returns a pointer to the NSScreen representing this monitor.
-    fn nsscreen(&self) -> Option<*mut c_void>;
+    fn ns_screen(&self) -> Option<*mut c_void>;
 }
 
 impl MonitorHandleExtMacOS for MonitorHandle {
@@ -176,7 +198,7 @@ impl MonitorHandleExtMacOS for MonitorHandle {
         self.inner.native_identifier()
     }
 
-    fn nsscreen(&self) -> Option<*mut c_void> {
-        self.inner.nsscreen().map(|s| s as *mut c_void)
+    fn ns_screen(&self) -> Option<*mut c_void> {
+        self.inner.ns_screen().map(|s| s as *mut c_void)
     }
 }

src/platform/unix.rs

@@ -1,29 +1,26 @@
 #![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"))]
 
-use std::os::raw;
-use std::ptr;
-use std::sync::Arc;
+use std::{os::raw, ptr, sync::Arc};
 
-use sctk::window::{ButtonState, Theme};
+use smithay_client_toolkit::window::{ButtonState, Theme};
 
-use dpi::LogicalSize;
-use event_loop::EventLoop;
-use monitor::MonitorHandle;
-use window::{Window, WindowBuilder};
-
-use platform_impl::{
-    EventLoop as LinuxEventLoop,
-    Window as LinuxWindow,
+use crate::{
+    dpi::LogicalSize,
+    event_loop::EventLoop,
+    monitor::MonitorHandle,
+    window::{Window, WindowBuilder},
+};
+
+use crate::platform_impl::{
+    x11::{ffi::XVisualInfo, XConnection},
+    EventLoop as LinuxEventLoop, Window as LinuxWindow,
 };
-use platform_impl::x11::XConnection;
-use platform_impl::x11::ffi::XVisualInfo;
 
 // TODO: stupid hack so that glutin can do its work
 #[doc(hidden)]
-pub use platform_impl::x11;
+pub use crate::platform_impl::x11;
 
-pub use platform_impl::XNotSupported;
-pub use platform_impl::x11::util::WindowType as XWindowType;
+pub use crate::platform_impl::{x11::util::WindowType as XWindowType, XNotSupported};
 
 /// Theme for wayland client side decorations
 ///
@@ -97,11 +94,13 @@ impl Theme for WaylandThemeObject {
 pub trait EventLoopExtUnix {
     /// Builds a new `EventLoops` that is forced to use X11.
     fn new_x11() -> Result<Self, XNotSupported>
-        where Self: Sized;
+    where
+        Self: Sized;
 
     /// Builds a new `EventLoop` that is forced to use Wayland.
     fn new_wayland() -> Self
-        where Self: Sized;
+    where
+        Self: Sized;
 
     /// True if the `EventLoop` uses Wayland.
     fn is_wayland(&self) -> bool;
@@ -123,12 +122,10 @@ pub trait EventLoopExtUnix {
 impl<T> EventLoopExtUnix for EventLoop<T> {
     #[inline]
     fn new_x11() -> Result<Self, XNotSupported> {
-        LinuxEventLoop::new_x11().map(|ev|
-            EventLoop {
-                event_loop: ev,
-                _marker: ::std::marker::PhantomData,
-            }
-        )
+        LinuxEventLoop::new_x11().map(|ev| EventLoop {
+            event_loop: ev,
+            _marker: ::std::marker::PhantomData,
+        })
     }
 
     #[inline]
@@ -136,7 +133,7 @@ impl<T> EventLoopExtUnix for EventLoop<T> {
         EventLoop {
             event_loop: match LinuxEventLoop::new_wayland() {
                 Ok(e) => e,
-                Err(_) => panic!()      // TODO: propagate
+                Err(_) => panic!(), // TODO: propagate
             },
             _marker: ::std::marker::PhantomData,
         }
@@ -157,7 +154,7 @@ impl<T> EventLoopExtUnix for EventLoop<T> {
     fn xlib_xconnection(&self) -> Option<Arc<XConnection>> {
         match self.event_loop {
             LinuxEventLoop::X(ref e) => Some(e.x_connection().clone()),
-            _ => None
+            _ => None,
         }
     }
 
@@ -165,7 +162,7 @@ impl<T> EventLoopExtUnix for EventLoop<T> {
     fn wayland_display(&self) -> Option<*mut raw::c_void> {
         match self.event_loop {
             LinuxEventLoop::Wayland(ref e) => Some(e.display().get_display_ptr() as *mut _),
-            _ => None
+            _ => None,
         }
     }
 }
@@ -231,7 +228,7 @@ impl WindowExtUnix for Window {
     fn xlib_window(&self) -> Option<raw::c_ulong> {
         match self.window {
             LinuxWindow::X(ref w) => Some(w.xlib_window()),
-            _ => None
+            _ => None,
         }
     }
 
@@ -239,7 +236,7 @@ impl WindowExtUnix for Window {
     fn xlib_display(&self) -> Option<*mut raw::c_void> {
         match self.window {
             LinuxWindow::X(ref w) => Some(w.xlib_display()),
-            _ => None
+            _ => None,
         }
     }
 
@@ -247,7 +244,7 @@ impl WindowExtUnix for Window {
     fn xlib_screen_id(&self) -> Option<raw::c_int> {
         match self.window {
             LinuxWindow::X(ref w) => Some(w.xlib_screen_id()),
-            _ => None
+            _ => None,
         }
     }
 
@@ -256,7 +253,7 @@ impl WindowExtUnix for Window {
     fn xlib_xconnection(&self) -> Option<Arc<XConnection>> {
         match self.window {
             LinuxWindow::X(ref w) => Some(w.xlib_xconnection()),
-            _ => None
+            _ => None,
         }
     }
 
@@ -264,7 +261,7 @@ impl WindowExtUnix for Window {
     fn xcb_connection(&self) -> Option<*mut raw::c_void> {
         match self.window {
             LinuxWindow::X(ref w) => Some(w.xcb_connection()),
-            _ => None
+            _ => None,
         }
     }
 
@@ -279,7 +276,7 @@ impl WindowExtUnix for Window {
     fn wayland_surface(&self) -> Option<*mut raw::c_void> {
         match self.window {
             LinuxWindow::Wayland(ref w) => Some(w.surface().as_ref().c_ptr() as *mut _),
-            _ => None
+            _ => None,
         }
     }
 
@@ -287,7 +284,7 @@ impl WindowExtUnix for Window {
     fn wayland_display(&self) -> Option<*mut raw::c_void> {
         match self.window {
             LinuxWindow::Wayland(ref w) => Some(w.display().as_ref().c_ptr() as *mut _),
-            _ => None
+            _ => None,
         }
     }
 
@@ -334,9 +331,8 @@ pub trait WindowBuilderExtUnix {
 impl WindowBuilderExtUnix for WindowBuilder {
     #[inline]
     fn with_x11_visual<T>(mut self, visual_infos: *const T) -> WindowBuilder {
-        self.platform_specific.visual_infos = Some(
-            unsafe { ptr::read(visual_infos as *const XVisualInfo) }
-        );
+        self.platform_specific.visual_infos =
+            Some(unsafe { ptr::read(visual_infos as *const XVisualInfo) });
         self
     }
 

src/platform/windows.rs

@@ -5,17 +5,21 @@ use std::os::raw::c_void;
 use libc;
 use winapi::shared::windef::HWND;
 
-use event::DeviceId;
-use monitor::MonitorHandle;
-use event_loop::EventLoop;
-use window::{Icon, Window, WindowBuilder};
-use platform_impl::EventLoop as WindowsEventLoop;
+use crate::{
+    event::DeviceId,
+    event_loop::EventLoop,
+    monitor::MonitorHandle,
+    platform_impl::EventLoop as WindowsEventLoop,
+    window::{Icon, Window, WindowBuilder},
+};
 
 /// Additional methods on `EventLoop` that are specific to Windows.
 pub trait EventLoopExtWindows {
     /// By default, winit on Windows will attempt to enable process-wide DPI awareness. If that's
     /// undesirable, you can create an `EventLoop` using this function instead.
-    fn new_dpi_unaware() -> Self where Self: Sized;
+    fn new_dpi_unaware() -> Self
+    where
+        Self: Sized;
 }
 
 impl<T> EventLoopExtWindows for EventLoop<T> {