event_loop, a11y, text_shaping: AccessKit AT-SPI2 bridge, cross-app clipboard, xdg-activation, HarfBuzz shaping, multi-touch hooks

Five orthogonal capabilities land together because they share the same `try_run` plumbing: an optional global is bound at startup, a piece of state is added to `AppData`, the run-loop iteration drains an inbox / pushes a frame snapshot, and the public surface gains a small set of opt-in `App` hooks. Nothing here breaks an existing app — every new path degrades to a no-op when the compositor does not advertise the relevant global or when the platform adapter cannot start.
AT-SPI2 accessibility via AccessKit. A new `src/a11y/` module owns the platform adapter and the inbound `ActionRequest` channel. `A11yState::try_new` constructs an `accesskit_unix::Adapter`; when the AT-SPI2 daemon is not on the session bus (headless CI, locked-down compositors) the constructor returns `None` and the rest of the pipeline runs unchanged. After every successful `draw_frame`, the run loop builds a fresh `accesskit::TreeUpdate` from `widget_rects` and pushes it through the adapter — main surface plus every visible overlay, each translated to global coordinates via `surface_offset_for` so screen readers report positions in the same frame the user sees. Buttons / toggles / checkboxes / radios / list items / sliders / text edits map to the matching `Role`s; `Click` and `Focus` actions are advertised on every interactive node; inbound action requests are drained at the top of each iteration and translated into a synthetic press / focus on the matching widget. The integration is documented as best-effort in `docs/architecture.md` under "Known gaps and non-goals": hierarchical nesting, per-widget accessible names, live regions and `Action::SetValue` are listed as the natural follow-ups that the foundation now supports but does not yet wire.
Cross-application clipboard via `wl_data_device_manager`. A new `src/event_loop/data_device.rs` bridges the existing process-local `clipboard: String` to the Wayland selection. Outbound (Ctrl+C / Cut): after the local clipboard is populated, `publish_clipboard_selection` creates a `CopyPasteSource` offering `text/plain;charset=utf-8` and installs it as the seat's selection; `DataSourceHandler::send` writes the cached string into the fd the peer hands us. Inbound (Ctrl+V from another app): `DataDeviceHandler::selection` asks for the offered text via `WlDataOffer::receive`, spawns a tiny worker thread to drain the read pipe with a 16 MiB cap to prevent paste-bomb DoS, and posts the result back through an `mpsc::Sender` that the run loop drains each iteration into `data.clipboard`. The `clipboard:` field's doc-comment is updated to reflect the new behaviour: process-local when the compositor does not advertise the global, synchronised with the seat selection otherwise.
External drag-and-drop reception. The same `data_device` module handles `DragOffer` enter / motion / leave / drop_performed: `on_drop_motion( x, y )` fires while the drag hovers over the surface, `on_drop_leave()` when it withdraws without dropping, and `on_drop_received( x, y, mime, text )` when an external payload (`text/uri-list`, `text/plain`, …) is released on top of an ltk window. The receive path reuses the same worker-thread / channel pattern as the clipboard so the run loop never blocks on the read fd. Three new `App` hooks expose the events with no-op defaults; apps that ignore them get the previous behaviour.
`xdg-activation-v1`. The global is bound optionally; when it is present, `try_run` reads `$XDG_ACTIVATION_TOKEN` from the environment, removes it immediately (single-use; preventing leaks into child processes) and stashes it on `AppData::activation_token_pending`. After the first successful configure of the main surface — the earliest point at which `xdg_activation_v1.activate` is meaningful — the token is consumed once and the surface raised to focus. Compositors without the global leave `activation_state` as `None` and the inbound path silently degrades. An `App::request_activation_token` outbound path is reserved on the trait but not yet exercised here.
HarfBuzz shaping. A new `src/text_shaping.rs::shape_line` drives both renderers: the logical-order string is run through `unicode-bidi`, split into per-font sub-runs, and shaped through `rustybuzz`. Each `PositionedGlyph` carries the per-font `glyph_id`, the visual advance and the ink offsets — exactly what `fontdue::Font::rasterize_indexed` needs to render Arabic connected forms, Devanagari clusters and CJK shaped glyphs correctly. The GLES atlas is re-keyed on `(glyph_id, size_bits, font_id)` so glyphs from different fonts at the same size no longer collide, and the atlas format is selected per ES profile (`GL_R8` / `GL_RED` on ES3, `GL_LUMINANCE` on ES2) — the fragment shader samples `.r` for both, since `GL_LUMINANCE` replicates the coverage byte into `.r=.g=.b`. Software path follows the same key. New `Cargo.toml` deps: `unicode-bidi = "0.3"`, `rustybuzz = "0.14"`.
Multi-touch hooks. `App::on_touch_down / on_touch_move / on_touch_up( id, x, y )` expose the raw `wl_touch.id` of every secondary finger. The first finger to land remains the *primary slot* and is fed through the regular gesture machine (`on_pointer_*`, swipe, scroll, long-press, drag-and-drop). Every additional finger fires the new callbacks instead, leaving the existing single-slot behaviour untouched for apps that do not override them. This is the substrate for app-defined pinch-zoom / two-finger pan; the toolkit itself does not yet ship a built-in pinch gesture (called out in the same "Known gaps" doc section).
`event_loop::frame` extracted from `draw/mod.rs`. The `draw_frame` orchestrator and its per-format SHM helper (`pick_shm_format`) move into `src/event_loop/frame.rs`, leaving `draw/` strictly responsible for per-surface paint primitives. The import in `event_loop/run.rs` is rewritten accordingly; `draw/mod.rs` shrinks from 192-line orchestrator to a thin module index.
Overlay teardown safety. `AppData::discard_overlay( id )` synchronously removes a destroyed overlay from the map and rewrites every per-device focus that pointed at it (pointer, keyboard, every touch slot), migrating an in-flight long-press drag to the main surface the same way `reconcile_overlays` does. Used by the compositor-driven destruction paths (`PopupHandler::done`, `LayerShellHandler::closed`) where waiting for the next reconcile would leave a window in which `surface()` / `surface_mut()` panic. The non-panicking siblings `try_surface` / `try_surface_mut` are added for callers on async dispatch paths (IME `Done`, tooltip arm) that may race a teardown.
Miscellaneous. CI: `master` → `main` to match the actual default branch. `Makefile` adds `cargo run --example dialog` to the examples target. `src/lib.rs` re-exports `widget::scroll::ScrollAxis` so apps can configure a `scroll()` axis without reaching into a `pub(crate)` module. `Cargo.toml` adds `accesskit = "0.17"` and `accesskit_unix = "0.13"`. `docs/architecture.md` gains the "Known gaps and non-goals" section that enumerates the new capabilities, what still ships flat, and what is deferred (per-widget a11y labels, primary selection, intra-process multi-touch gestures, `wp_fractional_scale_v1`).

src/draw/damage.rs

@@ -234,6 +234,8 @@ mod tests
 			keyboard_focusable: true,
 			cursor:             crate::types::CursorShape::Default,
 			tooltip:            None,
+			accessible_label:   None,
+			is_live_region:     false,
 		}
 	}
 

src/draw/gles.rs

@@ -102,6 +102,8 @@ pub( crate ) fn draw_surface_full_gpu<Msg: Clone>(
 		scroll_canvases: std::mem::take( &mut ss.scroll_canvases ),
 		scroll_navigable_items: std::mem::take( &mut ss.scroll_navigable_items ),
 		previous_widget_rects: ss.widget_rects.clone(),
+		accessible_extras: Vec::new(),
+		live_depth: 0,
 	};
 	layout_and_draw::<Msg>( view, canvas, screen_rect, &mut ctx, 0 );
 
@@ -134,6 +136,7 @@ pub( crate ) fn draw_surface_full_gpu<Msg: Clone>(
 	ss.cursor_state    = ctx.cursor_state;
 	ss.selection_anchor = ctx.selection_anchor;
 	ss.scroll_offsets  = ctx.scroll_offsets;
+	ss.accessible_extras = ctx.accessible_extras;
 	ss.scroll_navigable_items = ctx.scroll_navigable_items;
 	ss.content_dirty   = false;
 
@@ -206,6 +209,8 @@ pub( crate ) fn draw_surface_partial_gpu<Msg: Clone>(
 		scroll_canvases: std::mem::take( &mut ss.scroll_canvases ),
 		scroll_navigable_items: std::mem::take( &mut ss.scroll_navigable_items ),
 		previous_widget_rects: ss.widget_rects.clone(),
+		accessible_extras: Vec::new(),
+		live_depth: 0,
 	};
 	layout_and_draw::<Msg>( view, canvas, screen_rect, &mut ctx, 0 );
 
@@ -231,6 +236,7 @@ pub( crate ) fn draw_surface_partial_gpu<Msg: Clone>(
 	ss.cursor_state    = ctx.cursor_state;
 	ss.selection_anchor = ctx.selection_anchor;
 	ss.scroll_offsets  = ctx.scroll_offsets;
+	ss.accessible_extras = ctx.accessible_extras;
 	ss.scroll_navigable_items = ctx.scroll_navigable_items;
 	ss.content_dirty   = false;
 

src/draw/layout.rs

@@ -130,6 +130,8 @@ pub( crate ) fn layout_and_draw<Msg: Clone>(
 					keyboard_focusable: false,
 					cursor:             p.cursor.unwrap_or( crate::types::CursorShape::Pointer ),
 					tooltip:            None,
+					accessible_label:   None,
+					is_live_region:     ctx.live_depth > 0,
 				} );
 			}
 			layout_and_draw::<Msg>( p.child.as_ref(), canvas, rect, ctx, my_idx + 1 )
@@ -138,6 +140,8 @@ pub( crate ) fn layout_and_draw<Msg: Clone>(
 		{
 			let saved_alpha = canvas.global_alpha();
 			canvas.set_global_alpha( saved_alpha * c.opacity );
+			let live_inc = if c.a11y_live { 1 } else { 0 };
+			ctx.live_depth += live_inc;
 
 			let rect = if let Some( mw ) = c.max_width
 			{
@@ -190,25 +194,33 @@ pub( crate ) fn layout_and_draw<Msg: Clone>(
 			};
 			let result = layout_and_draw::<Msg>( c.child.as_ref(), canvas, inner, ctx, flat_idx );
 
+			ctx.live_depth -= live_inc;
 			canvas.set_global_alpha( saved_alpha );
 			result
 		}
 		Element::Scroll( s ) =>
 		{
 			let my_idx     = flat_idx;
-			let offset_raw = ctx.scroll_offsets.get( &my_idx ).copied().unwrap_or( 0.0 );
-			let child_h    = s.child.preferred_size( rect.width, canvas ).1;
-			let offset     = crate::widget::scroll::clamp_offset( offset_raw, child_h, rect.height );
-			// Write the clamped offset back so input handlers (wheel /
+			let axis       = s.axis;
+			let ( ox_raw, oy_raw ) = ctx.scroll_offsets.get( &my_idx ).copied().unwrap_or( ( 0.0, 0.0 ) );
+			// Width-aware preferred size: when the axis allows horizontal
+			// overflow we let the child report its natural width by
+			// asking with `f32::INFINITY`; otherwise the child stays
+			// clamped to the viewport so wraps still happen.
+			let child_w_max = if axis.allows_x() { f32::INFINITY } else { rect.width };
+			let ( child_w, child_h ) = s.child.preferred_size( child_w_max, canvas );
+			let ox = if axis.allows_x() { crate::widget::scroll::clamp_offset( ox_raw, child_w, rect.width  ) } else { 0.0 };
+			let oy = if axis.allows_y() { crate::widget::scroll::clamp_offset( oy_raw, child_h, rect.height ) } else { 0.0 };
+			// Write the clamped offsets back so input handlers (wheel /
 			// drag) cannot accumulate past the content extents. Without
-			// this, repeated wheel ticks past the bottom keep growing
-			// `offset_raw` and the user has to "undo" that excess before
-			// the content scrolls back up. The clamp is idempotent for
-			// in-range values, so the only effect is collapsing
-			// out-of-range entries to the legitimate maximum.
-			if offset != offset_raw
+			// this, repeated wheel ticks past the edge keep growing
+			// `*_raw` and the user has to "undo" that excess before the
+			// content scrolls back. The clamp is idempotent for in-range
+			// values, so the only effect is collapsing out-of-range
+			// entries to the legitimate maximum.
+			if ox != ox_raw || oy != oy_raw
 			{
-				ctx.scroll_offsets.insert( my_idx, offset );
+				ctx.scroll_offsets.insert( my_idx, ( ox, oy ) );
 			}
 
 			// Reuse the sub-canvas from the previous frame if its size matches;
@@ -220,13 +232,15 @@ pub( crate ) fn layout_and_draw<Msg: Clone>(
 				.unwrap_or_else( || canvas.sub_canvas( sw, sh ) );
 			sub.clear();
 
-			// Child content fills at least the full viewport height so that
-			// children with VAlign::Bottom are positioned correctly when the
-			// content is shorter than the viewport.
-			let effective_h = child_h.max( rect.height );
-			// Shift child up by offset so scrolled content appears at y=0 in
-			// the sub-canvas.
-			let child_rect = Rect { x: 0.0, y: -offset, width: rect.width, height: effective_h };
+			// Child content fills at least the full viewport on each
+			// allowed axis so that children with `Bottom`/`Right`
+			// alignment are positioned correctly when the content is
+			// shorter than the viewport along that axis.
+			let effective_w = if axis.allows_x() { child_w.max( rect.width  ) } else { rect.width  };
+			let effective_h = if axis.allows_y() { child_h.max( rect.height ) } else { rect.height };
+			// Shift child by `(-ox, -oy)` so scrolled content appears at
+			// `(0, 0)` of the sub-canvas.
+			let child_rect = Rect { x: -ox, y: -oy, width: effective_w, height: effective_h };
 
 			let rects_before        = ctx.widget_rects.len();
 			let scroll_rects_before = ctx.scroll_rects.len();
@@ -245,11 +259,11 @@ pub( crate ) fn layout_and_draw<Msg: Clone>(
 			// caring about which items are currently scrolled into view.
 			// The recorded Y is in pre-translation, pre-offset coordinates
 			// (i.e. `child_y` relative to the start of the scroll content),
-			// recovered by undoing the `-offset` shift the child layout pass
-			// applied: `content_y = w.rect.y - child_rect.y = w.rect.y + offset`.
+			// recovered by undoing the `-oy` shift the child layout pass
+			// applied: `content_y = w.rect.y - child_rect.y = w.rect.y + oy`.
 			let navigable: Vec<( usize, f32, f32 )> = new_rects.iter()
 				.filter( |w| w.handlers.is_navigable_list_item() )
-				.map( |w| ( w.flat_idx, w.rect.y + offset, w.rect.height ) )
+				.map( |w| ( w.flat_idx, w.rect.y + oy, w.rect.height ) )
 				.collect();
 			if !navigable.is_empty()
 			{
@@ -264,8 +278,12 @@ pub( crate ) fn layout_and_draw<Msg: Clone>(
 				w.paint_rect.x += rect.x;
 				w.paint_rect.y += rect.y;
 				w.paint_rect = clamp_rect_to( w.paint_rect, rect );
-				// Only keep widgets at least partially visible inside the viewport.
-				if w.rect.y + w.rect.height > rect.y && w.rect.y < rect.y + rect.height
+				// Only keep widgets at least partially visible inside the
+				// viewport — now bi-axial because Scroll::horizontal /
+				// Scroll::both push content off-screen along x too.
+				let visible_y = w.rect.y + w.rect.height > rect.y && w.rect.y < rect.y + rect.height;
+				let visible_x = w.rect.x + w.rect.width  > rect.x && w.rect.x < rect.x + rect.width;
+				if visible_x && visible_y
 				{
 					ctx.widget_rects.push( w );
 				}
@@ -278,20 +296,20 @@ pub( crate ) fn layout_and_draw<Msg: Clone>(
 			// (0, 0) of the surface. Clamp to the outer scroll rect so
 			// the inner scroll only captures wheel events inside its
 			// visible region.
-			let new_scroll_rects: Vec<( Rect, usize )> =
+			let new_scroll_rects: Vec<( Rect, usize, crate::widget::scroll::ScrollAxis )> =
 				ctx.scroll_rects.drain( scroll_rects_before.. ).collect();
-			for ( mut r, idx ) in new_scroll_rects
+			for ( mut r, idx, ax ) in new_scroll_rects
 			{
 				r.x += rect.x;
 				r.y += rect.y;
 				let clamped = clamp_rect_to( r, rect );
 				if clamped.width > 0.0 && clamped.height > 0.0
 				{
-					ctx.scroll_rects.push( ( clamped, idx ) );
+					ctx.scroll_rects.push( ( clamped, idx, ax ) );
 				}
 			}
 
-			ctx.scroll_rects.push( ( rect, my_idx ) );
+			ctx.scroll_rects.push( ( rect, my_idx, axis ) );
 
 			canvas.blit( &sub, rect.x as i32, rect.y as i32 );
 
@@ -330,16 +348,16 @@ pub( crate ) fn layout_and_draw<Msg: Clone>(
 			// Translate scroll_rects pushed by nested scroll widgets
 			// from sub-canvas to surface space. Same reasoning as the
 			// scroll-inside-scroll case above.
-			let new_scroll_rects: Vec<( Rect, usize )> =
+			let new_scroll_rects: Vec<( Rect, usize, crate::widget::scroll::ScrollAxis )> =
 				ctx.scroll_rects.drain( scroll_rects_before.. ).collect();
-			for ( mut r, idx ) in new_scroll_rects
+			for ( mut r, idx, ax ) in new_scroll_rects
 			{
 				r.x += rect.x;
 				r.y += rect.y;
 				let clamped = clamp_rect_to( r, rect );
 				if clamped.width > 0.0 && clamped.height > 0.0
 				{
-					ctx.scroll_rects.push( ( clamped, idx ) );
+					ctx.scroll_rects.push( ( clamped, idx, ax ) );
 				}
 			}
 
@@ -380,8 +398,50 @@ pub( crate ) fn layout_and_draw<Msg: Clone>(
 					keyboard_focusable: other.is_focusable(),
 					cursor:             other.cursor_shape(),
 					tooltip:            other.tooltip().map( str::to_string ),
+					accessible_label:   other.accessible_label(),
+					is_live_region:     ctx.live_depth > 0,
 				} );
 			}
+			else
+			{
+				let live = ctx.live_depth > 0;
+				match other
+				{
+					Element::Text( t ) if !t.content.is_empty() =>
+					{
+						ctx.accessible_extras.push( crate::a11y::tree::AccessibleExtra
+						{
+							rect, label: Some( t.content.clone() ), live,
+							kind: crate::a11y::tree::AccessibleExtraKind::Label,
+						} );
+					}
+					Element::Image( _ ) =>
+					{
+						ctx.accessible_extras.push( crate::a11y::tree::AccessibleExtra
+						{
+							rect, label: None, live,
+							kind: crate::a11y::tree::AccessibleExtraKind::Image,
+						} );
+					}
+					Element::Separator( _ ) =>
+					{
+						ctx.accessible_extras.push( crate::a11y::tree::AccessibleExtra
+						{
+							rect, label: None, live,
+							kind: crate::a11y::tree::AccessibleExtraKind::Separator,
+						} );
+					}
+					Element::ProgressBar( p ) =>
+					{
+						ctx.accessible_extras.push( crate::a11y::tree::AccessibleExtra
+						{
+							rect, label: None, live,
+							kind: crate::a11y::tree::AccessibleExtraKind::Progress( p.value ),
+						} );
+					}
+					_ => {}
+				}
+			}
 			flat_idx + 1
 		}
 	}

src/draw/mod.rs

@@ -17,8 +17,8 @@
 //!
 //! Each of those paths has a software variant (CPU + SHM pool) and a
 //! GLES variant (FBO + EGL swap). The four resulting functions live in
-//! [`software`] and [`gles`]; this file is just the router plus the
-//! small shared setup ([`DrawCtx`], [`pick_shm_format`]).
+//! [`software`] and [`gles`]; routing and surface-level orchestration
+//! live in [`crate::event_loop::frame`].
 //!
 //! # Submodule layout
 //!
@@ -30,15 +30,10 @@
 //! * [`layout`] — `layout_and_draw` (the recursive element walker)
 
 use std::collections::HashMap;
-use std::sync::Arc;
-use smithay_client_toolkit::reexports::client::protocol::{ wl_shm, wl_surface::WlSurface };
-use smithay_client_toolkit::shm::Shm;
 
-use crate::app::App;
-use crate::event_loop::{ AppData, SurfaceFocus, SurfaceState };
 use crate::render::Canvas;
-use crate::types::{ Color, Rect };
-use crate::widget::{ Element, LaidOutWidget };
+use crate::types::Rect;
+use crate::widget::LaidOutWidget;
 
 pub( crate ) mod software;
 pub( crate ) mod gles;
@@ -49,23 +44,6 @@ pub( crate ) mod layout;
 pub( crate ) use damage::{ compute_damage, compute_interaction_dirty_rects };
 pub( crate ) use layout::layout_and_draw;
 
-/// Pick the best wl_shm format for our RGBA-premultiplied pixmap.
-///
-/// Abgr8888 matches tiny-skia's byteorder on little-endian systems, so we can
-/// copy with a plain memcpy. If the compositor doesn't advertise it, fall back
-/// to Argb8888 (mandatory per wl_shm) which requires a per-channel swap.
-///
-/// Returns `(format, swap_rb)`.
-pub( crate ) fn pick_shm_format( shm: &Shm ) -> ( wl_shm::Format, bool )
-{
-	if shm.formats().contains( &wl_shm::Format::Abgr8888 )
-	{
-		( wl_shm::Format::Abgr8888, false )
-	} else {
-		( wl_shm::Format::Argb8888, true )
-	}
-}
-
 /// Per-frame draw state threaded through [`layout_and_draw`]. Captures
 /// the interaction snapshot (focus / hover / pressed), scratch space
 /// for the widget-rect list the frame will produce, and the scroll
@@ -85,8 +63,8 @@ pub( crate ) struct DrawCtx<Msg: Clone>
 	pub selection_anchor: HashMap<usize, usize>,
 	pub widget_rects:  Vec<LaidOutWidget<Msg>>,
 	pub debug_layout:  bool,
-	pub scroll_offsets:  HashMap<usize, f32>,
-	pub scroll_rects:    Vec<(Rect, usize)>,
+	pub scroll_offsets:  HashMap<usize, ( f32, f32 )>,
+	pub scroll_rects:    Vec<( Rect, usize, crate::widget::scroll::ScrollAxis )>,
 	pub scroll_canvases: HashMap<usize, Canvas>,
 	/// Per-scroll navigation map: list of `(flat_idx, content_y, height)`
 	/// for every interactive item the scroll's child laid out, in
@@ -105,6 +83,11 @@ pub( crate ) struct DrawCtx<Msg: Clone>
 	/// re-position itself relative to that rect. Drivers populate this
 	/// before invoking the recursive layout / draw walk.
 	pub previous_widget_rects: Vec<LaidOutWidget<Msg>>,
+	/// Non-interactive widgets exposed only to the accessibility
+	/// tree (text labels, images, separators, progress bars).
+	pub accessible_extras: Vec<crate::a11y::tree::AccessibleExtra>,
+	/// Depth counter for containers marked `a11y_live`.
+	pub live_depth: u32,
 }
 
 /// Paint the built-in Copy / Cut / Paste context menu on top of the
@@ -172,156 +155,3 @@ pub( crate ) fn draw_context_menu(
 		canvas.draw_line( r.x + 8.0, *y, r.x + r.width - 8.0, *y, sep_color, 1.0 );
 	}
 }
-
-pub( crate ) fn draw_frame<A: App>( data: &mut AppData<A> )
-{
-	// Caches were refreshed by the run loop just before calling us; pull them
-	// by reference instead of re-invoking `App::view` / `App::overlays` each
-	// frame. The two `expect`s document the run loop's contract.
-	let main_view = data.cached_view.as_ref().expect( "view cache populated" );
-	let overlays  = data.cached_overlays.as_ref().expect( "overlays cache populated" );
-
-	let main_bg      = data.app.background_color();
-	let main_region  = data.app.input_region();
-	let debug_layout = data.debug_layout;
-	let ( format, swap_rb ) = pick_shm_format( &data.shm );
-	let egl_ctx = data.egl_context.as_ref();
-	let qh      = &data.qh;
-
-	if data.main.configured && data.main.needs_redraw && !data.main.frame_pending
-	{
-		let req_frame = | wl: &WlSurface | { let _ = wl.frame( qh, SurfaceFocus::Main ); };
-		draw_surface::<A::Message>(
-			&mut data.main,
-			&data.compositor_state,
-			egl_ctx,
-			main_view,
-			main_bg,
-			main_region.as_deref(),
-			debug_layout,
-			format,
-			swap_rb,
-			&req_frame,
-		);
-		data.main.needs_redraw = false;
-		data.main.last_draw    = std::time::Instant::now();
-	}
-
-	for spec in overlays
-	{
-		if let Some( ss ) = data.overlays.get_mut( &spec.id )
-		{
-			if !ss.configured || !ss.needs_redraw || ss.frame_pending { continue; }
-			let focus     = SurfaceFocus::Overlay( spec.id );
-			let req_frame = | wl: &WlSurface | { let _ = wl.frame( qh, focus ); };
-			let bg        = Color::rgba( 0.0, 0.0, 0.0, 0.0 );
-			draw_surface::<A::Message>(
-				ss,
-				&data.compositor_state,
-				egl_ctx,
-				&spec.view,
-				bg,
-				spec.input_region.as_deref(),
-				debug_layout,
-				format,
-				swap_rb,
-				&req_frame,
-			);
-			ss.needs_redraw = false;
-			ss.last_draw    = std::time::Instant::now();
-		}
-	}
-}
-
-/// Render one surface's current view. Picks between software and GLES,
-/// and within each picks between full and partial redraw based on what
-/// changed since the last committed frame.
-///
-/// The decision:
-/// * **Skip** — `content_dirty` is false and no interaction state
-///   changed. Previously committed buffer stays on screen.
-/// * **Partial** — `content_dirty` is false but focus / hover / pressed
-///   transitioned. Canvas is preserved across frames, so clip to the
-///   dirty widgets and repaint only under the clip.
-/// * **Full** — `content_dirty` is true. Clear + redraw + damage.
-///
-/// Partial eligibility also bails out when the total dirty area >50%
-/// of the surface: at that ratio per-region clipping is no faster than
-/// a plain full redraw, so the code prefers one big damage rect over
-/// several small ones.
-fn draw_surface<Msg: Clone>(
-	ss:            &mut SurfaceState<Msg>,
-	compositor:    &smithay_client_toolkit::compositor::CompositorState,
-	egl_ctx:       Option<&Arc<crate::egl_context::EglContext>>,
-	view:          &Element<Msg>,
-	bg:            Color,
-	input_region:  Option<&[Rect]>,
-	debug_layout:  bool,
-	shm_format:    wl_shm::Format,
-	swap_rb:       bool,
-	request_frame: &dyn Fn( &WlSurface ),
-)
-{
-	let scale = ss.scale_factor.max( 1 ) as u32;
-	let w = ss.width;
-	let h = ss.height;
-	if w == 0 || h == 0 { return; }
-	let pw     = w * scale;
-	let ph     = h * scale;
-
-	// Decide partial-redraw eligibility BEFORE allocating a buffer. If we end
-	// up skipping the frame, we want to avoid touching the SHM pool at all.
-	let canvas_ready = ss.canvas.as_ref()
-		.map( |c| c.size() == ( pw, ph ) )
-		.unwrap_or( false );
-	let partial_eligible = !ss.content_dirty
-		&& canvas_ready
-		&& !ss.widget_rects.is_empty();
-
-	if partial_eligible
-	{
-		let dirty_rects = compute_interaction_dirty_rects(
-			&ss.widget_rects,
-			ss.prev_focused, ss.prev_hovered, ss.prev_pressed,
-			ss.focused_idx,  ss.hovered_idx,  ss.gesture.pressed_idx,
-			pw, ph,
-		);
-		if dirty_rects.is_empty()
-		{
-			// Nothing visible changed — keep the previously committed buffer.
-			return;
-		}
-		// Total dirty area > 50% of screen: a full redraw is no slower than
-		// per-region clipping but emits a single damage rect.
-		let total: f32 = dirty_rects.iter().map( |r| r.width * r.height ).sum();
-		if total < pw as f32 * ph as f32 * 0.5
-		{
-			if let ( Some( ctx ), true ) = ( egl_ctx, ss.egl_surface.is_some() )
-			{
-				gles::draw_surface_partial_gpu(
-					ss, compositor, ctx, view, bg, input_region,
-					dirty_rects, pw, ph, scale, request_frame,
-				);
-			} else {
-				software::draw_surface_partial(
-					ss, compositor, view, bg, input_region,
-					shm_format, swap_rb, dirty_rects, pw, ph, scale, request_frame,
-				);
-			}
-			return;
-		}
-	}
-
-	if let ( Some( ctx ), true ) = ( egl_ctx, ss.egl_surface.is_some() )
-	{
-		gles::draw_surface_full_gpu(
-			ss, compositor, ctx, view, bg, input_region, debug_layout,
-			pw, ph, scale, request_frame,
-		);
-	} else {
-		software::draw_surface_full(
-			ss, compositor, view, bg, input_region, debug_layout,
-			shm_format, swap_rb, pw, ph, scale, request_frame,
-		);
-	}
-}

src/draw/software.rs

@@ -99,6 +99,8 @@ pub( crate ) fn draw_surface_full<Msg: Clone>(
 		scroll_canvases: std::mem::take( &mut ss.scroll_canvases ),
 		scroll_navigable_items: std::mem::take( &mut ss.scroll_navigable_items ),
 		previous_widget_rects: ss.widget_rects.clone(),
+		accessible_extras: Vec::new(),
+		live_depth: 0,
 	};
 	layout_and_draw::<Msg>( view, canvas, screen_rect, &mut ctx, 0 );
 
@@ -146,6 +148,7 @@ pub( crate ) fn draw_surface_full<Msg: Clone>(
 	ss.cursor_state    = ctx.cursor_state;
 	ss.selection_anchor = ctx.selection_anchor;
 	ss.scroll_offsets  = ctx.scroll_offsets;
+	ss.accessible_extras = ctx.accessible_extras;
 	ss.scroll_navigable_items = ctx.scroll_navigable_items;
 	ss.content_dirty   = false;
 
@@ -236,6 +239,8 @@ pub( crate ) fn draw_surface_partial<Msg: Clone>(
 		scroll_canvases: std::mem::take( &mut ss.scroll_canvases ),
 		scroll_navigable_items: std::mem::take( &mut ss.scroll_navigable_items ),
 		previous_widget_rects: ss.widget_rects.clone(),
+		accessible_extras: Vec::new(),
+		live_depth: 0,
 	};
 	layout_and_draw::<Msg>( view, canvas, screen_rect, &mut ctx, 0 );
 
@@ -263,6 +268,7 @@ pub( crate ) fn draw_surface_partial<Msg: Clone>(
 	ss.cursor_state    = ctx.cursor_state;
 	ss.selection_anchor = ctx.selection_anchor;
 	ss.scroll_offsets  = ctx.scroll_offsets;
+	ss.accessible_extras = ctx.accessible_extras;
 	ss.scroll_navigable_items = ctx.scroll_navigable_items;
 	ss.content_dirty   = false;