Enum Ime 

pub enum Ime<'a> {
    Enabled,
    Disabled,
    Preedit {
        text: &'a str,
        cursor: Option<(usize, usize)>,
    },
    Commit {
        text: &'a str,
    },
    DeleteSurrounding {
        before_bytes: usize,
        after_bytes: usize,
    },
}

Input Method Editor events

This enum describes input method events.

This enum closely follows the specification of winit::event::Ime, hence its documentation may prove useful.

Variants

Enabled

Notifies when the IME was enabled.

This may mean, for example, that a virtual keyboard is now active with focus on the recipient. This event does not mean that physical keyboard input is disabled (or that it should be ignored).

The widget should call EventState::set_ime_cursor_area immediately and each time the area changes (relative to the widget’s coordinate space), until Ime::Disabled is received. Failure to do so will result in the widget’s entire rect being used as the IME cursor area.

Disabled

Notifies when the IME was disabled.

Any pending (uncommitted) pre-edit should be cleared (cancelled).

Preedit

Notifies when a new composing text should be set at the cursor position.

When text.is_empty() the pre-edit was cleared. Synthetic events with empty text and cursor: None are generated immediately before an Ime::Commit event.

cursor represents the selection-start and cursor indices within text. If cursor.is_none() then no cursor should be shown.

Fields

text: &'a str

cursor: Option<(usize, usize)>

Commit

Notifies when text should be inserted into the editor widget.

Right before this event winit will send empty Self::Preedit event.

Fields

text: &'a str

DeleteSurrounding

Delete text surrounding the cursor or selection.

This event does not affect the pre-edit string.

Fields

before_bytes: usize

Bytes to remove before the selection

Assuming the selection starts at s (or the cursor is at s with an empty selection), bytes in the range s - before_bytes .. s should be deleted.

after_bytes: usize

Bytes to remove after the selection

Assuming the selection ends at c, bytes in the range c .. c + after_bytes should be deleted.

Trait Implementations

impl<'a> Clone for Ime<'a>

fn clone(&self) -> Ime<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Ime<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Hash for Ime<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for Ime<'a>

fn eq(&self, other: &Ime<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for Ime<'a>

impl<'a> StructuralPartialEq for Ime<'a>