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/widget/container/mod.rs

@@ -92,6 +92,11 @@ pub struct Container<Msg: Clone>
 	/// Mirrors the same flag on [`Column`](crate::layout::column::Column)
 	/// and [`Row`](crate::layout::row::Row).
 	pub max_width:  Option<f32>,
+	/// When true, the contents of this container are announced by
+	/// assistive technologies as a `Live::Polite` region — useful for
+	/// toasts, status banners and OSDs that need to be read on
+	/// appearance even when the user has not navigated to them.
+	pub a11y_live:  bool,
 }
 
 impl<Msg: Clone> Container<Msg>
@@ -111,9 +116,16 @@ impl<Msg: Clone> Container<Msg>
 			opacity:    1.0,
 			border:     None,
 			max_width:  None,
+			a11y_live:  false,
 		}
 	}
 
+	pub fn live_region( mut self, live: bool ) -> Self
+	{
+		self.a11y_live = live;
+		self
+	}
+
 	/// Paint a rounded-rect stroke around the container with the given
 	/// colour and pixel width. Useful for input fields, popovers and
 	/// any chrome the design system specifies as outlined rather than
@@ -285,6 +297,7 @@ impl<Msg: Clone> Container<Msg>
 			opacity:    self.opacity,
 			border:     self.border,
 			max_width:  self.max_width,
+			a11y_live:  self.a11y_live,
 		}
 	}
 }

src/widget/element.rs

@@ -251,6 +251,25 @@ impl<Msg: Clone> Element<Msg>
 	///
 	/// Containers and layouts that delegate to children return
 	/// [`WidgetHandlers::None`] — only leaf widgets actually carry payload.
+	pub( crate ) fn accessible_label( &self ) -> Option<String>
+	{
+		match self
+		{
+			Element::Button( b ) => match &b.content
+			{
+				super::button::ButtonContent::Text( s ) => Some( s.clone() ),
+				super::button::ButtonContent::Icon { .. } => b.tooltip.clone(),
+			},
+			Element::Toggle( t )       => t.label.clone(),
+			Element::Checkbox( c )     => c.label.clone(),
+			Element::Radio( r )        => r.label.clone(),
+			Element::ListItem( l )     => Some( l.label.clone() ).filter( |s| !s.is_empty() ),
+			Element::WindowButton( _ ) => None,
+			Element::Text( t )         => Some( t.content.clone() ).filter( |s| !s.is_empty() ),
+			_                          => None,
+		}
+	}
+
 	pub( crate ) fn handlers( &self ) -> WidgetHandlers<Msg>
 	{
 		match self
@@ -271,9 +290,9 @@ impl<Msg: Clone> Element<Msg>
 				on_escape:     p.on_escape.clone(),
 				repeating:     false,
 			},
-			Element::Toggle( t )   => WidgetHandlers::Toggle   { on_toggle: t.on_toggle.clone() },
-			Element::Checkbox( c ) => WidgetHandlers::Checkbox { on_toggle: c.on_toggle.clone() },
-			Element::Radio( r )    => WidgetHandlers::Radio    { on_select: r.on_select.clone() },
+			Element::Toggle( t )   => WidgetHandlers::Toggle   { on_toggle: t.on_toggle.clone(), value: t.value },
+			Element::Checkbox( c ) => WidgetHandlers::Checkbox { on_toggle: c.on_toggle.clone(), value: c.checked },
+			Element::Radio( r )    => WidgetHandlers::Radio    { on_select: r.on_select.clone(), selected: r.selected },
 			Element::ListItem( l ) => WidgetHandlers::ListItem { on_press:  l.on_press.clone()  },
 			Element::WindowButton( b ) => WidgetHandlers::WindowButton { on_press: b.on_press.clone() },
 			Element::TextEdit( t ) =>
@@ -301,6 +320,7 @@ impl<Msg: Clone> Element<Msg>
 				{
 					on_change: s.on_change.clone(),
 					axis:      slider::SliderAxis::Horizontal,
+					value:     s.value,
 				}
 			}
 			Element::VSlider( s ) =>
@@ -309,6 +329,7 @@ impl<Msg: Clone> Element<Msg>
 				{
 					on_change: s.on_change.clone(),
 					axis:      slider::SliderAxis::Vertical,
+					value:     s.value,
 				}
 			}
 			_ => WidgetHandlers::None,

src/widget/handlers.rs

@@ -30,9 +30,9 @@ pub enum WidgetHandlers<Msg: Clone>
 		on_escape:     Option<Msg>,
 		repeating:     bool,
 	},
-	Toggle   { on_toggle: Option<Msg> },
-	Checkbox { on_toggle: Option<Msg> },
-	Radio    { on_select: Option<Msg> },
+	Toggle   { on_toggle: Option<Msg>, value: bool },
+	Checkbox { on_toggle: Option<Msg>, value: bool },
+	Radio    { on_select: Option<Msg>, selected: bool },
 	ListItem { on_press:  Option<Msg> },
 	WindowButton { on_press: Option<Msg> },
 	TextEdit
@@ -77,6 +77,7 @@ pub enum WidgetHandlers<Msg: Clone>
 	{
 		on_change: Option<Arc<dyn Fn( f32 ) -> Msg>>,
 		axis:      slider::SliderAxis,
+		value:     f32,
 	},
 }
 
@@ -117,9 +118,9 @@ impl<Msg: Clone> Clone for WidgetHandlers<Msg>
 				on_escape:     on_escape.clone(),
 				repeating:     *repeating,
 			},
-			WidgetHandlers::Toggle   { on_toggle } => WidgetHandlers::Toggle   { on_toggle: on_toggle.clone() },
-			WidgetHandlers::Checkbox { on_toggle } => WidgetHandlers::Checkbox { on_toggle: on_toggle.clone() },
-			WidgetHandlers::Radio    { on_select } => WidgetHandlers::Radio    { on_select: on_select.clone() },
+			WidgetHandlers::Toggle   { on_toggle, value } => WidgetHandlers::Toggle   { on_toggle: on_toggle.clone(), value: *value },
+			WidgetHandlers::Checkbox { on_toggle, value } => WidgetHandlers::Checkbox { on_toggle: on_toggle.clone(), value: *value },
+			WidgetHandlers::Radio    { on_select, selected } => WidgetHandlers::Radio { on_select: on_select.clone(), selected: *selected },
 			WidgetHandlers::ListItem { on_press  } => WidgetHandlers::ListItem { on_press:  on_press.clone()  },
 			WidgetHandlers::WindowButton { on_press } => WidgetHandlers::WindowButton { on_press: on_press.clone() },
 			WidgetHandlers::TextEdit { value, on_change, on_submit, secure, multiline, align, font_size, select_on_focus, password_toggle_msg } =>
@@ -137,9 +138,9 @@ impl<Msg: Clone> Clone for WidgetHandlers<Msg>
 					password_toggle_msg: password_toggle_msg.clone(),
 				}
 			}
-			WidgetHandlers::Slider { on_change, axis } =>
+			WidgetHandlers::Slider { on_change, axis, value } =>
 			{
-				WidgetHandlers::Slider { on_change: on_change.clone(), axis: *axis }
+				WidgetHandlers::Slider { on_change: on_change.clone(), axis: *axis, value: *value }
 			}
 		}
 	}
@@ -152,6 +153,23 @@ impl<Msg: Clone> WidgetHandlers<Msg>
 		matches!( self, WidgetHandlers::TextEdit { .. } )
 	}
 
+	pub fn is_disabled( &self ) -> bool
+	{
+		match self
+		{
+			WidgetHandlers::Button   { on_press, on_long_press, on_drag_start, on_escape, .. } =>
+				on_press.is_none() && on_long_press.is_none() && on_drag_start.is_none() && on_escape.is_none(),
+			WidgetHandlers::Toggle   { on_toggle, .. } => on_toggle.is_none(),
+			WidgetHandlers::Checkbox { on_toggle, .. } => on_toggle.is_none(),
+			WidgetHandlers::Radio    { on_select, .. } => on_select.is_none(),
+			WidgetHandlers::ListItem { on_press } => on_press.is_none(),
+			WidgetHandlers::WindowButton { on_press } => on_press.is_none(),
+			WidgetHandlers::Slider   { on_change, .. } => on_change.is_none(),
+			WidgetHandlers::TextEdit { on_change, on_submit, .. } => on_change.is_none() && on_submit.is_none(),
+			WidgetHandlers::None => true,
+		}
+	}
+
 	/// `true` when this is a [`WidgetHandlers::TextEdit`] whose source
 	/// widget was built with `.multiline( true )`. The keyboard
 	/// dispatch reads this so pressing Enter inserts a `\n` instead of
@@ -185,9 +203,9 @@ impl<Msg: Clone> WidgetHandlers<Msg>
 		match self
 		{
 			WidgetHandlers::Button   { on_press, .. } => on_press.clone(),
-			WidgetHandlers::Toggle   { on_toggle } => on_toggle.clone(),
-			WidgetHandlers::Checkbox { on_toggle } => on_toggle.clone(),
-			WidgetHandlers::Radio    { on_select } => on_select.clone(),
+			WidgetHandlers::Toggle   { on_toggle, .. } => on_toggle.clone(),
+			WidgetHandlers::Checkbox { on_toggle, .. } => on_toggle.clone(),
+			WidgetHandlers::Radio    { on_select, .. } => on_select.clone(),
 			WidgetHandlers::ListItem { on_press  } => on_press.clone(),
 			WidgetHandlers::WindowButton { on_press } => on_press.clone(),
 			_                                       => None,

src/widget/laid_out.rs

@@ -34,6 +34,10 @@ pub struct LaidOutWidget<Msg: Clone>
 	/// element tree.
 	pub cursor:             crate::types::CursorShape,
 	pub tooltip:            Option<String>,
+	/// Visible text of the widget, captured for the accessibility
+	/// tree. `None` for non-textual widgets (icons, dividers).
+	pub accessible_label:   Option<String>,
+	pub is_live_region:     bool,
 }
 
 impl<Msg: Clone> Clone for LaidOutWidget<Msg>
@@ -50,6 +54,8 @@ impl<Msg: Clone> Clone for LaidOutWidget<Msg>
 			keyboard_focusable: self.keyboard_focusable,
 			cursor:             self.cursor,
 			tooltip:            self.tooltip.clone(),
+			accessible_label:   self.accessible_label.clone(),
+			is_live_region:     self.is_live_region,
 		}
 	}
 }

src/widget/scroll/mod.rs

@@ -8,7 +8,36 @@ use crate::widget::Element;
 #[cfg(test)]
 mod tests;
 
-/// A vertically scrollable viewport that clips its child to its allocated rect.
+/// Which axes a [`Scroll`] viewport allows to move along. Determines
+/// whether the layout grows the child past the viewport width, the
+/// viewport height, or both, and which axis gesture / wheel deltas
+/// route to.
+///
+/// `Vertical` is the default (matches the historic behaviour) so
+/// existing call sites do not need a builder call to migrate.
+#[ derive( Clone, Copy, Debug, PartialEq, Eq ) ]
+pub enum ScrollAxis
+{
+	/// Standard list-style scroll: child grows vertically, child width
+	/// is clamped to the viewport.
+	Vertical,
+	/// Strip / timeline scroll: child grows horizontally, child height
+	/// is clamped to the viewport.
+	Horizontal,
+	/// Two-axis pan (large tables, code views, maps). Child may exceed
+	/// the viewport on either axis.
+	Both,
+}
+
+impl ScrollAxis
+{
+	#[ inline ]
+	pub fn allows_x( self ) -> bool { matches!( self, ScrollAxis::Horizontal | ScrollAxis::Both ) }
+	#[ inline ]
+	pub fn allows_y( self ) -> bool { matches!( self, ScrollAxis::Vertical   | ScrollAxis::Both ) }
+}
+
+/// A scrollable viewport that clips its child to its allocated rect.
 ///
 /// The child can be any element — typically a [`Column`](crate::layout::column::Column)
 /// for lists or a [`WrapGrid`](crate::layout::wrap_grid::WrapGrid) for icon grids.
@@ -35,6 +64,8 @@ pub struct Scroll<Msg: Clone>
 	pub child: Box<Element<Msg>>,
 	/// Optional stable identifier — used as scroll state key.
 	pub id:    Option<WidgetId>,
+	/// Which axis (or both) this viewport scrolls along.
+	pub axis:  ScrollAxis,
 }
 
 impl<Msg: Clone> Scroll<Msg>
@@ -46,9 +77,25 @@ impl<Msg: Clone> Scroll<Msg>
 		self
 	}
 
+	/// Switch this viewport to horizontal scrolling. The child is laid
+	/// out at its preferred width (potentially larger than the
+	/// viewport) and clipped on the X axis.
+	pub fn horizontal( mut self ) -> Self
+	{
+		self.axis = ScrollAxis::Horizontal;
+		self
+	}
+
+	/// Allow both axes. Use for tables / code views / maps.
+	pub fn both( mut self ) -> Self
+	{
+		self.axis = ScrollAxis::Both;
+		self
+	}
+
 	/// Returns `(max_width, 0.0)` — the Scroll node claims all remaining space in
 	/// the parent layout, exactly like a [`Spacer`](crate::layout::spacer::Spacer).
-	/// The actual viewport height is determined at render time from the rect the
+	/// The actual viewport size is determined at render time from the rect the
 	/// parent assigns.
 	pub fn preferred_size( &self, max_width: f32, _canvas: &Canvas ) -> (f32, f32)
 	{
@@ -67,6 +114,7 @@ impl<Msg: Clone> Scroll<Msg>
 		{
 			child: Box::new( self.child.map_arc( f ) ),
 			id:    self.id,
+			axis:  self.axis,
 		}
 	}
 }
@@ -79,19 +127,24 @@ impl<Msg: Clone + 'static> From<Scroll<Msg>> for Element<Msg>
 	}
 }
 
-/// Compute the clamped scroll offset given raw offset, content height, and viewport height.
+/// Clamp a raw 1-D scroll offset to `[0, max(content - viewport, 0)]`.
 ///
-/// Extracted as a pure function so it can be unit-tested without a Wayland surface.
+/// Extracted as a pure function so it can be unit-tested without a
+/// Wayland surface. Used for both axes by passing in the relevant
+/// content / viewport dimensions.
 pub(crate) fn clamp_offset( offset: f32, content_h: f32, viewport_h: f32 ) -> f32
 {
 	let max = (content_h - viewport_h).max( 0.0 );
 	offset.clamp( 0.0, max )
 }
 
-/// Create a scrollable viewport wrapping `child`.
+/// Create a scrollable viewport wrapping `child`. Defaults to vertical
+/// scrolling; chain [`Scroll::horizontal`] or [`Scroll::both`] to
+/// switch axes.
 ///
-/// The parent layout controls the viewport size by assigning a rect to this widget.
-/// Content that overflows vertically is scrolled via drag gesture.
+/// The parent layout controls the viewport size by assigning a rect to
+/// this widget. Content that overflows along the allowed axis is
+/// scrolled via drag gestures or the scroll wheel.
 ///
 /// ```rust,no_run
 /// # use ltk::{ column, scroll, text, Element };
@@ -103,5 +156,5 @@ pub(crate) fn clamp_offset( offset: f32, content_h: f32, viewport_h: f32 ) -> f3
 /// ```
 pub fn scroll<Msg: Clone>( child: impl Into<Element<Msg>> ) -> Scroll<Msg>
 {
-	Scroll { child: Box::new( child.into() ), id: None }
+	Scroll { child: Box::new( child.into() ), id: None, axis: ScrollAxis::Vertical }
 }