leyoda/redox-wayland-compositor
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
No description
19 commits 1 branch 0 tags 380 KiB
Find a file
Votre Nom a8898960f1 🎉 Phase 7.8 — resize interactif xdg_toplevel + durcissements 
Resize complet implémenté (compute selon edges + configure cycle)
+ durcissements sécu Move/Resize.

Frontend additions :
- Helper compute_resize_geom(edges, start_x/y/w/h, dx, dy) qui
  interprète le bitmask xdg_toplevel::ResizeEdge :
  Top(1)/Bottom(2)/Left(4)/Right(8). Coins = combinaisons.
  Clamp w/h à MIN_RESIZE_DIM=32.
- Handler xdg_toplevel.Resize complet : valide serial!=0,
  validation soft du serial vs last_button_serial (log warning,
  accept), refuse si drag déjà actif, check client_id (caller ==
  owner de la surface — sécu défense en profondeur). Capture
  start_geom (x,y,w,h) + start_cursor, stocke InteractiveDrag::
  Resize(edges).
- apply_interactive_drag(Resize) : compute new geom, modifie
  registry x/y, envoie xdg_toplevel.configure(w, h, [Resizing]) +
  xdg_surface.configure(serial). Met à jour
  XdgSurfaceData.last_serial = serial pour que l'ack du client
  soit accepté (sinon refusé par garde 7.5).
- Move handler : check client_id ajouté en mode défense en
  profondeur (un client ne peut pas drag une surface d'un autre).

Nouveau crate : redox-wl-test-client-resize (~285 lignes)
- Bind wl_seat
- 1 fenêtre 320x200 cyan + bordure noire
- À T+8s : toplevel.resize(seat, 1, BottomRight)
- Écoute xdg_toplevel.Configure : à chaque new size, ack +
  nouveau shm pool + nouveau buffer + attach + commit
- Vec<WlShmPool>/Vec<WlBuffer> pour ne pas drop les anciens
  pendant que le serveur peut encore les utiliser

Pièges trouvés :
- last_serial doit être mis à jour à chaque configure envoyé
  pendant le resize, sinon l'ack du client est refusé par le
  garde 7.5 (serial > last_sent → ignoring).
- Le client peut ignorer la taille initiale suggérée par le
  configure du compositor (legal selon spec). Le compositor
  compose à la taille du buffer attaché.
- À chaque resize, garder les anciens pool+buffer en mémoire
  pour ne pas crasher le serveur qui mmap dessus.

Validation runtime : 3 captures à 3 tailles distinctes (320x200
initial, ~520x300 agrandi, ~70x25 rétréci) confirment le pipeline
end-to-end. Logs symétriques côté client et compositor.

Bilan phase 7 (1-8) :
- 7.1 xdg-shell, 7.2 wl_seat, 7.3 cursor, 7.4 focus/raise,
  7.5 robustesse, 7.6 multi-clients, 7.7 move, 7.8 resize
- Compositor 7.x désormais utilisable pour un toolkit Wayland
  basique. Prochain jalon : port COSMIC (phase 13 plan-directeur,
  réordonnée avant GPU).

Doc complète : docs/phase7-8-resize.md

Leyoda 2026 – GPLv3
2026-05-13 19:47:53 +02:00
crates 🎉 Phase 7.8 — resize interactif xdg_toplevel + durcissements 2026-05-13 19:47:53 +02:00
docs 🎉 Phase 7.8 — resize interactif xdg_toplevel + durcissements 2026-05-13 19:47:53 +02:00
.gitignore 🎉 Phase 4 vraie validée visuellement : pixels custom plein écran 2026-05-09 10:46:20 +02:00
README.md Phase 4.4 : binaire prêt pour test sur image bootée 2026-05-08 20:04:16 +02:00
REDOX_COSMIC_XWAYLAND_RS_PLAN.md Initial commit: phases 1-3 du portage Wayland Rust pour Redox OS 2026-05-08 17:41:55 +02:00

README.md

redox-wayland-compositor

Portage de Wayland sur Redox OS, en Rust pur, visant à terme à remplacer Orbital comme serveur graphique de base.

État : phases 1+2+3 du plan directeur complétées le 2026-05-08.

Le pipeline shm Wayland complet est validé end-to-end sur Redox via redoxer (crate redox-wl-test-shm-pipeline) : socket Unix réel, wl_compositor + wl_shm globals, fd passing via SCM_RIGHTS, wl_shm_pool + wl_buffer, wl_surface.attach/damage/commit, lecture pixels côté serveur via le fd reçu — pixel-perfect.

Structure

.
├── REDOX_COSMIC_XWAYLAND_RS_PLAN.md   # plan directeur 14 phases / 5 ans
├── docs/
│   ├── existing-redox-gui.md          # phase 1 : audit Orbital + graphics-ipc + inputd + relibc
│   └── redox-wayland-primitives.md    # phase 2 : 5 primitives + POC pixels validés sur Redox
├── crates/
│   ├── redox-wl-test-unix-socket/        # primitive 1 : SOCK_STREAM Wayland-shaped
│   ├── redox-wl-test-fd-passing/         # primitive 2 : SCM_RIGHTS mono-process (artefact)
│   ├── redox-wl-test-fd-passing-fork/    # primitive 2b : SCM_RIGHTS via fork (vrai cas Wayland)
│   ├── redox-wl-test-shm-open/           # primitive 3 : shm_open + mmap MAP_SHARED
│   ├── redox-wl-test-poll-multifd/       # primitive 4 : poll() multiplexing + POLLHUP
│   ├── redox-wl-poc-pixels/              # POC : datapath shm + SCM_RIGHTS bout en bout
│   ├── redox-wl-test-handshake/          # phase 3 : wayland-rs server/client registry
│   ├── redox-wl-test-shm-pipeline/       # phase 3 : pipeline shm complet validé
│   └── redox-wl-test-display-backend/    # phase 4.1 : ouvre display Redox via inputd + V2GraphicsHandle
└── (pas de Cargo.toml racine : chaque crate est standalone — voir note ci-dessous)

Note structure : pas de workspace Cargo racine. Chaque crate dans crates/ est autonome avec son propre Cargo.toml et son propre target/ lors de la build. Raison : redoxer build/redoxer run cherche le binaire dans <crate>/target/... et n'arrive pas à le retrouver si le target/ est centralisé au niveau workspace. Ce sera repensé quand on aura un compositor unique vs plusieurs binaires de tests.

Prérequis

  • Rust nightly (récent — testé 2026-05-07)
  • Target installé : rustup target add x86_64-unknown-redox --toolchain nightly
  • cargo install redoxer puis redoxer install (sysroot Redox ~456 Mo)
  • Repo upstream Smithay/wayland-rs cloné en ../wayland-rs/ (paths relatifs depuis crates/*/Cargo.toml)

Reproduire les tests

Chaque crate s'exécute via redoxer (mini-VM Redox sous QEMU) :

cd crates/redox-wl-test-shm-pipeline
redoxer run --release

Pattern attendu en fin d'exécution : [test-XX] PASS: ....

Important : utiliser redoxer build ou redoxer run, pas cargo build --target=x86_64-unknown-redox direct qui fait un fail au link (undefined reference CMSG_NXTHDR/CMSG_DATA) parce que le linker host ne sait pas chaîner librelibc.a du sysroot Redox. redoxer configure le linker correctement.

Tests qui exigent un vrai framebuffer

Les binaires qui touchent au display (à partir de redox-wl-test-display-backend) ne tourneront pas sous redoxer run standard car celui-ci est headless. Deux voies pour les exécuter :

Voie A — redoxer exec --gui (mini-VM interactive)

cd crates/redox-wl-test-display-backend
redoxer build --release
redoxer exec --gui target/x86_64-unknown-redox/release/redox-wl-test-display-backend

Ouvre une fenêtre QEMU, boote une mini-VM Redox avec framebuffer, lance le binaire. À fermer manuellement quand le test est fini.

Voie B — Image complète + make qemu

Pousser le binaire dans une image Redox bootable via redoxfs-fuse, puis booter en mode interactif. Étapes :

# 1. Monter l'image (redoxfs reste en foreground tant que monté)
mkdir -p /tmp/redox-mnt
~/Projets/Redox/redox-src/build/fstools/bin/redoxfs \
    ~/Projets/Redox/redox-src/build/x86_64/desktop/harddrive.img \
    /tmp/redox-mnt &
sleep 2

# 2. Copier le binaire dans /usr/bin de l'image
cp ~/Projets/Redox/redox-wayland-compositor/crates/redox-wl-test-display-backend/target/x86_64-unknown-redox/release/redox-wl-test-display-backend \
    /tmp/redox-mnt/usr/bin/

# 3. Démonter
fusermount -u /tmp/redox-mnt
rmdir /tmp/redox-mnt

# 4. Booter (avec clavier FR si besoin, voir hook QEMU_USER_FLAGS dans mk/qemu.mk)
cd ~/Projets/Redox/redox-src
make qemu audio=no QEMU_USER_FLAGS="-k fr"

Une fois Redox bootée :

  • Ctrl+Alt+F2 pour basculer sur le VT 2 (console texte), sans Orbital
  • Login : root / mot de passe password
  • Lancer : redox-wl-test-display-backend

Le binaire écrit aussi sur /scheme/debug (serial), donc même si tu lances depuis Orbital (VT 3) la sortie sera visible côté host dans le terminal qui a lancé make qemu.

Roadmap

Voir REDOX_COSMIC_XWAYLAND_RS_PLAN.md pour le plan complet 14 phases / 5 ans.

Prochaine étape : phase 4 — display backend Redox via graphics-ipc::V2GraphicsHandle.

Licence

Leyoda 2026 — GPLv3+