feat(wm): migrate monitor reconciliator

I have no idea if this works at this point, I just tried to get
everything compiling and adhering to the macOS threading model for
access to NSScreen.
This commit is contained in:
LGUG2Z committed 2025-09-25 17:20:01 -07:00
1 parent 7217f311f2
commit a6ced512d7
10 files changed
+797 -83

No files matched your search

@@ -18,19 +18,45 @@ unsafe extern "C-unwind" fn callback(
tracing::debug!("display: {display_id} resized");
monitor_reconciliator::send_notification(MonitorNotification::Resize(display_id));
}
if flags.contains(CGDisplayChangeSummaryFlags::AddFlag) {
tracing::debug!("display: {display_id} added");
monitor_reconciliator::send_notification(MonitorNotification::DisplayConnectionChange(
display_id,
));
}
if flags.contains(CGDisplayChangeSummaryFlags::RemoveFlag) {
tracing::debug!("display: {display_id} removed");
monitor_reconciliator::send_notification(MonitorNotification::DisplayConnectionChange(
display_id,
));
}
if flags.contains(CGDisplayChangeSummaryFlags::EnabledFlag) {
tracing::debug!("display: {display_id} enabled");
monitor_reconciliator::send_notification(MonitorNotification::DisplayConnectionChange(
display_id,
));
}
if flags.contains(CGDisplayChangeSummaryFlags::DisabledFlag) {
tracing::debug!("display: {display_id} disabled");
monitor_reconciliator::send_notification(MonitorNotification::DisplayConnectionChange(
display_id,
));
}
if flags.contains(CGDisplayChangeSummaryFlags::MovedFlag) {
tracing::debug!("display: {display_id} moved");
monitor_reconciliator::send_notification(MonitorNotification::DisplayConnectionChange(
display_id,
));
}
// if flags.contains(CGDisplayChangeSummaryFlags::BeginConfigurationFlag) {
// tracing::debug!("display: {display_id} configured");
// }
//
// if flags.contains(CGDisplayChangeSummaryFlags::AddFlag) {
// tracing::debug!("display: {display_id} added");
// }
//
// if flags.contains(CGDisplayChangeSummaryFlags::RemoveFlag) {
// tracing::debug!("display: {display_id} removed");
// }
//
// if flags.contains(CGDisplayChangeSummaryFlags::MirrorFlag) {
// tracing::debug!("display: {display_id} mirrored");
// }
@@ -39,18 +65,6 @@ unsafe extern "C-unwind" fn callback(
// tracing::debug!("display: {display_id} unmirrored");
// }
//
// if flags.contains(CGDisplayChangeSummaryFlags::EnabledFlag) {
// tracing::debug!("display: {display_id} enabled");
// }
//
// if flags.contains(CGDisplayChangeSummaryFlags::DisabledFlag) {
// tracing::debug!("display: {display_id} disabled");
// }
//
// if flags.contains(CGDisplayChangeSummaryFlags::DisabledFlag) {
// tracing::debug!("display: {display_id} disabled");
// }
//
// tracing::trace!("display: {display_id}, flags: {flags:?}");
}
+5
View File
@@ -10,6 +10,7 @@ use crate::core::config_generation::MatchingRule;
use crate::core::config_generation::MatchingStrategy;
use crate::core::config_generation::WorkspaceMatchingRule;
use crate::core_graphics::error::CoreGraphicsError;
use crate::monitor::Monitor;
use crate::monitor_reconciliator::MonitorNotification;
use crate::state::State;
use crate::window::AspectRatio;
@@ -100,6 +101,10 @@ lazy_static! {
static ref WINDOW_RESTORE_POSITIONS: Arc<Mutex<HashMap<u32, CGRect>>> =
Arc::new(Mutex::new(HashMap::new()));
pub static ref UPDATE_MONITOR_WORK_AREAS: Arc<AtomicBool> = Arc::new(AtomicBool::new(false));
pub static ref UPDATE_LATEST_MONITOR_INFORMATION: Arc<AtomicBool> =
Arc::new(AtomicBool::new(false));
pub static ref LATEST_MONITOR_INFORMATION: Arc<RwLock<Option<Vec<Monitor>>>> =
Arc::new(RwLock::new(None));
static ref WORKSPACE_MATCHING_RULES: Arc<Mutex<Vec<WorkspaceMatchingRule>>> =
Arc::new(Mutex::new(Vec::new()));
static ref REGEX_IDENTIFIERS: Arc<Mutex<HashMap<String, Regex>>> =
+171 -3
View File
@@ -1,3 +1,4 @@
use crate::DISPLAY_INDEX_PREFERENCES;
use crate::LibraryError;
use crate::accessibility::AccessibilityApi;
use crate::accessibility::attribute_constants::kAXFocusedApplicationAttribute;
@@ -39,6 +40,172 @@ pub struct MacosApi;
impl MacosApi {
#[tracing::instrument(skip_all)]
pub fn load_monitor_information(wm: &mut WindowManager) -> Result<(), LibraryError> {
let monitors = &mut wm.monitors;
let monitor_usr_idx_map = &mut wm.monitor_usr_idx_map;
let monitor_info = IoReg::query_monitors()?;
let mut monitor_info_map = HashMap::new();
for m in monitor_info {
monitor_info_map.insert(m.serial_number, m);
}
let mut all_devices = vec![];
let screens = NSScreen::screens(MainThreadMarker::new().unwrap());
for display_id in CoreGraphicsApi::connected_display_ids()? {
let display_bounds = CoreGraphicsApi::display_bounds(display_id);
let serial_number = CoreGraphicsApi::display_serial_number(display_id);
if let Some(info) = monitor_info_map.get(&serial_number) {
for screen in &screens {
let menu_bar_height = screen.frame().size.height
- screen.visibleFrame().size.height
- screen.visibleFrame().origin.y;
if screen.frame() == display_bounds {
let size = Rect::from(display_bounds);
let mut work_area_size = Rect::from(display_bounds);
work_area_size.top += menu_bar_height as i32;
work_area_size.bottom = screen.visibleFrame().size.height as i32;
let monitor = Monitor::new(
display_id,
size,
work_area_size,
&info.product_name,
&info.alphanumeric_serial_number,
);
all_devices.push(monitor);
}
}
}
}
'read: for device in all_devices {
for monitor in monitors.elements() {
if device.serial_number_id.eq(&monitor.serial_number_id) {
continue 'read;
}
}
let m = device.clone();
let mut index_preference = None;
let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
for (index, id) in &*display_index_preferences {
if m.serial_number_id.eq(id) {
index_preference = Option::from(index);
}
}
if let Some(preference) = index_preference {
while *preference >= monitors.elements().len() {
monitors.elements_mut().push_back(Monitor::placeholder());
}
let current_serial_id = monitors
.elements_mut()
.get(*preference)
.map_or("", |m| &m.serial_number_id);
if current_serial_id == "PLACEHOLDER" {
let _ = monitors.elements_mut().remove(*preference);
monitors.elements_mut().insert(*preference, m);
} else {
monitors.elements_mut().insert(*preference, m);
}
} else {
monitors.elements_mut().push_back(m);
}
}
monitors
.elements_mut()
.retain(|m| m.serial_number_id.ne("PLACEHOLDER"));
// Rebuild monitor index map
*monitor_usr_idx_map = HashMap::new();
let mut added_monitor_idxs = Vec::new();
for (index, id) in &*DISPLAY_INDEX_PREFERENCES.read() {
if let Some(m_idx) = monitors
.elements()
.iter()
.position(|m| m.serial_number_id.eq(id))
{
monitor_usr_idx_map.insert(*index, m_idx);
added_monitor_idxs.push(m_idx);
}
}
let max_usr_idx = monitors
.elements()
.len()
.max(monitor_usr_idx_map.keys().max().map_or(0, |v| *v));
let mut available_usr_idxs = (0..max_usr_idx)
.filter(|i| !monitor_usr_idx_map.contains_key(i))
.collect::<Vec<_>>();
let not_added_monitor_idxs = (0..monitors.elements().len())
.filter(|i| !added_monitor_idxs.contains(i))
.collect::<Vec<_>>();
for i in not_added_monitor_idxs {
if let Some(next_usr_idx) = available_usr_idxs.first() {
monitor_usr_idx_map.insert(*next_usr_idx, i);
available_usr_idxs.remove(0);
} else if let Some(idx) = monitor_usr_idx_map.keys().max() {
monitor_usr_idx_map.insert(*idx, i);
}
}
Ok(())
}
pub fn update_monitor_work_areas(wm: Arc<Mutex<WindowManager>>) -> eyre::Result<()> {
let screens = NSScreen::screens(MainThreadMarker::new().unwrap());
for display_id in CoreGraphicsApi::connected_display_ids()? {
let display_bounds = CoreGraphicsApi::display_bounds(display_id);
let mut wm = wm.lock();
for screen in &screens {
let menu_bar_height = screen.frame().size.height
- screen.visibleFrame().size.height
- screen.visibleFrame().origin.y;
if screen.frame() == display_bounds {
let size = Rect::from(display_bounds);
let mut work_area_size = Rect::from(display_bounds);
work_area_size.top += menu_bar_height as i32;
work_area_size.bottom = screen.visibleFrame().size.height as i32;
for monitor in wm.monitors_mut() {
if monitor.id == display_id {
monitor.size = size;
monitor.work_area_size = work_area_size;
}
tracing::info!(
"updated monitor size and work area for monitor {display_id}"
)
}
}
}
let focus_follows_mouse = wm.mouse_follows_focus;
wm.update_focused_workspace(focus_follows_mouse, true)?;
}
Ok(())
}
pub fn latest_monitor_information() -> Result<Vec<Monitor>, LibraryError> {
let mut monitors = vec![];
let monitor_info = IoReg::query_monitors()?;
let mut monitor_info_map = HashMap::new();
for m in monitor_info {
@@ -70,16 +237,17 @@ impl MacosApi {
&info.product_name,
&info.alphanumeric_serial_number,
);
wm.monitors.elements_mut().push_back(monitor);
monitors.push(monitor);
}
}
}
}
Ok(())
Ok(monitors)
}
pub fn update_monitor_work_areas(wm: Arc<Mutex<WindowManager>>) -> eyre::Result<()> {
pub fn reconile_monitors(wm: Arc<Mutex<WindowManager>>) -> eyre::Result<()> {
let screens = NSScreen::screens(MainThreadMarker::new().unwrap());
for display_id in CoreGraphicsApi::connected_display_ids()? {
+8
View File
@@ -6,6 +6,8 @@ use color_eyre::eyre;
use color_eyre::eyre::OptionExt;
use komorebi::DATA_DIR;
use komorebi::HOME_DIR;
use komorebi::LATEST_MONITOR_INFORMATION;
use komorebi::UPDATE_LATEST_MONITOR_INFORMATION;
use komorebi::UPDATE_MONITOR_WORK_AREAS;
use komorebi::core::pathext::replace_env_in_path;
use komorebi::display_reconfiguration_listener::DisplayReconfigurationListener;
@@ -277,6 +279,12 @@ fn main() -> eyre::Result<()> {
UPDATE_MONITOR_WORK_AREAS.store(false, Ordering::Relaxed);
}
if UPDATE_LATEST_MONITOR_INFORMATION.load(Ordering::Relaxed) {
let mut latest_monitor_information = LATEST_MONITOR_INFORMATION.write();
// this can only be called on the main thread
*latest_monitor_information = Some(MacosApi::latest_monitor_information()?);
}
// this gets our observer notification callbacks firing
autoreleasepool(|_| unsafe { CFRunLoop::run_in_mode(kCFRunLoopDefaultMode, 2.0, false) });
}
+46
View File
@@ -70,6 +70,33 @@ pub struct Monitor {
pub floating_layer_behaviour: Option<FloatingLayerBehaviour>,
}
pub fn new(
id: u32,
size: Rect,
work_area_size: Rect,
device: String,
serial_number_id: String,
) -> Monitor {
let mut workspaces = Ring::default();
workspaces.elements_mut().push_back(Workspace::default());
Monitor {
id,
device,
serial_number_id,
size,
work_area_size,
work_area_offset: None,
window_based_work_area_offset: None,
window_based_work_area_offset_limit: 1,
workspaces,
last_focused_workspace: None,
container_padding: None,
workspace_padding: None,
floating_layer_behaviour: None,
}
}
impl Monitor {
#[allow(clippy::field_reassign_with_default)]
pub fn new(
@@ -104,6 +131,25 @@ impl Monitor {
}
}
pub fn placeholder() -> Self {
Self {
// temp
id: 2051316,
device: "".to_string(),
serial_number_id: "PLACEHOLDER".to_string(),
size: Default::default(),
work_area_size: Default::default(),
work_area_offset: None,
window_based_work_area_offset: None,
window_based_work_area_offset_limit: 0,
workspaces: Default::default(),
last_focused_workspace: None,
container_padding: None,
workspace_padding: None,
floating_layer_behaviour: None,
}
}
#[tracing::instrument(skip_all)]
pub fn update_focused_workspace(&mut self, offset: Option<Rect>) -> eyre::Result<()> {
let offset = if self.work_area_offset.is_some() {
+471 -2
View File
@@ -1,6 +1,12 @@
use crate::DISPLAY_INDEX_PREFERENCES;
use crate::LATEST_MONITOR_INFORMATION;
use crate::Notification;
use crate::NotificationEvent;
use crate::UPDATE_MONITOR_WORK_AREAS;
use crate::WORKSPACE_MATCHING_RULES;
use crate::core::config_generation::WorkspaceMatchingRule;
use crate::macos_api::MacosApi;
use crate::monitor::Monitor;
use crate::notify_subscribers;
use crate::state::State;
use crate::window_manager::WindowManager;
@@ -10,6 +16,7 @@ use objc2_core_graphics::CGDirectDisplayID;
use parking_lot::Mutex;
use serde::Deserialize;
use serde::Serialize;
use std::collections::HashMap;
use std::sync::Arc;
use std::sync::OnceLock;
use std::sync::atomic::Ordering;
@@ -19,10 +26,14 @@ use strum::Display;
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
pub enum MonitorNotification {
Resize(CGDirectDisplayID),
DisplayConnectionChange(CGDirectDisplayID),
}
static CHANNEL: OnceLock<(Sender<MonitorNotification>, Receiver<MonitorNotification>)> =
OnceLock::new();
static MONITOR_CACHE: OnceLock<Mutex<HashMap<String, Monitor>>> = OnceLock::new();
pub fn channel() -> &'static (Sender<MonitorNotification>, Receiver<MonitorNotification>) {
CHANNEL.get_or_init(|| crossbeam_channel::bounded(20))
}
@@ -35,6 +46,22 @@ fn event_rx() -> Receiver<MonitorNotification> {
channel().1.clone()
}
pub fn insert_in_monitor_cache(serial_number_id: &str, monitor: Monitor) {
let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
let mut dip_ids = display_index_preferences.values();
let preferred_id = if dip_ids.any(|id| id == serial_number_id) {
monitor.serial_number_id.clone()
} else {
serial_number_id.to_string()
};
let mut monitor_cache = MONITOR_CACHE
.get_or_init(|| Mutex::new(HashMap::new()))
.lock();
monitor_cache.insert(preferred_id, monitor);
}
pub fn send_notification(notification: MonitorNotification) {
if event_tx().try_send(notification).is_err() {
tracing::warn!("channel is full; dropping notification")
@@ -67,8 +94,8 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
let receiver = event_rx();
for notification in receiver {
let wm = wm.lock();
'receiver: for notification in receiver {
let mut wm = wm.lock();
let initial_state = State::from(wm.as_ref());
@@ -77,6 +104,448 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
tracing::debug!("handling resize notification");
UPDATE_MONITOR_WORK_AREAS.store(true, Ordering::Relaxed);
}
MonitorNotification::DisplayConnectionChange(_) => {
tracing::debug!("handling display connection change notification");
let mut monitor_cache = MONITOR_CACHE
.get_or_init(|| Mutex::new(HashMap::new()))
.lock();
let initial_monitor_count = wm.monitors().len();
// Get the currently attached display devices
// TODO: I think because of the way the threading model works on macOS we'll
// need to run this on the main thread to get access to info from NSScreen
// let attached_devices = attached_display_devices(display_provider)?;
let mut latest_monitor_information = LATEST_MONITOR_INFORMATION.write();
*latest_monitor_information = None;
UPDATE_MONITOR_WORK_AREAS.store(true, Ordering::Relaxed);
let mut attached_devices = vec![];
while attached_devices.is_empty() {
if let Some(latest) = &*LATEST_MONITOR_INFORMATION.read() {
attached_devices = latest.clone();
}
std::thread::sleep(std::time::Duration::from_millis(100));
}
UPDATE_MONITOR_WORK_AREAS.store(false, Ordering::Relaxed);
// Make sure that in our state any attached displays have the latest Win32 data
for monitor in wm.monitors_mut() {
for attached in &attached_devices {
// let serial_number_ids_match = if let (Some(attached_snid), Some(m_snid)) =
// (&attached.serial_number_id, &monitor.serial_number_id)
// {
// attached_snid.eq(m_snid)
// } else {
// false
// };
let serial_number_ids_match =
attached.serial_number_id == monitor.serial_number_id;
if serial_number_ids_match {
monitor.id = attached.id;
monitor.device = attached.device.clone();
// monitor.device_id = attached.device_id.clone();
monitor.serial_number_id = attached.serial_number_id.clone();
// monitor.name = attached.name.clone();
monitor.size = attached.size;
monitor.work_area_size = attached.work_area_size;
}
}
}
if initial_monitor_count == attached_devices.len() {
tracing::debug!("monitor counts match, reconciliation not required");
drop(wm);
continue 'receiver;
}
if attached_devices.is_empty() {
tracing::debug!(
"no devices found, skipping reconciliation to avoid breaking state"
);
drop(wm);
continue 'receiver;
}
if initial_monitor_count > attached_devices.len() {
tracing::info!(
"monitor count mismatch ({initial_monitor_count} vs {}), removing disconnected monitors",
attached_devices.len()
);
// Windows to remove from `known_hwnds`
let mut windows_to_remove = Vec::new();
// Collect the ids in our state which aren't in the current attached display ids
// These are monitors that have been removed
let mut newly_removed_displays = vec![];
for (m_idx, m) in wm.monitors().iter().enumerate() {
if !attached_devices
.iter()
.any(|attached| attached.serial_number_id.eq(&m.serial_number_id))
{
let id = m.serial_number_id.clone();
newly_removed_displays.push(id.clone());
let focused_workspace_idx = m.focused_workspace_idx();
for (idx, workspace) in m.workspaces().iter().enumerate() {
let is_focused_workspace = idx == focused_workspace_idx;
let focused_container_idx = workspace.focused_container_idx();
for (c_idx, container) in workspace.containers().iter().enumerate()
{
let focused_window_idx = container.focused_window_idx();
for (w_idx, window) in container.windows().iter().enumerate() {
windows_to_remove.push(window.id);
if is_focused_workspace
&& c_idx == focused_container_idx
&& w_idx == focused_window_idx
{
// TODO: Do we need this on macOS?
// Minimize the focused window since Windows might try
// to move it to another monitor if it was focused.
// if window.is_focused() {
// window.minimize()?;
// }
}
}
}
// TODO: might not support maximization on macOS
// if let Some(maximized) = &workspace.maximized_window {
// windows_to_remove.push(maximized.id);
// // Minimize the focused window since Windows might try
// // to move it to another monitor if it was focused.
// if maximized.is_focused() {
// maximized.minimize();
// }
// }
if let Some(container) = &workspace.monocle_container {
for window in container.windows() {
windows_to_remove.push(window.id);
}
if let Some(_window) = container.focused_window() {
// TODO: Do we need this on macOS?
// Minimize the focused window since Windows might try
// to move it to another monitor if it was focused.
// if window.is_focused() {
// window.minimize();
// }
}
}
for window in workspace.floating_windows() {
windows_to_remove.push(window.id);
// TODO: Do we need this on macOS?
// Minimize the focused window since Windows might try
// to move it to another monitor if it was focused.
// if window.is_focused() {
// window.minimize();
// }
}
}
// Remove any workspace_rules for this specific monitor
let mut workspace_rules = WORKSPACE_MATCHING_RULES.lock();
let mut rules_to_remove = Vec::new();
for (i, rule) in workspace_rules.iter().enumerate().rev() {
if rule.monitor_index == m_idx {
rules_to_remove.push(i);
}
}
for i in rules_to_remove {
workspace_rules.remove(i);
}
// Let's add their state to the cache for later, make sure to use what
// the user set as preference as the id.
let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
let mut dip_ids = display_index_preferences.values();
let preferred_id = if dip_ids.any(|id| m.serial_number_id.eq(id)) {
m.serial_number_id.clone()
} else {
id.to_string()
};
monitor_cache.insert(preferred_id, m.clone());
}
}
// Update known_hwnds
wm.known_window_ids
.retain(|i, _| !windows_to_remove.contains(i));
if !newly_removed_displays.is_empty() {
// After we have cached them, remove them from our state
wm.monitors_mut().retain(|m| {
!newly_removed_displays
.iter()
.any(|id| m.serial_number_id.eq(id))
});
}
let post_removal_monitor_count = wm.monitors().len();
let focused_monitor_idx = wm.focused_monitor_idx();
if focused_monitor_idx >= post_removal_monitor_count {
wm.focus_monitor(0)?;
}
let offset = wm.work_area_offset;
for monitor in wm.monitors_mut() {
// If we have lost a monitor, update everything to filter out any jank
if initial_monitor_count != post_removal_monitor_count {
monitor.update_focused_workspace(offset)?;
}
}
}
let post_removal_monitor_count = wm.monitors().len();
// // This is the list of device ids after we have removed detached displays. We can
// // keep this with just the device_ids without the serial numbers since this is used
// // only to check which one is the newly added monitor below if there is a new
// // monitor. Everything done after with said new monitor will again consider both
// // serial number and device ids.
// let post_removal_device_ids = wm
// .monitors()
// .iter()
// .map(|m| &m.device_id)
// .cloned()
// .collect::<Vec<_>>();
let post_removal_serial_ids = [];
// // Check for and add any new monitors that may have been plugged in
// // Monitor and display index preferences get applied in this function
MacosApi::load_monitor_information(&mut wm)?;
let post_addition_monitor_count = wm.monitors().len();
if post_addition_monitor_count > post_removal_monitor_count {
tracing::info!(
"monitor count mismatch ({post_removal_monitor_count} vs {post_addition_monitor_count}), adding connected monitors",
);
let known_window_ids = wm.known_window_ids.clone();
let offset = wm.work_area_offset;
let mouse_follows_focus = wm.mouse_follows_focus;
let focused_monitor_idx = wm.focused_monitor_idx();
let focused_workspace_idx = wm.focused_workspace_idx()?;
// Look in the updated state for new monitors
for (i, m) in wm.monitors_mut().iter_mut().enumerate() {
// let device_id = &m.device_id;
let serial_id = m.serial_number_id.clone();
// We identify a new monitor when we encounter a new device id
if !post_removal_serial_ids.contains(&serial_id) {
let mut cache_hit = false;
let mut cached_id = String::new();
// Check if that device id exists in the cache for this session
if let Some((id, cached)) = monitor_cache.get_key_value(&serial_id) {
cache_hit = true;
cached_id = id.clone();
tracing::info!(
"found monitor and workspace configuration for {id} in the monitor cache, applying"
);
// If it does, update the cached monitor info with the new one and
// load the cached monitor removing any window that has since been
// closed or moved to another workspace
*m = Monitor {
// Data that should be the one just read from `win32-display-data`
id: m.id,
// name: m.name.clone(),
device: m.device.clone(),
// device_id: m.device_id.clone(),
serial_number_id: m.serial_number_id.clone(),
size: m.size,
work_area_size: m.work_area_size,
// The rest should come from the cached monitor
work_area_offset: cached.work_area_offset,
window_based_work_area_offset: cached
.window_based_work_area_offset,
window_based_work_area_offset_limit: cached
.window_based_work_area_offset_limit,
workspaces: cached.workspaces.clone(),
last_focused_workspace: cached.last_focused_workspace,
// workspace_names: cached.workspace_names.clone(),
container_padding: cached.container_padding,
workspace_padding: cached.workspace_padding,
// wallpaper: cached.wallpaper.clone(),
floating_layer_behaviour: cached.floating_layer_behaviour,
};
let focused_workspace_idx = m.focused_workspace_idx();
for (j, workspace) in m.workspaces_mut().iter_mut().enumerate() {
// If this is the focused workspace we need to show (restore) all
// windows that were visible since they were probably minimized by
// Windows.
let is_focused_workspace = j == focused_workspace_idx;
let focused_container_idx = workspace.focused_container_idx();
let mut empty_containers = Vec::new();
for (idx, container) in
workspace.containers_mut().iter_mut().enumerate()
{
container.windows_mut().retain(|window| {
window.exe().is_some()
&& !known_window_ids.contains_key(&window.id)
});
if container.windows().is_empty() {
empty_containers.push(idx);
}
if is_focused_workspace {
if let Some(_window) = container.focused_window() {
// TODO: do we need to do this on macOS?
// tracing::debug!(
// "restoring window: {}",
// window.id
// );
// WindowsApi::restore_window(window.hwnd);
} else {
// If the focused window was moved or removed by
// the user after the disconnect then focus the
// first window and show that one
container.focus_window(0);
//
// if let Some(window) = container.focused_window() {
// WindowsApi::restore_window(window.hwnd);
// }
}
}
}
// Remove empty containers
for empty_idx in empty_containers {
if empty_idx == focused_container_idx {
workspace.remove_container(empty_idx);
} else {
workspace.remove_container_by_idx(empty_idx);
}
}
// if let Some(window) = &workspace.maximized_window {
// if window.exe().is_none()
// || known_window_ids.contains_key(&window.id)
// {
// workspace.maximized_window = None;
// } else if is_focused_workspace {
// WindowsApi::restore_window(window.hwnd);
// }
// }
if let Some(container) = &mut workspace.monocle_container {
container.windows_mut().retain(|window| {
window.exe().is_some()
&& !known_window_ids.contains_key(&window.id)
});
if container.windows().is_empty() {
workspace.monocle_container = None;
} else if is_focused_workspace {
if let Some(_window) = container.focused_window() {
// WindowsApi::restore_window(window.hwnd);
} else {
// If the focused window was moved or removed by
// the user after the disconnect then focus the
// first window and show that one
container.focus_window(0);
if let Some(_window) = container.focused_window() {
// WindowsApi::restore_window(window.hwnd);
}
}
}
}
workspace.floating_windows_mut().retain(|window| {
window.exe().is_some()
&& !known_window_ids.contains_key(&window.id)
});
if is_focused_workspace {
for _window in workspace.floating_windows() {
// WindowsApi::restore_window(window.hwnd);
}
}
// Apply workspace rules
let mut workspace_matching_rules =
WORKSPACE_MATCHING_RULES.lock();
if let Some(rules) = workspace
.workspace_config
.as_ref()
.and_then(|c| c.workspace_rules.as_ref())
{
for r in rules {
workspace_matching_rules.push(WorkspaceMatchingRule {
monitor_index: i,
workspace_index: j,
matching_rule: r.clone(),
initial_only: false,
});
}
}
if let Some(rules) = workspace
.workspace_config
.as_ref()
.and_then(|c| c.initial_workspace_rules.as_ref())
{
for r in rules {
workspace_matching_rules.push(WorkspaceMatchingRule {
monitor_index: i,
workspace_index: j,
matching_rule: r.clone(),
initial_only: true,
});
}
}
}
// Restore windows from new monitor and update the focused
// workspace
m.load_focused_workspace(mouse_follows_focus)?;
m.update_focused_workspace(offset)?;
}
// Entries in the cache should only be used once; remove the entry there was a cache hit
if cache_hit && !cached_id.is_empty() {
monitor_cache.remove(&cached_id);
}
}
}
// Refocus the previously focused monitor since the code above might
// steal the focus away.
wm.focus_monitor(focused_monitor_idx)?;
wm.focus_workspace(focused_workspace_idx)?;
}
let final_count = wm.monitors().len();
if post_removal_monitor_count != final_count {
wm.retile_all(true)?;
// Second retile to fix DPI/resolution related jank
// wm.retile_all(true)?;
// Border updates to fix DPI/resolution related jank
// border_manager::send_notification(None);
}
}
}
notify_subscribers(
+6 -3
View File
@@ -1,4 +1,5 @@
use crate::DATA_DIR;
use crate::DISPLAY_INDEX_PREFERENCES;
use crate::HOME_DIR;
use crate::IGNORE_IDENTIFIERS;
use crate::MANAGE_IDENTIFIERS;
@@ -15,6 +16,7 @@ use crate::window_manager::WindowManager;
use crate::workspace::Workspace;
use serde::Deserialize;
use serde::Serialize;
use std::collections::HashMap;
use std::collections::VecDeque;
use std::path::PathBuf;
@@ -44,7 +46,7 @@ pub struct GlobalState {
// pub tray_and_multi_window_identifiers: Vec<MatchingRule>,
// pub name_change_on_launch_identifiers: Vec<MatchingRule>,
// pub monitor_index_preferences: HashMap<usize, Rect>,
// pub display_index_preferences: HashMap<usize, String>,
pub display_index_preferences: HashMap<usize, String>,
// pub ignored_duplicate_monitor_serial_ids: Vec<String>,
pub workspace_rules: Vec<WorkspaceMatchingRule>,
// pub window_hiding_behaviour: HidingBehaviour,
@@ -58,6 +60,7 @@ impl Default for GlobalState {
Self {
ignore_identifiers: IGNORE_IDENTIFIERS.lock().clone(),
manage_identifiers: MANAGE_IDENTIFIERS.lock().clone(),
display_index_preferences: DISPLAY_INDEX_PREFERENCES.read().clone(),
workspace_rules: WORKSPACE_MATCHING_RULES.lock().clone(),
configuration_dir: HOME_DIR.clone(),
data_dir: DATA_DIR.clone(),
@@ -70,7 +73,7 @@ impl Default for GlobalState {
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct State {
pub monitors: Ring<Monitor>,
// pub monitor_usr_idx_map: HashMap<usize, usize>,
pub monitor_usr_idx_map: HashMap<usize, usize>,
pub is_paused: bool,
pub resize_delta: i32,
pub new_window_behaviour: WindowContainerBehaviour,
@@ -154,7 +157,7 @@ impl From<&WindowManager> for State {
Self {
monitors: stripped_monitors,
// monitor_usr_idx_map: wm.monitor_usr_idx_map.clone(),
monitor_usr_idx_map: wm.monitor_usr_idx_map.clone(),
is_paused: wm.is_paused,
work_area_offset: wm.work_area_offset,
resize_delta: wm.resize_delta,
+47 -55
View File
@@ -28,7 +28,9 @@ use crate::core::default_layout::LayoutOptions;
use crate::core::layout::Layout;
use crate::core::pathext::ResolvedPathBuf;
use crate::core::rect::Rect;
use crate::monitor;
use crate::monitor::Monitor;
use crate::monitor_reconciliator;
use crate::ring::Ring;
use crate::window::AspectRatio;
use crate::window::PredefinedAspectRatio;
@@ -1120,7 +1122,7 @@ impl StaticConfig {
let mut wm = WindowManager {
monitors: Ring::default(),
// monitor_usr_idx_map: HashMap::new(),
monitor_usr_idx_map: HashMap::new(),
applications: Default::default(),
incoming_events: incoming,
command_listener: listener,
@@ -1275,13 +1277,10 @@ impl StaticConfig {
// Check if this monitor config is the preferred config for this monitor and store
// a copy of the monitor itself on the monitor cache if it is.
// if idx == preferred_config_idx {
// let id = monitor
// .serial_number_id
// .as_ref()
// .map_or(&monitor.device_id, |sn| sn);
// monitor_reconciliator::insert_in_monitor_cache(id, monitor.clone());
// }
if idx == preferred_config_idx {
let id = &monitor.serial_number_id;
monitor_reconciliator::insert_in_monitor_cache(id, monitor.clone());
}
let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
for (j, ws) in monitor_config.workspaces.iter().enumerate() {
@@ -1313,53 +1312,46 @@ impl StaticConfig {
// Check for configs that should be tied to a specific display that isn't loaded right now
// and cache a monitor with those configs with the specific `serial_number_id` so that when
// those devices are connected later we can use the correct config from the cache.
// if configs_with_preference.len() > configs_used.len() {
// for i in configs_with_preference
// .iter()
// .filter(|i| !configs_used.contains(i))
// {
// let id = {
// let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
// display_index_preferences.get(i).cloned()
// };
// if let (Some(id), Some(monitor_config)) =
// (id, value.monitors.as_ref().and_then(|ms| ms.get(*i)))
// {
// // The name, device, device_id and serial_number_id can be empty here since
// // once the monitor with this preferred index actually connects the
// // `load_monitor_information` function will update these fields.
// let mut m = monitor::new(
// 0,
// Rect::default(),
// Rect::default(),
// "".into(),
// "".into(),
// "".into(),
// None,
// );
//
// m.ensure_workspace_count(monitor_config.workspaces.len());
// m.work_area_offset = monitor_config.work_area_offset;
// m.window_based_work_area_offset = monitor_config.window_based_work_area_offset;
// m.window_based_work_area_offset_limit = monitor_config
// .window_based_work_area_offset_limit
// .unwrap_or(1);
// m.container_padding = monitor_config.container_padding;
// m.workspace_padding = monitor_config.workspace_padding;
// m.floating_layer_behaviour = monitor_config.floating_layer_behaviour;
//
// m.update_workspaces_globals(offset);
//
// for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
// if let Some(workspace_config) = monitor_config.workspaces.get(j) {
// ws.load_static_config(workspace_config)?;
// }
// }
//
// monitor_reconciliator::insert_in_monitor_cache(&id, m);
// }
// }
// }
if configs_with_preference.len() > configs_used.len() {
for i in configs_with_preference
.iter()
.filter(|i| !configs_used.contains(i))
{
let id = {
let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
display_index_preferences.get(i).cloned()
};
if let (Some(id), Some(monitor_config)) =
(id, value.monitors.as_ref().and_then(|ms| ms.get(*i)))
{
// The name, device, device_id and serial_number_id can be empty here since
// once the monitor with this preferred index actually connects the
// `load_monitor_information` function will update these fields.
let mut m =
monitor::new(0, Rect::default(), Rect::default(), "".into(), "".into());
m.ensure_workspace_count(monitor_config.workspaces.len());
m.work_area_offset = monitor_config.work_area_offset;
m.window_based_work_area_offset = monitor_config.window_based_work_area_offset;
m.window_based_work_area_offset_limit = monitor_config
.window_based_work_area_offset_limit
.unwrap_or(1);
m.container_padding = monitor_config.container_padding;
m.workspace_padding = monitor_config.workspace_padding;
m.floating_layer_behaviour = monitor_config.floating_layer_behaviour;
m.update_workspaces_globals(offset);
for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
if let Some(workspace_config) = monitor_config.workspaces.get(j) {
ws.load_static_config(workspace_config)?;
}
}
monitor_reconciliator::insert_in_monitor_cache(&id, m);
}
}
}
wm.enforce_workspace_rules()?;
+2
View File
@@ -59,6 +59,7 @@ use std::sync::Arc;
#[derive(Debug)]
pub struct WindowManager {
pub monitors: Ring<Monitor>,
pub monitor_usr_idx_map: HashMap<usize, usize>,
pub applications: HashMap<i32, Application>,
pub run_loop: CoreFoundationRunLoop,
pub command_listener: UnixListener,
@@ -138,6 +139,7 @@ impl WindowManager {
Ok(Self {
monitors: Ring::default(),
monitor_usr_idx_map: HashMap::new(),
applications: Default::default(),
run_loop: CoreFoundationRunLoop(run_loop.clone()),
command_listener: listener,
+7
View File
@@ -741,6 +741,13 @@ impl Workspace {
container
}
pub fn remove_container(&mut self, idx: usize) -> Option<Container> {
let container = self.remove_container_by_idx(idx);
self.focus_previous_container();
container
}
pub fn promote_container(&mut self) -> eyre::Result<()> {
let resize = self.resize_dimensions.remove(0);
let container = self