Mirror monitor list methods on Window (#567)

* macOS: Monitor list methods on Window

* X11+Wayland: Monitor list methods on Window

* Windows: Monitor list methods on Window

* iOS: Monitor list methods on Window

* Android: Monitor list methods on Window

* Emscripten: Monitor list methods on Window

* Fixed Wayland implementation

src/platform/android/mod.rs

@@ -385,6 +385,18 @@ impl Window {
         RootMonitorId { inner: MonitorId }
     }
 
+    #[inline]
+    pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
+        let mut rb = VecDeque::with_capacity(1);
+        rb.push_back(MonitorId);
+        rb
+    }
+
+    #[inline]
+    pub fn get_primary_monitor(&self) -> MonitorId {
+        MonitorId
+    }
+
     #[inline]
     pub fn id(&self) -> WindowId {
         WindowId

src/platform/emscripten/mod.rs

@@ -9,7 +9,8 @@ use std::os::raw::{c_char, c_void, c_double, c_ulong, c_int};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Mutex, Arc};
 
-use {LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize};
+use dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize};
+use window::MonitorId as RootMonitorId;
 
 const DOCUMENT_NAME: &'static str = "#document\0";
 
@@ -582,8 +583,20 @@ impl Window {
     }
 
     #[inline]
-    pub fn get_current_monitor(&self) -> ::MonitorId {
-        ::MonitorId{inner: MonitorId}
+    pub fn get_current_monitor(&self) -> RootMonitorId {
+        RootMonitorId { inner: MonitorId }
+    }
+
+    #[inline]
+    pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
+        let mut list = VecDeque::with_capacity(1);
+        list.push_back(MonitorId);
+        list
+    }
+
+    #[inline]
+    pub fn get_primary_monitor(&self) -> MonitorId {
+        MonitorId
     }
 }
 

src/platform/ios/mod.rs

@@ -447,6 +447,18 @@ impl Window {
         RootMonitorId { inner: MonitorId }
     }
 
+    #[inline]
+    pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
+        let mut rb = VecDeque::with_capacity(1);
+        rb.push_back(MonitorId);
+        rb
+    }
+
+    #[inline]
+    pub fn get_primary_monitor(&self) -> MonitorId {
+        MonitorId
+    }
+
     #[inline]
     pub fn id(&self) -> WindowId {
         WindowId

src/platform/linux/mod.rs

@@ -325,8 +325,30 @@ impl Window {
     #[inline]
     pub fn get_current_monitor(&self) -> RootMonitorId {
         match self {
-            &Window::X(ref w) => RootMonitorId{inner: MonitorId::X(w.get_current_monitor())},
-            &Window::Wayland(ref w) => RootMonitorId{inner: MonitorId::Wayland(w.get_current_monitor())},
+            &Window::X(ref window) => RootMonitorId { inner: MonitorId::X(window.get_current_monitor()) },
+            &Window::Wayland(ref window) => RootMonitorId { inner: MonitorId::Wayland(window.get_current_monitor()) },
+        }
+    }
+
+    #[inline]
+    pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
+        match self {
+            &Window::X(ref window) => window.get_available_monitors()
+                .into_iter()
+                .map(MonitorId::X)
+                .collect(),
+            &Window::Wayland(ref window) => window.get_available_monitors()
+                .into_iter()
+                .map(MonitorId::Wayland)
+                .collect(),
+        }
+    }
+
+    #[inline]
+    pub fn get_primary_monitor(&self) -> MonitorId {
+        match self {
+            &Window::X(ref window) => MonitorId::X(window.get_primary_monitor()),
+            &Window::Wayland(ref window) => MonitorId::Wayland(window.get_primary_monitor()),
         }
     }
 }

src/platform/linux/wayland/event_loop.rs

@@ -199,27 +199,11 @@ impl EventsLoop {
     }
 
     pub fn get_primary_monitor(&self) -> MonitorId {
-        self.env.outputs.with_all(|list| {
-            if let Some(&(_, ref proxy, _)) = list.first() {
-                MonitorId {
-                    proxy: proxy.clone(),
-                    mgr: self.env.outputs.clone(),
-                }
-            } else {
-                panic!("No monitor is available.")
-            }
-        })
+        get_primary_monitor(&self.env.outputs)
     }
 
     pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
-        self.env.outputs.with_all(|list| {
-            list.iter()
-                .map(|&(_, ref proxy, _)| MonitorId {
-                    proxy: proxy.clone(),
-                    mgr: self.env.outputs.clone(),
-                })
-                .collect()
-        })
+        get_available_monitors(&self.env.outputs)
     }
 }
 
@@ -494,3 +478,27 @@ impl MonitorId {
             .unwrap_or(1)
     }
 }
+
+pub fn get_primary_monitor(outputs: &OutputMgr) -> MonitorId {
+    outputs.with_all(|list| {
+        if let Some(&(_, ref proxy, _)) = list.first() {
+            MonitorId {
+                proxy: proxy.clone(),
+                mgr: outputs.clone(),
+            }
+        } else {
+            panic!("No monitor is available.")
+        }
+    })
+}
+
+pub fn get_available_monitors(outputs: &OutputMgr) -> VecDeque<MonitorId> {
+    outputs.with_all(|list| {
+        list.iter()
+            .map(|&(_, ref proxy, _)| MonitorId {
+                proxy: proxy.clone(),
+                mgr: outputs.clone(),
+            })
+            .collect()
+    })
+}

src/platform/linux/wayland/window.rs

@@ -1,3 +1,4 @@
+use std::collections::VecDeque;
 use std::sync::{Arc, Mutex, Weak};
 
 use {CreationError, CursorState, MouseCursor, WindowAttributes, LogicalPosition, LogicalSize};
@@ -9,13 +10,16 @@ use sctk::reexports::client::{Display, Proxy};
 use sctk::reexports::client::protocol::{wl_seat, wl_surface, wl_output};
 use sctk::reexports::client::protocol::wl_compositor::RequestsTrait as CompositorRequests;
 use sctk::reexports::client::protocol::wl_surface::RequestsTrait as SurfaceRequests;
+use sctk::output::OutputMgr;
 
 use super::{make_wid, EventsLoop, MonitorId, WindowId};
+use platform::platform::wayland::event_loop::{get_available_monitors, get_primary_monitor};
 
 pub struct Window {
     surface: Proxy<wl_surface::WlSurface>,
     frame: Arc<Mutex<SWindow<BasicFrame>>>,
-    monitors: Arc<Mutex<MonitorList>>,
+    monitors: Arc<Mutex<MonitorList>>, // Monitors this window is currently on
+    outputs: OutputMgr, // Access to info for all monitors
     size: Arc<Mutex<(u32, u32)>>,
     kill_switch: (Arc<Mutex<bool>>, Arc<Mutex<bool>>),
     display: Arc<Display>,
@@ -153,6 +157,7 @@ impl Window {
             surface: surface,
             frame: frame,
             monitors: monitor_list,
+            outputs: evlp.env.outputs.clone(),
             size: size,
             kill_switch: (kill_switch, evlp.cleanup_needed.clone()),
             need_frame_refresh: need_frame_refresh,
@@ -297,6 +302,14 @@ impl Window {
         let guard = self.monitors.lock().unwrap();
         guard.monitors.last().unwrap().clone()
     }
+
+    pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
+        get_available_monitors(&self.outputs)
+    }
+
+    pub fn get_primary_monitor(&self) -> MonitorId {
+        get_primary_monitor(&self.outputs)
+    }
 }
 
 impl Drop for Window {

src/platform/linux/x11/window.rs

@@ -503,6 +503,14 @@ impl UnownedWindow {
             })
     }
 
+    pub fn get_available_monitors(&self) -> Vec<X11MonitorId> {
+        self.xconn.get_available_monitors()
+    }
+
+    pub fn get_primary_monitor(&self) -> X11MonitorId {
+        self.xconn.get_primary_monitor()
+    }
+
     fn set_maximized_inner(&self, maximized: bool) -> util::Flusher {
         let horz_atom = unsafe { self.xconn.get_atom_unchecked(b"_NET_WM_STATE_MAXIMIZED_HORZ\0") };
         let vert_atom = unsafe { self.xconn.get_atom_unchecked(b"_NET_WM_STATE_MAXIMIZED_VERT\0") };

src/platform/macos/monitor.rs

@@ -8,26 +8,37 @@ use core_graphics::display::{CGDirectDisplayID, CGDisplay, CGDisplayBounds};
 
 use {PhysicalPosition, PhysicalSize};
 use super::EventsLoop;
-use super::window::IdRef;
+use super::window::{IdRef, Window2};
 
 #[derive(Clone, PartialEq)]
 pub struct MonitorId(CGDirectDisplayID);
 
-impl EventsLoop {
-    pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
-        let mut monitors = VecDeque::new();
-        if let Ok(displays) = CGDisplay::active_displays() {
-            for d in displays {
-                monitors.push_back(MonitorId(d));
-            }
+fn get_available_monitors() -> VecDeque<MonitorId> {
+    if let Ok(displays) = CGDisplay::active_displays() {
+        let mut monitors = VecDeque::with_capacity(displays.len());
+        for d in displays {
+            monitors.push_back(MonitorId(d));
         }
         monitors
+    } else {
+        VecDeque::with_capacity(0)
+    }
+}
+
+pub fn get_primary_monitor() -> MonitorId {
+    let id = MonitorId(CGDisplay::main().id);
+    id
+}
+
+impl EventsLoop {
+    #[inline]
+    pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
+        get_available_monitors()
     }
 
     #[inline]
     pub fn get_primary_monitor(&self) -> MonitorId {
-        let id = MonitorId(CGDisplay::main().id);
-        id
+        get_primary_monitor()
     }
 
     pub fn make_monitor_from_display(id: CGDirectDisplayID) -> MonitorId {
@@ -36,6 +47,18 @@ impl EventsLoop {
     }
 }
 
+impl Window2 {
+    #[inline]
+    pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
+        get_available_monitors()
+    }
+
+    #[inline]
+    pub fn get_primary_monitor(&self) -> MonitorId {
+        get_primary_monitor()
+    }
+}
+
 impl fmt::Debug for MonitorId {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         #[derive(Debug)]

src/platform/windows/monitor.rs

@@ -5,9 +5,10 @@ use winapi::um::winuser;
 use std::{mem, ptr};
 use std::collections::VecDeque;
 
-use {PhysicalPosition, PhysicalSize};
 use super::{EventsLoop, util};
+use dpi::{PhysicalPosition, PhysicalSize};
 use platform::platform::dpi::{dpi_to_scale_factor, get_monitor_dpi};
+use platform::platform::window::Window;
 
 /// Win32 implementation of the main `MonitorId` object.
 #[derive(Debug, Clone)]
@@ -48,19 +49,31 @@ unsafe extern "system" fn monitor_enum_proc(
     TRUE // continue enumeration
 }
 
+fn get_available_monitors() -> VecDeque<MonitorId> {
+    let mut monitors: VecDeque<MonitorId> = VecDeque::new();
+    unsafe {
+        winuser::EnumDisplayMonitors(
+            ptr::null_mut(),
+            ptr::null_mut(),
+            Some(monitor_enum_proc),
+            &mut monitors as *mut _ as LPARAM,
+        );
+    }
+    monitors
+}
+
+fn get_primary_monitor() -> MonitorId {
+    const ORIGIN: POINT = POINT { x: 0, y: 0 };
+    let hmonitor = unsafe {
+        winuser::MonitorFromPoint(ORIGIN, winuser::MONITOR_DEFAULTTOPRIMARY)
+    };
+    MonitorId::from_hmonitor(hmonitor)
+}
+
 impl EventsLoop {
     // TODO: Investigate opportunities for caching
     pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
-        let mut monitors: VecDeque<MonitorId> = VecDeque::new();
-        unsafe {
-            winuser::EnumDisplayMonitors(
-                ptr::null_mut(),
-                ptr::null_mut(),
-                Some(monitor_enum_proc),
-                &mut monitors as *mut _ as LPARAM,
-            );
-        }
-        monitors
+        get_available_monitors()
     }
 
     pub fn get_current_monitor(hwnd: HWND) -> MonitorId {
@@ -71,11 +84,17 @@ impl EventsLoop {
     }
 
     pub fn get_primary_monitor(&self) -> MonitorId {
-        const ORIGIN: POINT = POINT { x: 0, y: 0 };
-        let hmonitor = unsafe {
-            winuser::MonitorFromPoint(ORIGIN, winuser::MONITOR_DEFAULTTOPRIMARY)
-        };
-        MonitorId::from_hmonitor(hmonitor)
+        get_primary_monitor()
+    }
+}
+
+impl Window {
+    pub fn get_available_monitors(&self) -> VecDeque<MonitorId> {
+        get_available_monitors()
+    }
+
+    pub fn get_primary_monitor(&self) -> MonitorId {
+        get_primary_monitor()
     }
 }