Enum InputMethod

pub enum InputMethod<T = String> {
    Disabled,
    Enabled {
        position: Point,
        purpose: Purpose,
        preedit: Option<Preedit<T>>,
    },
}

The input method strategy of a widget.

Variants

Disabled

Input method is disabled.

Enabled

Input method is enabled.

Fields

position: Point

The position at which the input method dialog should be placed.

purpose: Purpose

The Purpose of the input method.

preedit: Option<Preedit<T>>

The preedit to overlay on top of the input method dialog, if needed.

Ideally, your widget will show pre-edits on-the-spot; but, since that can be tricky, you can instead provide the current pre-edit here and the runtime will display it as an overlay (i.e. “Over-the-spot IME”).

Implementations

impl InputMethod

pub fn merge<T: AsRef<str>>(&mut self, other: &InputMethod<T>)

Merges two InputMethod strategies, prioritizing the first one when both open:

let open = InputMethod::Enabled {
    position: Point::ORIGIN,
    purpose: Purpose::Normal,
    preedit: Some(Preedit { content: "1".to_owned(), selection: None, text_size: None }),
};

let open_2 = InputMethod::Enabled {
    position: Point::ORIGIN,
    purpose: Purpose::Secure,
    preedit: Some(Preedit { content: "2".to_owned(), selection: None, text_size: None }),
};

let mut ime = InputMethod::Disabled;

ime.merge(&open);
assert_eq!(ime, open);

ime.merge(&open_2);
assert_eq!(ime, open);

pub fn is_enabled(&self) -> bool

Returns true if the InputMethod is open.

impl<T> InputMethod<T>

pub fn to_owned(&self) -> InputMethod

where T: AsRef<str>,

Turns an InputMethod into its owned version.

Trait Implementations

impl<T: Clone> Clone for InputMethod<T>

fn clone(&self) -> InputMethod<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for InputMethod<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for InputMethod<T>

fn eq(&self, other: &InputMethod<T>) -> 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<T> StructuralPartialEq for InputMethod<T>