zaxis 0.0.1

An event-driven immediate mode GUI for desktop tools
Documentation
use super::*;

impl TextEdit<'_> {
    pub(super) fn process_events(
        &mut self,
        ui: &mut Ui<'_>,
        state: &mut TextEditState,
        response: &mut Response,
        events: Vec<TextEditInput>,
        inner: Rect,
        size: f32,
    ) {
        for event in events {
            if self.enabled
                && (state.preedit.is_none()
                    || matches!(
                        event,
                        TextEditInput::Focus(_) | TextEditInput::Key(KeyCode::Escape, _)
                    ))
            {
                if let Some(handler) = &mut self.event_handler {
                    let previous = self.text.clone();
                    let handled = handler(self.text, &event);
                    if previous != *self.text {
                        state.buffer.select_all(self.text);
                        state.history = EditHistory::default();
                    }
                    if handled {
                        if matches!(event, TextEditInput::Key(KeyCode::Escape, _)) {
                            state.preedit = None;
                        }
                        continue;
                    }
                }
            }
            let previous = self.text.clone();
            let previous_buffer = state.buffer.clone();
            let typing = matches!(&event, TextEditInput::Text(text)
                if state.preedit.is_none() && previous_buffer.selection().is_empty()
                    && text.graphemes(true).count() == 1 && !text.chars().any(char::is_control));
            let restoring = matches!(&event, TextEditInput::Key(key, mods)
                if (mods.control_key() || mods.super_key())
                    && matches!(key, KeyCode::KeyZ | KeyCode::KeyY));
            let interrupts_typing = match &event {
                TextEditInput::Key(key, mods) => {
                    mods.control_key()
                        || mods.super_key()
                        || matches!(
                            key,
                            KeyCode::ArrowLeft
                                | KeyCode::ArrowRight
                                | KeyCode::ArrowUp
                                | KeyCode::ArrowDown
                                | KeyCode::Home
                                | KeyCode::End
                                | KeyCode::Backspace
                                | KeyCode::Delete
                                | KeyCode::Enter
                                | KeyCode::NumpadEnter
                                | KeyCode::Escape
                        )
                }
                _ => !typing,
            };
            if interrupts_typing {
                state.history.break_group();
            }
            match event {
                TextEditInput::Focus(false) => {
                    response.lost_focus = true;
                    state.preedit = None;
                }
                TextEditInput::Focus(true) => {}
                _ if !self.enabled => {}
                TextEditInput::Text(text) | TextEditInput::Commit(text) if !self.read_only => {
                    state.preedit = None;
                    let text = single_line(&text);
                    if !text.is_empty() {
                        state.buffer.insert(self.text, &text);
                    }
                }
                TextEditInput::Preedit(text, cursor) if !self.read_only => {
                    state.preedit = (!text.is_empty()).then_some((single_line(&text), cursor));
                }
                TextEditInput::Pointer(pointer, extend, count) => {
                    state.preedit = None;
                    let points = positions(ui, self.text, size);
                    let x = pointer.x - inner.min.x + state.scroll;
                    let cursor = points
                        .iter()
                        .min_by(|a, b| (a.1 - x).abs().total_cmp(&(b.1 - x).abs()))
                        .map_or(0, |p| p.0);
                    let word_cursor = points
                        .iter()
                        .rev()
                        .find(|(_, px)| *px <= x)
                        .map_or(0, |p| p.0);
                    match count {
                        2 => {
                            let word = word_at(self.text, word_cursor);
                            state.buffer.anchor = word.start;
                            state.buffer.cursor = word.end;
                            state.word_drag = Some(word);
                        }
                        3 => {
                            state.buffer.select_all(self.text);
                            state.word_drag = Some(0..self.text.len());
                        }
                        0 if state.word_drag.is_some() => {
                            let anchor = state.word_drag.as_ref().unwrap();
                            let word = word_at(self.text, word_cursor);
                            if word.start < anchor.start {
                                state.buffer.anchor = anchor.end;
                                state.buffer.cursor = word.start;
                            } else {
                                state.buffer.anchor = anchor.start;
                                state.buffer.cursor = word.end.max(anchor.end);
                            }
                        }
                        _ => {
                            state.word_drag = None;
                            state.buffer.set_cursor(cursor, extend);
                        }
                    }
                }
                TextEditInput::Key(key, modifiers) if state.preedit.is_none() => {
                    let command = modifiers.control_key() || modifiers.super_key();
                    match key {
                        KeyCode::KeyZ | KeyCode::KeyY if command && !self.read_only => {
                            let redo = key == KeyCode::KeyY || modifiers.shift_key();
                            state.history.restore(self.text, &mut state.buffer, redo);
                            state.word_drag = None;
                        }
                        KeyCode::Enter | KeyCode::NumpadEnter => response.submitted = true,
                        KeyCode::KeyC | KeyCode::KeyX if command => {
                            let range = state.buffer.selection();
                            if !range.is_empty()
                                && ui.context.copy_text(self.text[range].to_owned()).is_ok()
                                && key == KeyCode::KeyX
                                && !self.read_only
                            {
                                state.buffer.insert(self.text, "");
                            }
                        }
                        KeyCode::KeyV if command && !self.read_only => {
                            if let Ok(text) = ui.context.clipboard_text() {
                                let text = single_line(&text);
                                if !text.is_empty() {
                                    state.buffer.insert(self.text, &text);
                                }
                            }
                        }
                        _ => state.buffer.key(self.text, key, modifiers, self.read_only),
                    }
                }
                _ => {}
            }
            if previous != *self.text && !restoring {
                state.history.record(previous, previous_buffer, typing);
                state.word_drag = None;
            }
        }
    }
}