The protocol seems to allow this, because it explicitly mentions either
session lock surface or compositor blanking the output in this sentence:
> The locked event must not be sent until a new "locked" frame
(either from a session lock surface or the compositor blanking the output)
has been presented on all outputs and no security sensitive normal/unlocked
content is possibly visible.
Since `locked_screen_delay` is capped to 5 seconds,
after the 5 seconds this timer is registered for, we assume that
all outputs are covered either by lockedead or by an actual lock frame.
Thus sending locked is ok.
After scaling m_captureBox from logical to pixel coordinates, the box may
have non-integer dimensions (e.g. logical 401x301 at scale 1.25 -> pixel
501.25x376.25). m_bufferSize is then computed as captureBox.size() and
sent to the client as int32 width/height (truncating the fraction), but
m_bufferSize itself stays as a fractional Vector2D.
When the client allocates the integer-sized buffer and submits it,
CScreenshareFrame::share() rejects it with ERROR_BUFFER_SIZE because
Vector2D::operator== is exact double comparison: (501, 376) != (501.25,
376.25). The frame is sent failed, and the client retries forever.
The SHARE_WINDOW path already rounds its bufferSize; the SHARE_REGION
path didn't. Round the captureBox immediately after scaling so all
downstream consumers (m_bufferSize, render translates) see clean integer
pixel coordinates.
Reproducer at scale 1.25 on a 1920x1080 monitor:
wf-recorder -g '500,200 401x301' -f /tmp/x.mp4
# "Failed to copy frame, retrying..." until exit
wf-recorder -g '500,200 400x300' -f /tmp/x.mp4
# works (400*1.25=500, 300*1.25=375, both integer)
* fix(screenshare): adjust session cleanup and event emission order
Revised the handling of `stoppedListener` initialization in
`getManagedSession` to ensure correct scoping and lifecycle management.
Updated the `stop` method in `CScreenshareSession` to adjust the order
of `screenshareEvents` and `stopped.emit()` to prevent potential
use-after-free scenarios.
* fix(screenshare): ensure managedSession removal uses consistent target reference
This change updates the lambda in the stopped listener to use
a pre-fetched target pointer for comparison when erasing sessions.
* fix(screenshare): use early-return and smart ptr comparison in session cleanup
* seat: fix dropped wl_keyboard.enter after stale keyboardFocusResource
CSeatManager::setKeyboardFocus's leave loop was gated on
m_state.keyboardFocusResource (a WP<CWLSeatResource>). That weak
pointer can expire between focus cycles — most reliably via the
explicit `.reset()` in KeybindManager::passKeys for XWayland
targets, but also in practice after certain wl_seat rebind
sequences from toolkit-level churn. When the WP is expired, the
leave loop's `if (m_state.keyboardFocusResource)` is false, the
loop is skipped, and no wl_keyboard.leave is sent for the previous
focus. The old client's CWLKeyboardResource keeps m_currentSurface
pointing at its old surface.
On the next focus back to that surface,
CWLKeyboardResource::sendEnter's per-keyboard dedup fires
(`if (m_currentSurface == surface) return;`) and the enter is
silently dropped. Net result: client believes it's still focused,
compositor routes keys via m_state.keyboardFocusResource which now
points somewhere else, typed keystrokes silently go to a different
window. A mouse drag resyncs because
InputManager::processMouseDownNormal → refocus() →
mouseMoveUnified(refocus=true) → rawWindowFocus(…, foundSurface)
takes a different path that forces the leave/enter pair through.
Reported and reproducible in discussion #14141.
Fix: iterate PROTO::seat->m_keyboards (the global owning list) in
the leave loop and let sendLeave()'s own m_currentSurface gate
decide whether each keyboard needs the event. sendLeave() and the
sendMods(0,…) that precedes it are already gated on m_currentSurface
being set, so iterating every keyboard is a no-op for any keyboard
that wasn't on the previous focus — identical semantics to the old
code in the healthy case, correct in the broken case.
Enter loop unchanged: it's driven by surf->client() which is a
cached wl_client* on the surface resource, stable across cycles.
Verified against the repro in #14141 (two wev instances cycled via
`hyprctl dispatch focuswindow`). Before the fix both windows get
stuck in a "I am focused" state after ~3 cycles. After the fix
leave/enter pair each dispatch cleanly.
* seat: apply same leave-loop fix to setPointerFocus
Identical failure mode to the keyboard case in the previous commit:
setPointerFocus's leave loop is gated on m_state.pointerFocusResource,
which can expire between focus changes. When it does, the leave is
skipped, the previously-focused client's wl_pointer m_currentSurface
stays stuck, and the next sendEnter's per-pointer dedup silently
drops the enter.
sendPointerButton also early-returns on `if (!m_state.pointerFocusResource)`,
so the visible symptom is "a click on a taskbar / dock / menu button
doesn't register after a layer-shell Overlay surface appeared or
disappeared, until the user moves the mouse." Motion re-syncs focus
via InputManager::mouseMoveUnified → setPointerFocus with a fresh
resource, at which point clicks work again.
Fix is the same: iterate PROTO::seat->m_pointers and let sendLeave's
m_currentSurface gate decide. No-op for pointers not on the old
surface.
* input: implement follow_mouse_shrink
Add a new config option `input:follow_mouse_shrink` (INT, 0-300, default 0)
that shrinks inactive window hitboxes by the specified number of pixels for
focus detection purposes. This creates a dead zone in gaps between windows
where moving the cursor will not trigger a focus change.
The shrink only applies to inactive (non-focused) windows and only during
mouse-move focus checks (follow_mouse = 1). Click and scroll interactions
are unaffected — clicking on a window in the shrunk area still works
normally once the window is focused.
Closes#9973
* tests: add integration test for follow_mouse_shrink
* Add test for movewindowgroup
* groups: Fix `movewindoworgroup` moving into group
Fixes `CKeybindManager::moveWindowIntoGroup` to
remove a window from a group before attempting
to add it to another group. Addresses #13843.
But the animation of moving a window from a group
into another group now looks weird: as if the
whole target group is being moved.
* xwayland: prefer monitor-aware hover coords
Introduce monitor-aware XWayland coordinate helpers and keep the X11 hover path anchored to the main surface box while preserving detailed debug logging, reducing dependence on nearest-monitor guesses in layout-sensitive input paths.
* xwayland: use window monitor for reported coords
Report X11 window positions through the window's known monitor instead of the generic nearest-monitor heuristic so boundary-aligned outputs keep stable XWayland coordinates.
* xwayland: use window monitor for real position restore
Convert XWayland geometry back into compositor space using the window's current monitor when available so vertically offset layouts do not round-trip through the wrong output.
* xwayland: use window monitor for unmanaged geometry
Restore override-redirect X11 geometry through the window's known monitor so helper windows and popups avoid nearest-monitor misclassification on offset layouts.
* xwayland: remove monitor conversion debug logging
Drop the temporary XWayland hover and coordinate conversion diagnostics now that the monitor-selection bug is confirmed and the window-monitor based conversions fix the issue.
* xwayland: drop unrelated focused-motion change
Remove the exploratory X11-specific pointer focus scaling from InputManager so the monitor mapping fix stays narrowly scoped to the XWayland coordinate conversion changes that actually resolve the bug.
* clang-format XWaylandManager
* misc: silence warnings about ignoring return value on reads
silence warnings on ignored return values on read() and print an error
if it occurs.
* misc: silence warnings about ignoring return value on writes
silence warnings on ignored return values on write() and print an error
where we can, or pass them the maybe_unused attribute.
* misc: silence warnings about ignoring return value on pipe
silence warnings on ignored return value on pipe(), print an error and
exit on failure.
