Migrate GTK widget tree to quadraui AppShell + run_with_shell()

[JDonaghy]

Summary

Replace vimcode's hand-built GTK widget tree — struct App (~456 lines of widget refs), fn init (~2,122 lines of widget creation), and the view macro (~814 lines) — with quadraui::gtk::run_with_shell(). The AppShell creates the standard editor layout (title bar, activity bar, sidebar revealer, editor DA, bottom panel, status bar, command line) from a config struct.

What exists in quadraui

• quadraui::compose::AppShell — widget tree builder with dynamic panel registration (add_panel, remove_panel)
• quadraui::shell::ShellApp trait — apps implement setup(), render_content(), handle()
• quadraui::gtk::shell_runner::run_with_shell() — wraps ShellApp in AppShell, drives GTK event loop
• ShellConfig — declares panels, sidebar width, activity bar items

What to do

1. Implement ShellApp for vimcode's GTK entry point
2. Build a ShellConfig describing vimcode's panels (Explorer, Search, Git, Debug, Extensions, AI)
3. Replace fn init + view macro with run_with_shell(config, app)
4. Delete struct App widget refs (replaced by AppShell-owned handles)
5. Keep platform services wiring (clipboard via setup_gtk_clipboard(), file dialogs)

Files

• src/gtk/mod.rs — bulk of the deletion (~3,392 lines from init/view/App struct)
• Possibly new src/gtk/app.rs for the ShellApp impl

Dependencies

• quadraui Settings panel: descriptions on SettingDef are never rendered (hint field unused) #202 Stage 1 (AppShell) ✅ landed
• Should land after Migrate GTK draw wiring to quadraui ScreenLayout::draw() #446 (draw wiring migration) — easier to migrate draw first while widget tree still exists, then swap the tree

Notes

This is issue 2 of 4 in the GTK AppShell consumption series. Depends on #446.

[JDonaghy]

Briefing (coordinator, 2026-05-18)

Predecessor #446 is done — all draw wiring now goes through ScreenLayout::draw(). This issue replaces the hand-built widget tree.

Target deletion: ~3,392 lines from src/gtk/mod.rs (struct App widget refs, fn init widget creation, view macro).

Approach:

1. Pull quadraui first: cd ~/src/quadraui && git pull
2. Read the quadraui shell example: ~/src/quadraui/quadraui/examples/common/shell_demo.rs (or similar)
3. Implement ShellApp for vimcode's GTK entry point
4. Build ShellConfig with vimcode's 6 panels (Explorer, Search, Git, Debug, Extensions, AI)
5. Replace fn init + view macro with run_with_shell(config, app)
6. Delete struct App widget refs
7. Keep: setup_gtk_clipboard(), file dialog wiring, platform services

Your files: src/gtk/mod.rs, possibly new src/gtk/app.rs. Do NOT touch src/tui_main/, src/core/engine/keys.rs, or src/render.rs.

Quality gate: cargo build && cargo test --no-default-features && cargo clippy -- -D warnings && cargo fmt --check all green before pushing.

[JDonaghy]

Push-back: scope gap between issue and current quadraui infrastructure

Started looking at this and hit a structural mismatch. Documenting before reverting the claim so a future session (or coordinator) knows the state.

What's actually in quadraui today (post git pull)

quadraui::compose::AppShell (compose/app_shell.rs) owns:

• Activity bar (top + bottom items)
• Sidebar header chrome (just a title bar)
• Sidebar content bounds (consumer paints the panel content)
• Resize divider
• Main content bounds (consumer paints everything else)

It does NOT own — despite what this issue's summary lists:

• Title bar / window controls
• Per-panel sidebar containers (explorer, search, debug, git, ext, ai)
• Editor DrawingArea
• Bottom panel
• Status bar
• Command line

run_with_shell() (gtk/shell_runner.rs) wraps AppShell in an AppLogic adapter and calls quadraui::gtk::run(). run.rs:24-30 says explicitly:

Apps with multiple independently-painted surfaces (vimcode's per-DrawingArea model with ~20 distinct DAs) need a richer shape. […] once a multi-area runner ships, it will pass the AreaId for whichever DA is repainting […]. Stage B (this file) proves the trait shape end-to-end on the simple case.

So run_with_shell is a single-DrawingArea runner today. It owns Application + Window + one DA + all GDK event controllers on that DA + the single draw callback.

What that means for vimcode

Vimcode's src/gtk/mod.rs has:

• 14 distinct gtk4::DrawingAreas: explorer / activity_bar / ctx_menu_overlay / editor / menu_bar / debug_sidebar / git_sidebar / ext_sidebar / ext_dyn_panel / ai_sidebar / settings / search_sidebar / menu_dropdown / panel_hover
• Native GTK widgets: 3 window control buttons, gtk4::Revealer for sidebar, gtk4::ScrolledWindow, gtk4::Overlay for editor scrollbars
• Full Relm4 SimpleComponent: Msg enum (333 lines), view! macro (814 lines), #[watch] reactive bindings, sender.input() dispatch

Adopting run_with_shell() requires all of:

1. Replace Relm4 entirely (no more SimpleComponent / Msg / view! / #[watch] / sender.input()).
2. Collapse 14 DAs into 1 single DA.
3. Convert native window-control Buttons into paint primitives + click hit-testing.
4. Move every overlay DA (menu dropdown, hover popups, ctx menu, find/replace, editor scrollbars) into the same single-DA frame.

That's a near-total rewrite of src/gtk/, not the ~3,392-line delete the issue implies. The 3,392 number counts only struct App + fn init + view! macro — it doesn't count what would need to be added to a ShellApp::render_content() + ShellApp::handle() to replace those, nor the Msg/update rewiring, nor the all-DAs-to-one collapse, nor the Relm4 removal.

Why the briefing's approach won't work as written

The briefing says:

3. Implement ShellApp for vimcode's GTK entry point
4. Build ShellConfig with vimcode's 6 panels
5. Replace fn init + view macro with run_with_shell(config, app)

You can't just "swap run_with_shell in" while keeping the rest, because:

• run_with_shell creates its own GTK Application + Window + DA. The Relm4 component tree never gets instantiated.
• ShellApp::render_content is called from inside quadraui's set_draw_func. There's no #[watch], no Msg, no sender.input() available.
• Vimcode's per-panel sidebar DAs would have nowhere to mount — run_with_shell doesn't expose a way to add child widgets to the sidebar content area; the consumer is expected to paint into sidebar_content_bounds themselves.

What quadraui-first infrastructure looks like missing

This is Stage 1 of quadraui#202 — but the rest of that epic (Stages 2–6) is what makes a run_with_shell-based vimcode actually viable. Concretely, before this issue can be picked up:

• Multi-area GTK runner (mentioned in run.rs:24-30 as future work, with AppLogic::AreaId as the trait seam already in place)
• AppShell needs slots / config for: title bar above activity bar, bottom panel between sidebar/main and status bar, status bar below main, command-line row above status bar — or vimcode needs a way to reserve top/bottom chrome bands before handing the rest to AppShell
• Multi-panel sidebar: AppShell currently has one sidebar_content_bounds; vimcode has 6 distinct panels (explorer, search, debug, git, ext, ai) plus dynamic ext panels. ShellApp consumer could route active_panel_id → paint-specific-panel itself, but the sidebar content area would still be one bounding rect, not a gtk4::Revealer + per-panel gtk4::Box.

Suggested next steps

1. File a quadraui issue (or revise Settings panel: descriptions on SettingDef are never rendered (hint field unused) #202) describing the missing pieces above. Prerequisite for this issue.
2. Possibly split Migrate GTK widget tree to quadraui AppShell + run_with_shell() #447 into smaller wave-style issues:
   • "Adopt AppShell struct (NOT run_with_shell) inside existing Relm4/multi-DA tree" — gives quadraui-owned activity bar state + sidebar visibility on the existing activity_bar_da. ~200–400 line deletion, low risk, doable today.
   • "Multi-area GTK runner in quadraui" (depends on quadraui-side work)
   • "Collapse N DAs to 1" (depends on multi-area runner being optional / or on quadraui shipping the chrome slots)
   • "Strip Relm4" (final stage once run_with_shell can host everything)

Unassigning + deleting claim branch since I'm not landing a fix.

— Session 387 follow-up (2026-05-18)

[JDonaghy]

Gap filed in quadraui as JDonaghy/quadraui#217 — describes the 4 infrastructure pieces (multi-area runner, chrome slots, multi-panel sidebar ergonomics, native-modal hooks) that need to land before this issue is pickable.

[JDonaghy]

Unblocked — quadraui#217 Stage 1+2 landed (2026-05-18)

quadraui PR #219 merged. AppShell now has chrome slots (title bar, bottom panel, command line, status bar) and the single-DA model is locked in.

Before starting: cd ~/src/quadraui && git pull

What's now available in quadraui:

• ShellConfig::with_title_bar(height_lh), .with_bottom_panel(height_lh), .with_command_line(), .with_status_bar()
• AppShellLayout gains title_bar_bounds, bottom_panel_bounds, command_line_bounds, status_bar_bounds (all Option<Rect>)
• ShellContext gains in_title_bar(), in_bottom_panel(), in_command_line(), in_status_bar() helpers
• Bottom panel resize drag with min/max clamping
• Reference: ~/src/quadraui/quadraui/examples/common/full_chrome_demo.rs

Still missing (Stages 3+4, not blocking):

• Multi-panel sidebar ergonomics (panel-local coord helper)
• File dialog / PlatformServices hooks

The original pushback (comment from earlier today) identified that run_with_shell requires collapsing 14 DAs to 1 + stripping Relm4. That's still the end goal but can be done incrementally. Consider starting with the intermediate step: adopt AppShell struct inside the existing Relm4 tree to own activity bar + sidebar state, deleting ~200-400 lines of bespoke widget code.

[JDonaghy]

Agent Briefing — Desktop A (Session 389)

⚠️ FIRST: cd ~/src/quadraui && git pull — quadraui#217 (AppShell chrome slots) landed since last session. You need the new API.

Goal

Replace vimcode's hand-built GTK widget tree with quadraui::gtk::run_with_shell().

Files you own

• src/gtk/mod.rs — bulk of the work (~3,392 lines to delete/replace from struct App, fn init, view macro)
• src/gtk/app.rs — new file for ShellApp impl (if you split it out)

Do NOT touch

• src/tui_main/ — Server agent is there (TUI: Unify sidebar panel key translation into a shared helper #475)
• ~/src/quadraui/ — separate repo, separate agent

Approach

1. Read quadraui's AppShell API: ~/src/quadraui/quadraui/src/compose/app_shell.rs and the shell_runner module
2. Read the app_shell example: ~/src/quadraui/quadraui/examples/app_shell_app.rs
3. Implement ShellApp for vimcode's GTK entry point
4. Build ShellConfig declaring vimcode's panels (Explorer, Search, Git, Debug, Extensions, AI)
5. Replace fn init + view macro with run_with_shell(config, app)
6. Delete struct App widget refs
7. Keep platform services wiring (setup_gtk_clipboard(), file dialogs)

Quality gate

cargo build + cargo clippy -- -D warnings must pass. This is GTK-only so cargo test --no-default-features for the test suite.

Branch

issue-447-gtk-appshell