2014-12-02 04:24:15 +11:00
|
|
|
use winapi;
|
2015-01-26 13:52:17 +11:00
|
|
|
use user32;
|
2014-07-31 18:52:05 +10:00
|
|
|
|
2015-02-22 00:40:23 +11:00
|
|
|
use std::collections::VecDeque;
|
2015-01-02 18:09:16 +11:00
|
|
|
|
2014-08-02 07:02:26 +10:00
|
|
|
/// Win32 implementation of the main `MonitorID` object.
|
2014-07-31 18:52:05 +10:00
|
|
|
pub struct MonitorID {
|
2014-08-02 07:02:26 +10:00
|
|
|
/// The system name of the monitor.
|
2015-01-04 09:11:59 +11:00
|
|
|
name: [winapi::WCHAR; 32],
|
2014-08-02 07:02:26 +10:00
|
|
|
|
|
|
|
/// Name to give to the user.
|
2014-07-31 18:52:05 +10:00
|
|
|
readable_name: String,
|
2014-08-02 07:02:26 +10:00
|
|
|
|
|
|
|
/// See the `StateFlags` element here:
|
|
|
|
/// http://msdn.microsoft.com/en-us/library/dd183569(v=vs.85).aspx
|
2014-12-02 04:24:15 +11:00
|
|
|
flags: winapi::DWORD,
|
2014-08-02 07:02:26 +10:00
|
|
|
|
|
|
|
/// The position of the monitor in pixels on the desktop.
|
|
|
|
///
|
|
|
|
/// A window that is positionned at these coordinates will overlap the monitor.
|
2015-01-13 23:21:36 +11:00
|
|
|
position: (u32, u32),
|
2014-08-02 19:17:49 +10:00
|
|
|
|
|
|
|
/// The current resolution in pixels on the monitor.
|
2015-01-13 23:21:36 +11:00
|
|
|
dimensions: (u32, u32),
|
2014-07-31 18:52:05 +10:00
|
|
|
}
|
|
|
|
|
2014-08-02 07:02:26 +10:00
|
|
|
/// Win32 implementation of the main `get_available_monitors` function.
|
2015-02-22 00:40:23 +11:00
|
|
|
pub fn get_available_monitors() -> VecDeque<MonitorID> {
|
2014-07-31 18:52:05 +10:00
|
|
|
use std::{iter, mem, ptr};
|
|
|
|
|
2014-08-02 07:02:26 +10:00
|
|
|
// return value
|
2015-02-22 00:40:23 +11:00
|
|
|
let mut result = VecDeque::new();
|
2014-07-31 18:52:05 +10:00
|
|
|
|
2014-08-02 07:02:26 +10:00
|
|
|
// enumerating the devices is done by querying device 0, then device 1, then device 2, etc.
|
|
|
|
// until the query function returns null
|
2015-01-13 23:21:36 +11:00
|
|
|
for id in iter::count(0u32, 1) {
|
2014-08-02 07:02:26 +10:00
|
|
|
// getting the DISPLAY_DEVICEW object of the current device
|
|
|
|
let output = {
|
2014-12-02 04:24:15 +11:00
|
|
|
let mut output: winapi::DISPLAY_DEVICEW = unsafe { mem::zeroed() };
|
|
|
|
output.cb = mem::size_of::<winapi::DISPLAY_DEVICEW>() as winapi::DWORD;
|
2014-07-31 18:52:05 +10:00
|
|
|
|
2015-01-26 13:52:17 +11:00
|
|
|
if unsafe { user32::EnumDisplayDevicesW(ptr::null(),
|
2014-12-02 04:24:15 +11:00
|
|
|
id as winapi::DWORD, &mut output, 0) } == 0
|
2014-08-02 07:02:26 +10:00
|
|
|
{
|
|
|
|
// the device doesn't exist, which means we have finished enumerating
|
|
|
|
break;
|
|
|
|
}
|
2014-07-31 18:52:05 +10:00
|
|
|
|
2014-12-02 04:24:15 +11:00
|
|
|
if (output.StateFlags & winapi::DISPLAY_DEVICE_ACTIVE) == 0 ||
|
|
|
|
(output.StateFlags & winapi::DISPLAY_DEVICE_MIRRORING_DRIVER) != 0
|
2014-08-02 07:02:26 +10:00
|
|
|
{
|
|
|
|
// the device is not active
|
|
|
|
// the Win32 api usually returns a lot of inactive devices
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
output
|
|
|
|
};
|
2014-07-31 18:52:05 +10:00
|
|
|
|
2014-08-02 07:02:26 +10:00
|
|
|
// computing the human-friendly name
|
2014-07-31 18:52:05 +10:00
|
|
|
let readable_name = String::from_utf16_lossy(output.DeviceString.as_slice());
|
2015-01-06 00:30:42 +11:00
|
|
|
let readable_name = readable_name.as_slice().trim_right_matches(0 as char).to_string();
|
2014-07-31 18:52:05 +10:00
|
|
|
|
2014-08-02 07:02:26 +10:00
|
|
|
// getting the position
|
2014-08-02 19:17:49 +10:00
|
|
|
let (position, dimensions) = unsafe {
|
2014-12-02 04:24:15 +11:00
|
|
|
let mut dev: winapi::DEVMODEW = mem::zeroed();
|
|
|
|
dev.dmSize = mem::size_of::<winapi::DEVMODEW>() as winapi::WORD;
|
2014-07-31 18:52:05 +10:00
|
|
|
|
2015-01-26 13:52:17 +11:00
|
|
|
if user32::EnumDisplaySettingsExW(output.DeviceName.as_ptr(), winapi::ENUM_CURRENT_SETTINGS,
|
2014-07-31 18:52:05 +10:00
|
|
|
&mut dev, 0) == 0
|
|
|
|
{
|
2014-08-02 07:02:26 +10:00
|
|
|
continue;
|
2014-07-31 18:52:05 +10:00
|
|
|
}
|
|
|
|
|
2014-12-02 04:24:15 +11:00
|
|
|
let point: &winapi::POINTL = mem::transmute(&dev.union1);
|
2015-01-13 23:21:36 +11:00
|
|
|
let position = (point.x as u32, point.y as u32);
|
2014-08-02 19:17:49 +10:00
|
|
|
|
2015-01-13 23:21:36 +11:00
|
|
|
let dimensions = (dev.dmPelsWidth as u32, dev.dmPelsHeight as u32);
|
2014-08-02 19:17:49 +10:00
|
|
|
|
|
|
|
(position, dimensions)
|
2014-07-31 18:52:05 +10:00
|
|
|
};
|
|
|
|
|
2014-08-02 07:02:26 +10:00
|
|
|
// adding to the resulting list
|
2015-01-02 18:09:16 +11:00
|
|
|
result.push_back(MonitorID {
|
2014-07-31 18:52:05 +10:00
|
|
|
name: output.DeviceName,
|
|
|
|
readable_name: readable_name,
|
|
|
|
flags: output.StateFlags,
|
|
|
|
position: position,
|
2014-08-02 19:17:49 +10:00
|
|
|
dimensions: dimensions,
|
2014-07-31 18:52:05 +10:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
result
|
|
|
|
}
|
|
|
|
|
2014-08-02 07:02:26 +10:00
|
|
|
/// Win32 implementation of the main `get_primary_monitor` function.
|
2014-07-31 18:52:05 +10:00
|
|
|
pub fn get_primary_monitor() -> MonitorID {
|
2014-08-02 07:02:26 +10:00
|
|
|
// we simply get all available monitors and return the one with the `PRIMARY_DEVICE` flag
|
|
|
|
// TODO: it is possible to query the win32 API for the primary monitor, this should be done
|
|
|
|
// instead
|
2014-09-23 16:01:18 +10:00
|
|
|
for monitor in get_available_monitors().into_iter() {
|
2014-12-02 04:24:15 +11:00
|
|
|
if (monitor.flags & winapi::DISPLAY_DEVICE_PRIMARY_DEVICE) != 0 {
|
2014-07-31 18:52:05 +10:00
|
|
|
return monitor
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-30 18:14:09 +11:00
|
|
|
panic!("Failed to find the primary monitor")
|
2014-07-31 18:52:05 +10:00
|
|
|
}
|
|
|
|
|
|
|
|
impl MonitorID {
|
2014-08-02 07:02:26 +10:00
|
|
|
/// See the docs if the crate root file.
|
2014-07-31 18:52:05 +10:00
|
|
|
pub fn get_name(&self) -> Option<String> {
|
|
|
|
Some(self.readable_name.clone())
|
|
|
|
}
|
|
|
|
|
2014-08-02 19:17:49 +10:00
|
|
|
/// See the docs if the crate root file.
|
2015-01-13 23:21:36 +11:00
|
|
|
pub fn get_dimensions(&self) -> (u32, u32) {
|
2014-08-02 19:17:49 +10:00
|
|
|
// TODO: retreive the dimensions every time this is called
|
|
|
|
self.dimensions
|
|
|
|
}
|
|
|
|
|
2014-08-02 07:02:26 +10:00
|
|
|
/// This is a Win32-only function for `MonitorID` that returns the system name of the device.
|
2014-12-02 04:24:15 +11:00
|
|
|
pub fn get_system_name(&self) -> &[winapi::WCHAR] {
|
2014-08-02 19:17:49 +10:00
|
|
|
// TODO: retreive the position every time this is called
|
2014-07-31 18:52:05 +10:00
|
|
|
self.name.as_slice()
|
|
|
|
}
|
|
|
|
|
2014-08-02 07:02:26 +10:00
|
|
|
/// This is a Win32-only function for `MonitorID` that returns the position of the
|
2015-01-02 18:09:16 +11:00
|
|
|
/// monitor on the desktop.
|
2014-08-02 07:02:26 +10:00
|
|
|
/// A window that is positionned at these coordinates will overlap the monitor.
|
2015-01-13 23:21:36 +11:00
|
|
|
pub fn get_position(&self) -> (u32, u32) {
|
2014-07-31 18:52:05 +10:00
|
|
|
self.position
|
|
|
|
}
|
|
|
|
}
|