Skip to content

Chore: Move the Compose fork to 1.11.1-ext.5, with wheel tests through the real window - #852

Merged
b-re-w merged 5 commits into
developfrom
feat/compose-ext5
Nov 16, 2026
Merged

b-re-w merged 5 commits into
developfrom
feat/compose-ext5

Conversation

@b-re-w

@b-re-w b-re-w commented Nov 16, 2026

Copy link
Copy Markdown
Member

What moved

The Compose, window and Windows pins in renderer/scripts/build-compose.sh (REVISION, WINDOW_REVISION, MINGW_REVISION) all move to 96ae925f7fb6a730d7af31c2c29c856f35778d25, the tip of the fork's extended and the commit the v1.11.1-ext.5 tag will go on. Its gradle.properties publishes every line as 1.11.1-ext.5, so COMPOSE_AS, MATERIAL3_AS and SKIKO_AWT_AS move with it, and so does every live coordinate: the four renderer module.yaml files, COMPOSE_VERSION in Transform3DLayers.kt and its staged Android copy, the troubleshooting guides (en, ko), the script and test comments and the test-compose-from-fork.yml comment. compose-fork.changes and compose-fork-mingw.changes are regenerated from 73ac849 with the command at the top of the file. No path is dropped. The CHANGELOG has a new Unreleased entry, and the ext.4 entry keeps its version.

What the pins hold

Glue

No glue change was needed. The renderer calls none of the fork scene's input functions. Its Linux and Windows windows go through renderer/desktop/src/WindowEvents.kt, which already scrolls at lastPointerPosition. The macOS renderer goes through the fork's ComposeWindowHost, and MacosNativeViewWindow passes every event through once. So no scroll is sent twice, and none goes to a different place. The desktop C symbols are unchanged (desktop-c-symbols.test.sh). A side note, not changed here: lastPointerPosition is one process-wide value, so with several windows, a wheel in one window before any move there scrolls at the last place in another window.

Wheel tests through the real window

Platform Test Sends Asserts Runs in
macOS (K/N) renderer/macos/test/WheelScrollWindowTest.kt: fr13_a_wheel_over_a_scroll_column_..., fr13_a_wheel_over_a_lazy_column_..., fr13_a_trackpad_moves_... a mouse move to the view under the point, then CGEventCreateScrollWheelEvent2 -3/+3 lines and -40/+40 pixels to that view the container under the pointer moves 3 lines of 10 pt (or 40 pt) toward its end and comes back. The other container does not move. A non-scrolling box covers the corner, and both containers start mid-content. here, and Kotlin/Native desktop renderer test (macos)
Linux (K/N, X11) renderer/linux/test/LinuxWheelScrollTest.kt XSendEvent MotionNotify over the container, then button 5 and button 4 press and release a notch down moves it toward its end by 3 x sqrt(height px), a notch up brings it back. The other container stays. Kotlin/Native desktop renderer test (linux, Xvfb)
Windows (K/N) fr13_windows_a_wheel_turned_forward_scrolls_toward_the_top in Fr53WindowsCheck.kt (the renderer's real-window harness, because a mingw test executable cannot link the MSVC window) SetCursorPos and a posted WM_MOUSEMOVE, then WM_MOUSEWHEEL +120 and -120 forward moves it toward the top by the wheel lines of a twentieth of its height, back returns it. The other container stays. check-windows-consumer.sh in Windows static renderer (consumer). The script now reads every fr<N>_windows_* name.

The Linux and Windows tests cannot compile or run on a Mac: there are no linuxX64 or mingwX64 fork artifacts here. They were written against the APIs they use and need CI to show them green.

Red then green on macOS

The test ran once with develop's 1.11.1-ext.4 pins, before they moved. All three failed:

Failed fr13_a_wheel_over_a_scroll_column_scrolls_it_the_way_it_turned
  a wheel turned toward the reader over node 3 moved it by 0.0 pixels; it should bring what is below into view, 30.0 pixels (3 lines of 10.0 points)
Failed fr13_a_wheel_over_a_lazy_column_scrolls_it_the_way_it_turned
  ... over node 5 moved it by 0.0 pixels ...
Failed fr13_a_trackpad_moves_a_scroll_container_as_far_as_the_fingers_moved
  a trackpad push up over node 3 moved it by 0.0 pixels; it should be 40.0

At the ext.5 pins, built locally, all three pass.

Local gate (ext.5 built into ~/.m2 from 96ae925f)

The artifacts were built with build-compose.sh --target desktop and --target macosArm64, publish-skiko-awt.sh and publish-window.sh, with DXC_COMPOSE_BUILD under .scratch/. The ext.4 files in ~/.m2 were not changed: every ext.4 .module and .pom is byte-identical before and after, and no file of an older version is newer than the publish.

Step Result
fetch-design-systems.sh, stand-in renderer ok (stand-in built: the published renderer has another schema)
cargo fmt --all -- --check ok
cargo clippy --workspace --all-targets -- -D warnings ok
cargo test --workspace ok
scripts/tests/*.test.sh (88) 88 ok, including compose-fork, fork-versions, fork-dependencies, desktop-c-symbols, x11-window-layout, x11-key-codes, fr53-windows-backend
require-fork-artifacts.sh desktop macos ok
./kotlin test -m desktop 1258 passed, 0 failed
./kotlin test -m macos 61 passed, 0 failed (new wheel tests and NativeViewWindowTest included)
forced ./kotlin build -m ios -p iosSimulatorArm64 ok, compiled
dx build --package sample-minimal --platform android (wiped app dir) ok

Before this merges

  1. The fork tag v1.11.1-ext.5 must exist on 96ae925f7fb6a730d7af31c2c29c856f35778d25, and the 1.11.1-ext.5 artifacts must be on Maven Central.
  2. Then one CI dispatch (ci.yml). Use suites=all, or at least test,test_graalvm_renderer,test_kn_desktop_renderer,windows_static_consumer,test_native_renderer,test_compose_from_fork,test_windows_c:
    • test_kn_desktop_renderer: the macOS and Linux Kotlin/Native renderers, including the new WheelScrollWindowTest and LinuxWheelScrollTest under Xvfb
    • windows_static_kit and windows_static_consumer: the mingw Compose build, the Windows static renderer, and check-windows-consumer.sh with fr13_windows_a_wheel_turned_forward_scrolls_toward_the_top
    • test_native_renderer: the Windows and static renderers on the new pins
    • test_graalvm_renderer: the GraalVM path, which should be unchanged
    • test_compose_from_fork, test_windows_c, test

Draft: do not merge before both points above.

The Compose, window and Windows pins all move to 96ae925f7fb6a730d7af31c2c29c856f35778d25,
the tip of the fork's extended branch and the commit its v1.11.1-ext.5 tag goes on. It
publishes every line as 1.11.1-ext.5, so COMPOSE_AS, MATERIAL3_AS and SKIKO_AWT_AS move with
it, and every live coordinate follows: the renderer module.yaml files, COMPOSE_VERSION in
Transform3DLayers.kt and its staged Android copy (stage-android-kotlin.sh), the
troubleshooting guides in English and Korean, the scripts, the test comments and the
workflow comment.

ext.5 is the first tag since the ext.2 build that changes Compose itself, in foundation
(fork #240). The Kotlin/Native Windows and Linux scroll configs answer the wheel with the
sign and the line desktop Compose uses on the same system; before, the wheel scrolled the
wrong way there, and on Windows three times too far. The macOS config works out a scroll
with no NSEvent from its travel, 10 dp a line, where it came to zero. The scene sends a
scroll where the pointer last was (ScenePointer) instead of the top left corner, and the
macOS window places the pointer before a scroll that came before any move. Together they
make the wheel and the trackpad scroll on the Kotlin/Native macOS window, where nothing
scrolled. The tag also holds what the window pin carried past ext.4 (fork #232, #235, #239,
#236, #234, #237) and the AT-SPI readback tool matching roles by number (fork #241).

No glue changes: the renderer calls none of the scene's input functions (its Linux and
Windows windows go through its own WindowEvents.kt, which already scrolls at the last
pointer place, and the macOS renderer goes through the fork's scene), and the C symbols the
desktops link are unchanged (desktop-c-symbols.test.sh).

compose-fork.changes and compose-fork-mingw.changes are regenerated from 73ac849 to the new
pin. No path is dropped; the new paths are the foundation scroll configs and their tests,
the fork's wheel and native view tests, two fork workflows and its AGENTS.md. The historical
CHANGELOG entry for ext.4 keeps its version and ext.5 gets its own.

The tag and the Maven Central artifacts do not exist yet; this was built and checked against
1.11.1-ext.5 published into ~/.m2 from the same commit.
…trackpad

WheelScrollWindowTest opens a Kotlin/Native macOS window the way the renderer does
(MacosWindow with ComposeRustContent over a scripted Host), with a box that does not scroll
at the top left corner and a ScrollColumn and a LazyColumn beside it, each started in the
middle of its content. It moves the pointer over one container and hands the view under it
AppKit scroll events made with CGEventCreateScrollWheelEvent2: -3 and +3 lines, and -40 and
+40 pixels. It reads where each container is from its ScrollChanged reports and asserts that
-3 lines moves the one under the pointer 3 lines of 10 points toward its end, +3 brings it
back, 40 trackpad points move it 40 points, and the other container does not move.

It would have caught the bug ext.5 fixes (fork #240): against the 1.11.1-ext.4 pins all three
tests fail with the container moved by 0.0 pixels, because every scroll reached the scene at
the window's corner and its distance came to zero. Covers FR-13.6 (scroll containers) for
pointer input on the macOS window.
LinuxWheelScrollTest opens a window through the Linux backend with the same page as the
macOS wheel test: a box at the corner, a ScrollColumn and a LazyColumn started in the middle
of their content. Another display client sends the window a MotionNotify over a container,
then a button 5 press and release (a notch toward the reader) and a button 4 one, with
XSendEvent. The container under the pointer must move toward its end by three lines of the
square root of its height in pixels and then come back, and the other one must stay.

Against 1.11.1-ext.4 the notch down would move the container toward the top, by 64 dp a
line, which is the wrong-way wheel fork #240 fixes. Runs under Xvfb in the Kotlin/Native
desktop renderer test (linux); it cannot run or compile on a Mac. Covers FR-13.6.
The Windows renderer carries its real-window checks itself (Fr53WindowsCheck.kt), because a
Kotlin/Native test executable for mingwX64 cannot link the MSVC-built window.
fr13_windows_a_wheel_turned_forward_scrolls_toward_the_top joins them: a window with a box at
the corner and a ScrollColumn and a LazyColumn started in their middle, the real pointer moved
over a container and a WM_MOUSEMOVE posted, then a WM_MOUSEWHEEL of +120 (forward, away from
the reader) and one of -120. The container must move toward the top by the system's wheel
lines of a twentieth of its height and come back; the other must stay.

Against 1.11.1-ext.4 the forward notch moves the container toward its end, three times as far,
which is what fork #240 fixes. check-windows-consumer.sh and fr53-windows-backend.test.sh read
every `fr<N>_windows_*` name from the Kotlin instead of only `fr53_windows_*`, so the new check
is required to print its ok line. It runs in the consumer job of the Windows static renderer
workflow (windows_static_consumer in ci.yml). Covers FR-13.6.
Both sides added checks to the Windows real-window harness: develop the two
text edit menu checks, this branch the wheel check. Both are kept, and the
consumer script and its script test now read every fr<N>_windows and
fr<N>_<M>_windows name.
@b-re-w
b-re-w marked this pull request as ready for review November 16, 2026 03:05
@b-re-w
b-re-w merged commit 166b3e3 into develop Nov 16, 2026
85 checks passed
@b-re-w
b-re-w deleted the feat/compose-ext5 branch November 16, 2026 04:41
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant