Use x11rb for event handling

[notgull]

• Tested on all platforms changed
• Added an entry to CHANGELOG.md if knowledge of this change could be valuable to users
• Updated documentation to reflect any user-facing changes, including notes of platform-specific behavior
• Created or updated an example program if it would help users understand this functionality
• Updated feature matrix, if new features were added or implemented

Switches out the previous event handling logic for x11rb-based logic. The last large hurdle before getting rid of Xlib. As part of the process, also gets rid of Xlib's IME and replaces it with the xim crate.

Draft because I have not tested this in the slightest.

[notgull]

Event handling functionality looks sound to me. I haven't tested IME yet.

[notgull]

Tested IME on Fedora 38

[notgull]

@Riey Can you review this and make sure I'm using XIM right?

[Riey]

@notgull Is there an example code to check preedit and position?

[notgull]

I'm not sure what you're asking for, but here is the code responsible for handling pre-edits:

winit/src/platform_impl/linux/x11/ime.rs

Lines 648 to 767 in 46bb9e5

	fn handle_preedit_start(
	&mut self,
	_client: &mut C,
	input_method_id: u16,
	input_context_id: u16,
	) -> Result<(), ClientError> {
	debug_assert_eq!(self.input_method, Some(input_method_id));
	if let Some(ic_data) = self.input_contexts.get_mut(&input_context_id) {
	// Start a pre-edit.
	ic_data.text.clear();
	ic_data.cursor = 0;
	// Indicate the start.
	self.ime_events
	.push_back((ic_data.window.id, ImeEvent::Start));
	}
	Ok(())
	}
	fn handle_preedit_draw(
	&mut self,
	_client: &mut C,
	input_method_id: u16,
	input_context_id: u16,
	caret: i32,
	chg_first: i32,
	chg_len: i32,
	_status: xim::PreeditDrawStatus,
	preedit_string: &str,
	_feedbacks: Vec<xim::Feedback>,
	) -> Result<(), ClientError> {
	debug_assert_eq!(self.input_method, Some(input_method_id));
	if let Some(ic_data) = self.input_contexts.get_mut(&input_context_id) {
	// Set the cursor.
	ic_data.cursor = caret as usize;
	// Figure out the range of text to change.
	let change_range = chg_first as usize..(chg_first + chg_len) as usize;
	// If the range doesn't fit our current text, warn and return.
	if change_range.start > ic_data.text.len() || change_range.end > ic_data.text.len() {
	warn!(
	"Preedit draw range {}..{} doesn't fit text of length {}",
	change_range.start,
	change_range.end,
	ic_data.text.len()
	);
	return Ok(());
	}
	// Update the text in the changed range.
	{
	let text = &mut ic_data.text;
	let mut old_text_tail = text.split_off(change_range.end);
	text.truncate(change_range.start);
	text.extend(preedit_string.chars());
	text.append(&mut old_text_tail);
	}
	// Send the event.
	let cursor_byte_pos = calc_byte_position(&ic_data.text, ic_data.cursor);
	let event = ImeEvent::Update(ic_data.text.iter().collect(), Some(cursor_byte_pos));
	self.ime_events.push_back((ic_data.window.id, event));
	}
	Ok(())
	}
	fn handle_preedit_caret(
	&mut self,
	_client: &mut C,
	input_method_id: u16,
	input_context_id: u16,
	position: &mut i32,
	direction: xim::CaretDirection,
	_style: xim::CaretStyle,
	) -> Result<(), ClientError> {
	// We only care about absolute position.
	if matches!(direction, xim::CaretDirection::AbsolutePosition) {
	debug_assert_eq!(self.input_method, Some(input_method_id));
	if let Some(ic_data) = self.input_contexts.get_mut(&input_context_id) {
	ic_data.cursor = *position as usize;
	// Send the event
	let event =
	ImeEvent::Update(ic_data.text.iter().collect(), Some(*position as usize));
	self.ime_events.push_back((ic_data.window.id, event));
	}
	}
	Ok(())
	}
	fn handle_preedit_done(
	&mut self,
	_client: &mut C,
	input_method_id: u16,
	input_context_id: u16,
	) -> Result<(), ClientError> {
	debug_assert_eq!(self.input_method, Some(input_method_id));
	// Get the client data.
	if let Some(ic_data) = self.input_contexts.get_mut(&input_context_id) {
	// We're done with a preedit.
	ic_data.text.clear();
	ic_data.cursor = 0;
	// Send a message to the window.
	let window = ic_data.window.id;
	self.ime_events.push_back((window, ImeEvent::End));
	}
	Ok(())
	}

[kchibisov]

you can also, always try to do things with alacritty if you want to test with typing experience.

[Riey]

LGTM.

[psychon]

Since the commit message for this one says

I don't know what this actually does, but it can't hurt, right?

"Normally", all events and errors go through Xlib. It does some gymnastics internally to ensure that before the reply for a request is handled, everything that happens before is done: Events are in its internal event queue and errors were passed to the error handler. This has the effect of removing all events/errors from XCB's queue.

Thus, normally you cannot use xcb_poll/wait_for_event() when Xlib is involved, since Xlib might already have "eaten" an event and put it into its own queue.

The call you are doing here just tells Xlib "do not mess with the event queue, kthxbye". It still will use the flag XCB_REQUEST_CHECKED flags when sending requests to that any errors caused "through" Xlib are reported to Xlib via xcb_wait_for_reply() and do not end up in XCB's event queue, but it will no longer call xcb_poll_for_event() or xcb_wait_for_event().

[notgull]

Great, thanks for clarifying! Yeah I figured it was somehow telling Xlib to not interfere with libxcb. Glad to confirm it.

[psychon]

I came here for another reason, but then noticed this bit. I think this is wrong.

The old code does:

if event_type == self.randr_event_offset as c_int {

Imagine a + 0 in there and check that "event zero" from randr is RRScreenChangeNotify: https://docs.rs/x11-dl/latest/x11_dl/xrandr/constant.RRScreenChangeNotify.html

RandrNotify is event 1: https://docs.rs/x11-dl/latest/x11_dl/xrandr/constant.RRNotify.html

[notgull]

Closing as per chat discussion