diff --git a/komorebi-recorder/src/analysis/sheet.rs b/komorebi-recorder/src/analysis/sheet.rs index 51c94b9a..b1fa77da 100644 --- a/komorebi-recorder/src/analysis/sheet.rs +++ b/komorebi-recorder/src/analysis/sheet.rs @@ -36,7 +36,7 @@ //! With [`SheetOptions::windows`] (the `--windows` flag), each frame also has the rect of every //! window drawn on it, from the session's window track (see [`super::window_track`]): a 2 pixel //! border in a colour taken from the window's id and a label of the owner and id, front windows -//! drawn last. Windows that are minimized or not visible are not drawn; a cloaked window (Windows +//! drawn last. Windows that are minimized or not visible, and komorebi's borders (`border`), are not drawn; a cloaked window (Windows //! only: hidden but still "visible") has a thin dim border, so that a window komorebi has hidden //! can be told from one that is shown. The windows are those of the moment of the picture //! shown, which is how [`SheetFrame::windows`] names them. [`rect_in_cell`] is the conversion from @@ -394,7 +394,8 @@ impl Canvas { ) -> Vec { let mut drawn = Vec::new(); for window in windows.iter().rev() { - if !window.visible || window.minimized { + // a border is a thin frame right around its window: drawn, it would hide it + if !window.visible || window.minimized || window.border { continue; } let Some([left, top, w, h]) = rect_in_cell(window.rect, frame, width, height) else { diff --git a/komorebi-recorder/src/platform/linux/apps.rs b/komorebi-recorder/src/platform/linux/apps.rs index 90bf0ae4..c9f12621 100644 --- a/komorebi-recorder/src/platform/linux/apps.rs +++ b/komorebi-recorder/src/platform/linux/apps.rs @@ -41,6 +41,8 @@ fn sample(window: &Window, visible: bool) -> Option { visible, minimized: false, cloaked: None, + border: false, + border_of: None, }) } diff --git a/komorebi-recorder/src/platform/macos/apps.rs b/komorebi-recorder/src/platform/macos/apps.rs index 2e1fb8dd..23d97938 100644 --- a/komorebi-recorder/src/platform/macos/apps.rs +++ b/komorebi-recorder/src/platform/macos/apps.rs @@ -187,6 +187,8 @@ pub fn window_list() -> Vec { visible: onscreen.unwrap_or(false), minimized: false, cloaked: None, + border: false, + border_of: None, }); } diff --git a/komorebi-recorder/src/platform/win/window.rs b/komorebi-recorder/src/platform/win/window.rs index a494f0ab..3bd9b200 100644 --- a/komorebi-recorder/src/platform/win/window.rs +++ b/komorebi-recorder/src/platform/win/window.rs @@ -31,6 +31,7 @@ use windows::Win32::Graphics::Dwm::DwmGetWindowAttribute; use windows::Win32::System::Threading::GetCurrentProcessId; use windows::Win32::UI::WindowsAndMessaging::EnumWindows; use windows::Win32::UI::WindowsAndMessaging::GWL_EXSTYLE; +use windows::Win32::UI::WindowsAndMessaging::GetClassNameW; use windows::Win32::UI::WindowsAndMessaging::GetWindowLongW; use windows::Win32::UI::WindowsAndMessaging::GetWindowRect; use windows::Win32::UI::WindowsAndMessaging::GetWindowTextW; @@ -181,7 +182,8 @@ fn program_of(pid: u32) -> String { /// `EnumWindows` pass, then a few cheap reads of each window. /// /// Left out: windows that are not visible (`IsWindowVisible`), tool windows (`WS_EX_TOOLWINDOW`: -/// tooltips, toasts, floating palettes), windows with an empty frame, and this process's own +/// tooltips, toasts, floating palettes) except komorebi's borders (class `komoborder-`, listed +/// with `border` true, see [`WindowSample::border`]), windows with an empty frame, and this process's own /// windows (the recorder and the viewer are not in the video either). The rect is the visible /// frame, as [`inspect`] reads it. A cloaked window (another virtual desktop, or hidden by /// komorebi) is listed with `cloaked` true. The program name is looked up once for each process @@ -202,8 +204,18 @@ pub fn list() -> Vec { if !IsWindowVisible(window).as_bool() { continue; } + // komorebi's borders are tool windows too, and are kept: they are what the track is + // asked about when a border has fallen behind its window + let mut border = None; if GetWindowLongW(window, GWL_EXSTYLE) as u32 & WS_EX_TOOLWINDOW.0 != 0 { - continue; + let mut class = [0_u16; 128]; + let length = GetClassNameW(window, &mut class).max(0) as usize; + border = crate::sources::windowtrack::border_class(&String::from_utf16_lossy( + &class[..length.min(class.len())], + )); + if border.is_none() { + continue; + } } let mut pid = 0_u32; GetWindowThreadProcessId(window, Some(&raw mut pid)); @@ -246,6 +258,8 @@ pub fn list() -> Vec { visible: true, minimized: IsIconic(window).as_bool(), cloaked: Some(cloaked != 0), + border: border.is_some(), + border_of: border.flatten(), }); } } diff --git a/komorebi-recorder/src/session.rs b/komorebi-recorder/src/session.rs index 7c78fd67..e4c7885e 100644 --- a/komorebi-recorder/src/session.rs +++ b/komorebi-recorder/src/session.rs @@ -546,7 +546,7 @@ pub fn readme(dir: &Path, manifest: &Manifest) -> String { "| `state-start.json`, `state-end.json` | `State` when recording started / stopped |\n", ); if manifest.window_track.is_some() { - out.push_str("| `windows.jsonl` | The window track: every top-level window's rect and state, front to back, written when something changed and in full once a second: `{mach_ns, key?, windows: [{id, owner, title?, rect: [l,t,r,b], visible, minimized, cloaked?}]}`. `sheet --windows` draws it on frames | + out.push_str("| `windows.jsonl` | The window track: every top-level window's rect and state, front to back, written when something changed and in full once a second: `{mach_ns, key?, windows: [{id, owner, title?, rect: [l,t,r,b], visible, minimized, cloaked?, border?, border_of?}]}`; `border` marks komorebi's own border windows (Windows). `sheet --windows` draws it on frames | "); } out.push_str(os_trace_rows(&host)); diff --git a/komorebi-recorder/src/sources/windowtrack.rs b/komorebi-recorder/src/sources/windowtrack.rs index c39cc129..8a5812d1 100644 --- a/komorebi-recorder/src/sources/windowtrack.rs +++ b/komorebi-recorder/src/sources/windowtrack.rs @@ -30,6 +30,20 @@ //! macOS. Both are the units of a display's `frame` in `session.json`, which is how the `sheet //! --windows` overlay places them on a frame. `cloaked` is `null` or absent on macOS. //! +//! # Borders +//! +//! komorebi for Windows draws each border as a top-level window of its own (class and title +//! `komoborder-`, a topmost tool window). Those are kept in the track, marked `"border":true`, +//! so a reader can ask whether a border was N px off its window at time T. When the border is +//! named for a window (a floating window's border is `komoborder-`), `"border_of"` is that +//! handle. A tiled or monocle container's border is named for the *container* (a UUID, in the +//! border's `title`), which komorebi's `State` maps to the container's focused window: that join +//! is exact but is the analysis's to make; when the container id is not enough (or the state is +//! missing), pairing a border with a window by rect and z-order is a heuristic and is not done +//! here. Neither field is ever guessed. macOS komorebi has no such windows this crate knows of +//! (any border window there is not layer 0, which the Mac listing leaves out), and komorebi for KDE +//! draws no border windows at all: KWin's rounded-corners effect paints them. +//! //! # Threads and cost //! //! A [`WindowTracker`] owns one thread (`window-track`) that owns the file, as the event recorder's @@ -53,6 +67,8 @@ //! visible: true, //! minimized: false, //! cloaked: Some(false), +//! border: false, +//! border_of: None, //! }; //! //! let mut filter = ChangeFilter::default(); @@ -115,6 +131,20 @@ pub struct WindowSample { /// still "visible"). `None` where the host has no such thing (a Mac). #[serde(default, skip_serializing_if = "Option::is_none")] pub cloaked: Option, + /// Whether this is one of komorebi's own border windows (on Windows, a top-level window of + /// class `komoborder-`), which komorebi draws around a window as a window of its own. A + /// reader asks "is the border N px off its window at time T" by comparing the rect of a + /// border with the rect of the window it belongs to. Absent when false. + #[serde(default, skip_serializing_if = "std::ops::Not::not")] + pub border: bool, + /// For a border, the id of the window it was drawn for, when the border says so by itself: the + /// border of a floating window is named for that window's handle (`komoborder-`), so this + /// is exact. The border of a tiled or monocle container is named for the container (a UUID), + /// which is *not* a window: it is in `title`, and the pairing with a window goes through the + /// container ids of `State` (its focused window). Absent otherwise; it is never guessed from + /// rects. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub border_of: Option, } impl WindowSample { @@ -127,6 +157,8 @@ impl WindowSample { && self.visible == other.visible && self.minimized == other.minimized && self.cloaked == other.cloaked + && self.border == other.border + && self.border_of == other.border_of } } @@ -142,6 +174,26 @@ pub struct TrackRow { pub windows: Vec, } +/// What a window class says about komorebi's borders: `None` if it is not a border's class, else +/// `Some(window)` where `window` is the handle the border is named for, if it is named for one. +/// +/// komorebi for Windows names a border's class and title `komoborder-`, where `` is the +/// container's id (a UUID) for a tiled or monocle container and the window's handle in decimal for +/// a floating window. +/// +/// ```rust +/// use komorebi_recorder::sources::windowtrack::border_class; +/// +/// assert_eq!(border_class("komoborder-5d1c-uuid"), Some(None)); +/// assert_eq!(border_class("komoborder-131072"), Some(Some(131072))); +/// assert_eq!(border_class("Chrome_WidgetWin_1"), None); +/// ``` +#[must_use] +pub fn border_class(class: &str) -> Option> { + let id = class.strip_prefix("komoborder")?; + Some(id.strip_prefix('-').and_then(|id| id.parse().ok())) +} + /// Decides which samples become rows: the first, any that differ from the previous sample, and one /// per [`KEYFRAME_INTERVAL_NS`] otherwise. See the module docs for an example. #[derive(Debug, Default)] @@ -361,6 +413,8 @@ mod tests { visible: true, minimized: false, cloaked: None, + border: false, + border_of: None, } } @@ -415,6 +469,25 @@ mod tests { assert!(changed(&mut filter, 6, vec![window(2, 0)]).is_none()); } + #[test] + fn borders_are_told_by_their_class_and_the_old_format_still_reads() { + assert_eq!(border_class("komoborder-9f"), Some(None)); + assert_eq!(border_class("komoborder-42"), Some(Some(42))); + assert_eq!(border_class("komoborder"), Some(None)); + assert_eq!(border_class("notkomoborder-1"), None); + let old = r#"{"mach_ns":1,"windows":[{"id":1,"owner":"a","rect":[0,0,1,1],"visible":true,"minimized":false}]}"#; + let row: TrackRow = serde_json::from_str(old).unwrap(); + assert!(!row.windows[0].border && row.windows[0].border_of.is_none()); + let mut border = window(2, 0); + border.border = true; + border.border_of = Some(1); + let text = serde_json::to_string(&border).unwrap(); + assert!( + text.contains("\"border\":true") && text.contains("\"border_of\":1"), + "{text}" + ); + } + #[test] fn rows_round_trip_and_leave_out_what_is_empty() { let row = TrackRow { diff --git a/komorebi-recorder/src/testkit.rs b/komorebi-recorder/src/testkit.rs index f1775138..ecc3aa1c 100644 --- a/komorebi-recorder/src/testkit.rs +++ b/komorebi-recorder/src/testkit.rs @@ -125,6 +125,8 @@ impl SessionBuilder { visible: true, minimized: false, cloaked: Some(false), + border: false, + border_of: None, }, ) .collect(),