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/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") };