functora-egui 0.2.0

shadcn/ui-inspired widget library for egui - buttons, inputs, selects, dialogs, and 70+ more components with light/dark theming
Documentation
use std::sync::{Mutex, PoisonError};

use android_activity::AndroidApp;
use android_activity::input::{TextInputState, TextSpan};

static APP: Mutex<Option<AndroidApp>> = Mutex::new(None);

struct ImeTracker {
    last: Option<TextInputState>,
    last_focused: Option<egui::Id>,
    last_wants: bool,
}

static TRACKER: Mutex<ImeTracker> = Mutex::new(ImeTracker {
    last: None,
    last_focused: None,
    last_wants: false,
});

pub fn store_app(app: AndroidApp) {
    _ = APP
        .lock()
        .unwrap_or_else(PoisonError::into_inner)
        .replace(app);
}

pub fn poll_ime(ctx: &egui::Context) {
    let guard = APP.lock().unwrap_or_else(PoisonError::into_inner);
    let Some(app) = guard.as_ref() else { return };
    let focused = ctx.memory(egui::Memory::focused);
    let wants = ctx.egui_wants_keyboard_input();
    let mut tracker = TRACKER.lock().unwrap_or_else(PoisonError::into_inner);
    let focused_changed = tracker.last_focused != focused;
    let wants_changed = tracker.last_wants != wants;
    if focused_changed || wants_changed {
        let prev_wants = tracker.last_wants;
        tracker.last_focused = focused;
        tracker.last_wants = wants;
        if wants && !prev_wants {
            app.set_text_input_state(TextInputState::default());
            app.show_soft_input(false);
            tracker.last = None;
            ctx.input_mut(|input| input.events.push(preedit(&[])));
        } else if !wants && prev_wants {
            app.set_text_input_state(TextInputState::default());
            app.hide_soft_input(false);
            tracker.last = None;
            ctx.input_mut(|input| input.events.push(preedit(&[])));
        } else if wants {
            app.set_text_input_state(TextInputState::default());
            app.show_soft_input(false);
            tracker.last = None;
            ctx.input_mut(|input| input.events.push(preedit(&[])));
        }
        ctx.request_repaint();
        return;
    }
    let state = app.text_input_state();
    let prev = tracker.last.replace(state.clone()).unwrap_or_default();
    let unchanged = prev.text == state.text
        && prev.compose_region.map(|s| (s.start, s.end))
            == state.compose_region.map(|s| (s.start, s.end));
    if unchanged {
        if tracker.last_wants {
            ctx.request_repaint();
        }
        return;
    }
    let mut changed = false;
    ctx.input_mut(|input| changed = sync_ime(&prev, &state, &mut input.events));
    if changed {
        ctx.request_repaint();
    }
}

fn sync_ime(prev: &TextInputState, cur: &TextInputState, events: &mut Vec<egui::Event>) -> bool {
    let prev_chars: Vec<char> = prev.text.chars().collect();
    let cur_chars: Vec<char> = cur.text.chars().collect();
    let prev_committed = committed(&prev_chars, prev.compose_region);
    let cur_committed = committed(&cur_chars, cur.compose_region);
    let prev_composing = composing(&prev_chars, prev.compose_region);
    let cur_composing = composing(&cur_chars, cur.compose_region);
    let mut changed = false;
    if prev_composing.is_empty() || !cur_composing.is_empty() {
        if let Some(extra) = extra(prev_committed, cur_committed) {
            if !extra.is_empty() {
                events.push(egui::Event::Text(extra.iter().collect()));
                changed = true;
            }
        } else if prev_composing.is_empty()
            && cur_composing.is_empty()
            && cur_committed.len() < prev_committed.len()
            && !cur.text.is_empty()
        {
            events.push(egui::Event::Ime(egui::ImeEvent::DeleteSurrounding {
                before_chars: prev_committed.len() - cur_committed.len(),
                after_chars: 0,
            }));
            changed = true;
        }
    }
    match (prev_composing.is_empty(), cur_composing.is_empty()) {
        (_, false)
            if prev_composing.is_empty()
                || prev_committed != cur_committed
                || prev_composing != cur_composing =>
        {
            events.push(preedit(cur_composing));
            changed = true;
        }
        (false, true) => {
            if let Some(extra) = extra(prev_committed, cur_committed) {
                let commit: String = extra.iter().collect();
                if commit.is_empty() {
                    events.push(preedit(&[]));
                } else {
                    events.push(egui::Event::Ime(egui::ImeEvent::Commit(commit)));
                }
            } else {
                events.push(preedit(&[]));
                if cur_committed.len() < prev_committed.len() && !cur.text.is_empty() {
                    events.push(egui::Event::Ime(egui::ImeEvent::DeleteSurrounding {
                        before_chars: prev_committed.len() - cur_committed.len(),
                        after_chars: 0,
                    }));
                }
            }
            changed = true;
        }
        (true, _) | (false, false) => {}
    }
    changed
}

fn committed(text: &[char], compose: Option<TextSpan>) -> &[char] {
    let end = compose
        .map_or(text.len(), |span| span.start)
        .min(text.len());
    &text[..end]
}

fn composing(text: &[char], compose: Option<TextSpan>) -> &[char] {
    let Some(span) = compose else { return &[] };
    let start = span.start.min(text.len());
    let end = span.end.clamp(start, text.len());
    &text[start..end]
}

fn extra<'a>(prev: &'a [char], cur: &'a [char]) -> Option<&'a [char]> {
    cur.strip_prefix(prev)
}

fn preedit(chars: &[char]) -> egui::Event {
    egui::Event::Ime(egui::ImeEvent::Preedit {
        text: chars.iter().collect(),
        active_range_chars: None,
    })
}