The primary selection is kept in step with other applications, an application can paste either selection and hear the middle button, raw keys carry the text dead keys compose, and an application can ask for a cursor where the pointer is

A terminal drawn by the application itself needed four things ltk did not give it: the selection the middle button pastes, a way to read the clipboard, the text a key types once dead keys are applied, and a text cursor over its text area that does not hide the window's resize cursors. Text fields gain the primary selection along the way, and the symbol fallback and a missed field in the previous commit are fixed.
The primary selection. `event_loop/primary_selection.rs` binds `zwp_primary_selection_device_manager_v1` when the compositor offers it, creates the device with the data device in `new_seat`, and holds the manager, the device, our source while we own the selection, its text and the inbox the reader threads post to. A selection offered by another client is read on a thread of its own as the clipboard is; a peer asking for ours is served from the cached text, and a cancelled source is dropped. `data_device.rs` gives both the pieces they share: `pick_text_mime`, `read_selection` and `write_selection`, so the clipboard behaves as before.
Text fields. Once a press ends, `sync_text_field` publishes a new selection in the focused text field as the primary selection; password fields never publish theirs. It remembers what it last published rather than comparing with the current primary selection, so a selection made in another application is not taken back. A middle-button press on a text field focuses it, puts the cursor where it landed and inserts the primary selection there.
The application's side. `App::take_primary_request` makes a text the primary selection, as `take_clipboard_request` does for the clipboard. `App::take_paste_request` names a `SelectionKind`, `Clipboard` or `Primary`, and the runtime answers with `App::on_paste` and that selection's text, never with an empty one. `App::on_pointer_middle` reports a middle-button press anywhere but on a text field. All default to doing nothing.
Raw keys. `App::on_raw_key_with_alt` gives way to `App::on_raw_key_event`, which takes a `RawKey` with the keysym, the keycode, the press, Ctrl, Shift and Alt, and `text`: what sctk reports the key types once dead keys and compose sequences are applied, `None` on release, halfway through a sequence and for keys that type nothing. A terminal that took the character from the keysym typed `a` for an acute accent followed by `a`. The default still forwards to `on_raw_key`, and prompt was the only application overriding the old hook. Every key press now also records its serial in `last_input_serial`, so a selection set from a keyboard shortcut carries a serial a strict compositor accepts rather than the last click's.
The cursor. `App::cursor_at( x, y )` is the cursor the application wants at a point of the main surface. It comes after the resize edges and `cursor_override`, and before the cursor of the widget under the pointer, so a terminal shows the text cursor over its cells and the resize cursors still show at the window's edges, which a `cursor_override` would hide.
Fonts. Noto Sans Symbols 2 and Noto Sans Symbols follow DejaVu Sans in the fallback chain, for the media controls, arrows and shapes DejaVu lacks, which drew as the missing glyph.
`TextEdit::map_msg` now carries `pad_h` over: the previous commit added the field but left it out there, and ltk did not build.

src/event_loop/data_device.rs

@@ -34,8 +34,9 @@ use std::io::Read;
 use std::sync::mpsc;
 
 use smithay_client_toolkit::data_device_manager::data_device::{ DataDeviceData, DataDeviceHandler };
-use smithay_client_toolkit::data_device_manager::data_offer::{ DataOfferHandler, DragOffer, SelectionOffer };
+use smithay_client_toolkit::data_device_manager::data_offer::{ DataOfferHandler, DragOffer };
 use smithay_client_toolkit::data_device_manager::data_source::DataSourceHandler;
+use smithay_client_toolkit::data_device_manager::{ ReadPipe, WritePipe };
 use smithay_client_toolkit::reexports::client::
 {
 	protocol::
@@ -167,23 +168,40 @@ impl<A: App> DataDeviceHandler for AppData<A>
 	{
 		let Some( data ) = data_device.data::<DataDeviceData>() else { return };
 		let Some( offer ) = data.selection_offer() else { return };
-		let Some( mime )  = pick_mime( &offer ) else { return };
+		let Some( mime )  = offer.with_mime_types( pick_text_mime ) else { return };
 		let Ok( pipe )    = offer.receive( mime ) else { return };
-		let tx            = self.clipboard_inbox_tx.clone();
-		std::thread::spawn( move ||
-		{
-			let mut reader = std::fs::File::from( std::os::fd::OwnedFd::from( pipe ) );
-			let mut buf    = String::new();
-			// 16 MiB cap. Compositors are free to keep typing into the
-			// pipe forever; a runaway selection should not exhaust
-			// memory or stall the worker thread indefinitely.
-			let mut bounded = (&mut reader).take( 16 * 1024 * 1024 );
-			let _ = bounded.read_to_string( &mut buf );
-			let _ = tx.send( buf );
-		} );
+		read_selection( pipe, self.clipboard_inbox_tx.clone() );
 	}
 }
 
+/// Drain an offered selection on a thread of its own and post the text to `tx`.
+pub( super ) fn read_selection( pipe: ReadPipe, tx: mpsc::Sender<String> )
+{
+	std::thread::spawn( move ||
+	{
+		let mut reader = std::fs::File::from( std::os::fd::OwnedFd::from( pipe ) );
+		let mut buf    = String::new();
+		// 16 MiB cap. Compositors are free to keep typing into the
+		// pipe forever; a runaway selection should not exhaust
+		// memory or stall the worker thread indefinitely.
+		let mut bounded = (&mut reader).take( 16 * 1024 * 1024 );
+		let _ = bounded.read_to_string( &mut buf );
+		let _ = tx.send( buf );
+	} );
+}
+
+/// Serve `text` to the peer that asked for one of our selections.
+pub( super ) fn write_selection( pipe: WritePipe, text: &str )
+{
+	// SCTK's `WritePipe` derefs to `OwnedFd`; convert to a `File`
+	// (no buffering — selection payloads are small). Errors (peer
+	// closed early, broken pipe) are ignored: we cannot recover and
+	// the compositor will issue a fresh source on the next copy anyway.
+	use std::io::Write;
+	let mut writer = std::fs::File::from( std::os::fd::OwnedFd::from( pipe ) );
+	let _ = writer.write_all( text.as_bytes() );
+}
+
 impl<A: App> DataOfferHandler for AppData<A>
 {
 	fn source_actions( &mut self, _c: &Connection, _qh: &QueueHandle<Self>, _offer: &mut DragOffer, _actions: DndAction ) {}
@@ -194,7 +212,7 @@ impl<A: App> DataSourceHandler for AppData<A>
 {
 	fn accept_mime( &mut self, _c: &Connection, _qh: &QueueHandle<Self>, _source: &WlDataSource, _mime: Option<String> ) {}
 
-	fn send_request( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, source: &WlDataSource, _mime: String, fd: smithay_client_toolkit::data_device_manager::WritePipe )
+	fn send_request( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, source: &WlDataSource, _mime: String, fd: WritePipe )
 	{
 		// Only honour requests for our own active source — if a stale
 		// source is still hanging around (e.g. between a new copy and
@@ -205,14 +223,7 @@ impl<A: App> DataSourceHandler for AppData<A>
 			.map( |s| s.inner() == source )
 			.unwrap_or( false );
 		if !is_active { return; }
-		// SCTK's `WritePipe` derefs to `OwnedFd`; convert to a `File`
-		// (no buffering — selection payloads are small) and write the
-		// cached clipboard string. Errors (peer closed early, broken
-		// pipe) are ignored: we cannot recover and the compositor
-		// will issue a fresh source on the next copy anyway.
-		use std::io::Write;
-		let mut writer = std::fs::File::from( std::os::fd::OwnedFd::from( fd ) );
-		let _ = writer.write_all( self.clipboard.as_bytes() );
+		write_selection( fd, &self.clipboard );
 	}
 
 	fn cancelled( &mut self, _c: &Connection, _qh: &QueueHandle<Self>, source: &WlDataSource )
@@ -231,12 +242,11 @@ impl<A: App> DataSourceHandler for AppData<A>
 	fn action( &mut self, _c: &Connection, _qh: &QueueHandle<Self>, _source: &WlDataSource, _action: DndAction ) {}
 }
 
-/// Pick the best-supported MIME type from a selection offer. Order
-/// matches `CLIPBOARD_MIMES` — UTF-8 first, then plain text, then
-/// the legacy `UTF8_STRING`.
-fn pick_mime( offer: &SelectionOffer ) -> Option<String>
+/// Pick the best-supported MIME type from those a selection offers.
+/// Order matches `CLIPBOARD_MIMES` — UTF-8 first, then plain text,
+/// then the legacy `UTF8_STRING`.
+pub( super ) fn pick_text_mime( mimes: &[ String ] ) -> Option<String>
 {
-	let mimes = offer.with_mime_types( |m| m.to_vec() );
 	CLIPBOARD_MIMES.iter()
 		.find( |c| mimes.iter().any( |m| m == *c ) )
 		.map( |s| s.to_string() )