drag_icon_surface_listener is registered with only .enter and .leave.
wl_compositor is bound at version 6 whenever the compositor offers it,
so the drag icon surface receives wl_surface.preferred_buffer_scale
(opcode 2) and libwayland aborts on the NULL listener slot:
listener function for opcode 2 of wl_surface is NULL
Add no-op handlers for both version 6 events, matching surfaceListener.
The drag icon's scale is already fixed at drag start from the source
window, via viewport destination or wl_surface_set_buffer_scale, so
ignoring the compositor's later preference preserves existing behavior.
Fixes#10284
When there is no focused or recently-focused window to key off of (the
typical first-window-at-startup case), glfwGetWaylandCurrentMonitorFractionalScale
fell back to the registry-first output (monitors[0]). Registry/connector
order is semi-arbitrary and uncorrelated with where a compositor actually
places a new window, so on a multi-monitor setup with mixed fractional
scales the first window could be born at the wrong size.
Prefer the output at the logical origin (0, 0) instead: the compositor's
top-left/primary output is a better guess for initial placement than
registry order. Fall back to monitors[0] when no output reports (0, 0).
Since xdg_output geometry (including position) arrives asynchronously and
x/y read zero until it does, wait for every monitor's logical geometry
before trusting the reported positions, so an as-yet-unpositioned output
cannot spuriously match (0, 0).
Discussed in #10268.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VjwP6hQjA6GMuiM7Mf9VAx
niri for some reason known only to itself does not send any pointer
leave/data device enter/data source events when it accepts a grab. The
only event it seems to send is surface enter on the drag icon surface,
and that too it sends that event much later.
Handle this bonkers behavior by retrying the sync multiple times to
detect if niri has accepted the drag or not.
Fixes#10271
The first OS window on Wayland is created at scale 1 because the
compositor only sends the fractional scale after the surface exists.
The initial size in cells is therefore computed with scale-1 cell
metrics and the window is mapped a few cells too small. The existing
post-map recompute calls glfwSetWindowSize(), but on Wayland that loses
to the compositor's authoritative configure, which re-asserts the size
it recorded at map time. So a window that receives focus (the normal
interactive case) stays too small; a background window that never gets
an activated configure happens to keep the resized value, which is why
it can look fixed.
Correct the size while the window is still unmapped instead. GLFW gains
a hook (glfwWaylandSetInitialWindowSizeCallback) that it invokes when
the fractional scale is applied during creation -- mutter, kwin and niri
send the scale before the first configure -- letting the embedder
recompute the cell-based logical size for the real scale before the
window is mapped. The compositor then records the correct size and its
activation configure agrees, so there is nothing to race.
The existing post-map recompute is kept as a fallback for compositors
that only send the scale after the first configure (sway, Hyprland).
Also add glfwCocoaSetWindowLevel to the glfw.py wrapper generator list:
it was present in the committed glfw-wrapper but missing from the
generator, so regenerating the wrapper (required to add the hook above)
would otherwise drop it and break the macOS build.
This escape code is largely undefined. There is no specification for how
it affects alternate screen mode, overriden colors, kitty keyboard
state, paused rendering, etc. Do what I feel is sensible in these cases.
Fixes#10263
Problem
-------
In update_dest_rect() when both num_cols and num_rows are 0
(auto-computed, ``a=T``), the first block computes num_cols with
cell_x_offset, but, then the second block mismatches num_cols, causing
it to compute width_px from num_cols and adds cell_x_offset a second
time. The returned value is large enough that it often causes scrolling,
depending on size and location of the screen.
A sample visual program:
```python
import zlib, base64, time
from functools import partial
echo = partial(print, end='', flush=True)
echo('\033[H\033[J')
base = bytes([0, 128, 0, 255]) * 640 * 576
k = zlib.compress(keyframe, 3)
echo(f'\033[8;60H\033_Ga=T,i=1,q=1,f=32,s=640,v=576,o=z,N=1;{base64.b64encode(k).decode()}\033\\')
time.sleep(1)
delta = bytes([200, 0, 0, 255]) * 32 * 512
d = zlib.compress(delta, 3)
echo(f'\033[9;67H\033_Ga=T,i=100,q=1,f=32,s=32,v=512,o=z,N=1,X=9,Y=25;{base64.b64encode(d).decode()}\033\\')
time.sleep(1)
print()
```
Solution
--------
Add 'auto_cols' and 'auto_rows' to remember the original read-only
values before exercising their auto-calculated size. 'auto_rows' isn't
technically necessary given the logic branching but it describes in code
better.
Before and After video
----------------------
A video will be attached shortly, here.
Add a benchmark stream containing 262,144 distinct base-plus-combining-mark cells per repetition so TextCache collection cost remains visible instead of collapsing into cache hits.
Co-Authored-By: Claude <noreply@anthropic.com>
Move the periodic collection check to PREPARE_FOR_DRAW_TEXT so ordinary and fixed-width text share one safe integration point, while tab handling no longer initiates collection.
Reset the additions counter only after the live-cell remap completes successfully.
Co-Authored-By: Claude <noreply@anthropic.com>
