Struct ImeClient 

pub struct ImeClient { /* private fields */ }

Input Method Editor (IME) client.

ImeClient represents one instance of an Input Method Editor client. It provides callbacks for event handling as well as control over the position of the IME window. There should be only one IME client per application and it is advised to create at most one instance.

Implementations

impl ImeClient

pub fn set_logger<F>(f: F)

where F: for<'a> FnMut(&'a str) + Send + 'static,

Set the global logger for xcb-imdkit.

The callback will receive debug messages from the C library this crate is wrapping.

Examples found in repository

examples/example.rs (line 45)

fn main() {
    let (connection, screen_default_nbr) = xcb::Connection::connect(None).unwrap();
    let connection = Arc::new(connection);
    let screen = connection
        .get_setup()
        .roots()
        .nth(screen_default_nbr as usize)
        .unwrap();

    ImeClient::set_logger(|msg| println!("Log: {}", msg));
    let mut ime = ImeClient::new(
        connection.clone(),
        screen_default_nbr,
        InputStyle::PREEDIT_CALLBACKS,
        None,
    );
    ime.set_commit_string_cb(|win, input| println!("Win {}, got: {}", win, input));
    ime.set_forward_event_cb(|win, e| {
        dbg!(
            win,
            e.response_type(),
            e.detail(),
            e.time(),
            e.root(),
            e.event(),
            e.child(),
            e.root_x(),
            e.root_y(),
            e.event_x(),
            e.event_y(),
            e.state(),
            e.same_screen(),
        );
    });
    ime.set_preedit_draw_cb(|win, info| {
        dbg!(win, info);
    });

    let mut wins = vec![];
    for _ in 0..3 {
        wins.push(create_window(connection.clone(), &screen));
    }

    let mut focus_win = wins[0];
    let mut n = 0;
    loop {
        let event = connection.wait_for_event();
        if event.is_none() {
            break;
        }
        let event = event.unwrap();
        dbg!(event.response_type());

        let event_type = event.response_type() & !0x80;
        if xcb::FOCUS_IN == event_type {
            let event: &xcb::FocusInEvent = unsafe { xcb::cast_event(&event) };
            focus_win = event.event();
            ime.update_pos(focus_win, 0, 0);
        }

        if xcb::CONFIGURE_NOTIFY == event_type {
            ime.update_pos(focus_win, 0, 0);
        }

        println!(">>>>{}>>>>", n);
        ime.process_event(&event);
        println!("<<<<{}<<<<", n);
        n += 1;
    }
}

pub fn new( conn: Arc<Connection>, screen_id: i32, input_style: InputStyle, im_name: Option<&str>, ) -> Pin<Box<Self>>

Create a new ImeClient.

The first two arguments correspond to the result of xcb::Connection::connect with the connection wrapped into an Arc to ensure that the Ime does not outlive its connection. For documentation on input_style refer to InputStyle. im_name can be used to specify a custom IME server to connect to using the syntax @im=custom_server.

Examples found in repository

examples/example.rs (lines 46-51)

fn main() {
    let (connection, screen_default_nbr) = xcb::Connection::connect(None).unwrap();
    let connection = Arc::new(connection);
    let screen = connection
        .get_setup()
        .roots()
        .nth(screen_default_nbr as usize)
        .unwrap();

    ImeClient::set_logger(|msg| println!("Log: {}", msg));
    let mut ime = ImeClient::new(
        connection.clone(),
        screen_default_nbr,
        InputStyle::PREEDIT_CALLBACKS,
        None,
    );
    ime.set_commit_string_cb(|win, input| println!("Win {}, got: {}", win, input));
    ime.set_forward_event_cb(|win, e| {
        dbg!(
            win,
            e.response_type(),
            e.detail(),
            e.time(),
            e.root(),
            e.event(),
            e.child(),
            e.root_x(),
            e.root_y(),
            e.event_x(),
            e.event_y(),
            e.state(),
            e.same_screen(),
        );
    });
    ime.set_preedit_draw_cb(|win, info| {
        dbg!(win, info);
    });

    let mut wins = vec![];
    for _ in 0..3 {
        wins.push(create_window(connection.clone(), &screen));
    }

    let mut focus_win = wins[0];
    let mut n = 0;
    loop {
        let event = connection.wait_for_event();
        if event.is_none() {
            break;
        }
        let event = event.unwrap();
        dbg!(event.response_type());

        let event_type = event.response_type() & !0x80;
        if xcb::FOCUS_IN == event_type {
            let event: &xcb::FocusInEvent = unsafe { xcb::cast_event(&event) };
            focus_win = event.event();
            ime.update_pos(focus_win, 0, 0);
        }

        if xcb::CONFIGURE_NOTIFY == event_type {
            ime.update_pos(focus_win, 0, 0);
        }

        println!(">>>>{}>>>>", n);
        ime.process_event(&event);
        println!("<<<<{}<<<<", n);
        n += 1;
    }
}

pub unsafe fn unsafe_new( conn: &Connection, screen_id: i32, input_style: InputStyle, im_name: Option<&str>, ) -> Pin<Box<Self>>

Create a new ImeClient.

This is the same as new, except that the xcb::Connection is not wrapped into an Arc.

Safety

The caller is responsible to ensure that the ImeClient does not outlive the connection.

pub fn process_event(&mut self, event: &GenericEvent) -> bool

Let the IME client process XCB’s events.

Return true if the IME client is handling the event and false if the event is ignored by the IME client and has to be handled separately.

This method should be called on any event from the event queue and not just keypress/keyrelease events as it handles other events as well.

Typically you will want to let the IME client handle all keypress/keyrelease events in your main loop. The IME client will then forward all key events that were not used for input composition to the callback set by set_forward_event_cb. Often those events include all keyrelease events as well as the events for ESC, Enter or key combinations such as CTRL+C. To obtain the text currently typed into the IME and the final string consult set_preedit_draw_cb and set_commit_string_cb.

Examples found in repository

examples/example.rs (line 101)

fn main() {
    let (connection, screen_default_nbr) = xcb::Connection::connect(None).unwrap();
    let connection = Arc::new(connection);
    let screen = connection
        .get_setup()
        .roots()
        .nth(screen_default_nbr as usize)
        .unwrap();

    ImeClient::set_logger(|msg| println!("Log: {}", msg));
    let mut ime = ImeClient::new(
        connection.clone(),
        screen_default_nbr,
        InputStyle::PREEDIT_CALLBACKS,
        None,
    );
    ime.set_commit_string_cb(|win, input| println!("Win {}, got: {}", win, input));
    ime.set_forward_event_cb(|win, e| {
        dbg!(
            win,
            e.response_type(),
            e.detail(),
            e.time(),
            e.root(),
            e.event(),
            e.child(),
            e.root_x(),
            e.root_y(),
            e.event_x(),
            e.event_y(),
            e.state(),
            e.same_screen(),
        );
    });
    ime.set_preedit_draw_cb(|win, info| {
        dbg!(win, info);
    });

    let mut wins = vec![];
    for _ in 0..3 {
        wins.push(create_window(connection.clone(), &screen));
    }

    let mut focus_win = wins[0];
    let mut n = 0;
    loop {
        let event = connection.wait_for_event();
        if event.is_none() {
            break;
        }
        let event = event.unwrap();
        dbg!(event.response_type());

        let event_type = event.response_type() & !0x80;
        if xcb::FOCUS_IN == event_type {
            let event: &xcb::FocusInEvent = unsafe { xcb::cast_event(&event) };
            focus_win = event.event();
            ime.update_pos(focus_win, 0, 0);
        }

        if xcb::CONFIGURE_NOTIFY == event_type {
            ime.update_pos(focus_win, 0, 0);
        }

        println!(">>>>{}>>>>", n);
        ime.process_event(&event);
        println!("<<<<{}<<<<", n);
        n += 1;
    }
}

pub fn update_pos(&mut self, win: u32, x: i16, y: i16) -> bool

Set the position at which to place the IME window.

Set the position of the IME window relative to the window specified by win. Coordinates increase from the top left corner of the window.

Return true if an update for the IME window position has been sent to the IME, false if the update has been queued. If there is still an update request queued and this method is called, the previously queued request is discarded in favor of the new one.

Examples found in repository

examples/example.rs (line 93)

fn main() {
    let (connection, screen_default_nbr) = xcb::Connection::connect(None).unwrap();
    let connection = Arc::new(connection);
    let screen = connection
        .get_setup()
        .roots()
        .nth(screen_default_nbr as usize)
        .unwrap();

    ImeClient::set_logger(|msg| println!("Log: {}", msg));
    let mut ime = ImeClient::new(
        connection.clone(),
        screen_default_nbr,
        InputStyle::PREEDIT_CALLBACKS,
        None,
    );
    ime.set_commit_string_cb(|win, input| println!("Win {}, got: {}", win, input));
    ime.set_forward_event_cb(|win, e| {
        dbg!(
            win,
            e.response_type(),
            e.detail(),
            e.time(),
            e.root(),
            e.event(),
            e.child(),
            e.root_x(),
            e.root_y(),
            e.event_x(),
            e.event_y(),
            e.state(),
            e.same_screen(),
        );
    });
    ime.set_preedit_draw_cb(|win, info| {
        dbg!(win, info);
    });

    let mut wins = vec![];
    for _ in 0..3 {
        wins.push(create_window(connection.clone(), &screen));
    }

    let mut focus_win = wins[0];
    let mut n = 0;
    loop {
        let event = connection.wait_for_event();
        if event.is_none() {
            break;
        }
        let event = event.unwrap();
        dbg!(event.response_type());

        let event_type = event.response_type() & !0x80;
        if xcb::FOCUS_IN == event_type {
            let event: &xcb::FocusInEvent = unsafe { xcb::cast_event(&event) };
            focus_win = event.event();
            ime.update_pos(focus_win, 0, 0);
        }

        if xcb::CONFIGURE_NOTIFY == event_type {
            ime.update_pos(focus_win, 0, 0);
        }

        println!(">>>>{}>>>>", n);
        ime.process_event(&event);
        println!("<<<<{}<<<<", n);
        n += 1;
    }
}

pub fn set_commit_string_cb<F>(&mut self, f: F)

where F: for<'a> FnMut(u32, &'a str) + 'static,

Set callback to be called once input composition is done.

The window (set by update_pos) as well as the completed input are passed as arguments.

Examples found in repository

examples/example.rs (line 52)

fn main() {
    let (connection, screen_default_nbr) = xcb::Connection::connect(None).unwrap();
    let connection = Arc::new(connection);
    let screen = connection
        .get_setup()
        .roots()
        .nth(screen_default_nbr as usize)
        .unwrap();

    ImeClient::set_logger(|msg| println!("Log: {}", msg));
    let mut ime = ImeClient::new(
        connection.clone(),
        screen_default_nbr,
        InputStyle::PREEDIT_CALLBACKS,
        None,
    );
    ime.set_commit_string_cb(|win, input| println!("Win {}, got: {}", win, input));
    ime.set_forward_event_cb(|win, e| {
        dbg!(
            win,
            e.response_type(),
            e.detail(),
            e.time(),
            e.root(),
            e.event(),
            e.child(),
            e.root_x(),
            e.root_y(),
            e.event_x(),
            e.event_y(),
            e.state(),
            e.same_screen(),
        );
    });
    ime.set_preedit_draw_cb(|win, info| {
        dbg!(win, info);
    });

    let mut wins = vec![];
    for _ in 0..3 {
        wins.push(create_window(connection.clone(), &screen));
    }

    let mut focus_win = wins[0];
    let mut n = 0;
    loop {
        let event = connection.wait_for_event();
        if event.is_none() {
            break;
        }
        let event = event.unwrap();
        dbg!(event.response_type());

        let event_type = event.response_type() & !0x80;
        if xcb::FOCUS_IN == event_type {
            let event: &xcb::FocusInEvent = unsafe { xcb::cast_event(&event) };
            focus_win = event.event();
            ime.update_pos(focus_win, 0, 0);
        }

        if xcb::CONFIGURE_NOTIFY == event_type {
            ime.update_pos(focus_win, 0, 0);
        }

        println!(">>>>{}>>>>", n);
        ime.process_event(&event);
        println!("<<<<{}<<<<", n);
        n += 1;
    }
}

pub fn set_forward_event_cb<F>(&mut self, f: F)

where F: for<'a> FnMut(u32, &'a KeyPressEvent) + 'static,

Often those events include all keyrelease events as well as the events for ESC, Enter or key combinations such as CTRL+C. Please note that xcb::KeyPressEvent == xcb::KeyReleaseEvent (see xcb::ffi::xcb_key_release_event_t) and keyrelease events are also supplied.

Examples found in repository

examples/example.rs (lines 53-69)

fn main() {
    let (connection, screen_default_nbr) = xcb::Connection::connect(None).unwrap();
    let connection = Arc::new(connection);
    let screen = connection
        .get_setup()
        .roots()
        .nth(screen_default_nbr as usize)
        .unwrap();

    ImeClient::set_logger(|msg| println!("Log: {}", msg));
    let mut ime = ImeClient::new(
        connection.clone(),
        screen_default_nbr,
        InputStyle::PREEDIT_CALLBACKS,
        None,
    );
    ime.set_commit_string_cb(|win, input| println!("Win {}, got: {}", win, input));
    ime.set_forward_event_cb(|win, e| {
        dbg!(
            win,
            e.response_type(),
            e.detail(),
            e.time(),
            e.root(),
            e.event(),
            e.child(),
            e.root_x(),
            e.root_y(),
            e.event_x(),
            e.event_y(),
            e.state(),
            e.same_screen(),
        );
    });
    ime.set_preedit_draw_cb(|win, info| {
        dbg!(win, info);
    });

    let mut wins = vec![];
    for _ in 0..3 {
        wins.push(create_window(connection.clone(), &screen));
    }

    let mut focus_win = wins[0];
    let mut n = 0;
    loop {
        let event = connection.wait_for_event();
        if event.is_none() {
            break;
        }
        let event = event.unwrap();
        dbg!(event.response_type());

        let event_type = event.response_type() & !0x80;
        if xcb::FOCUS_IN == event_type {
            let event: &xcb::FocusInEvent = unsafe { xcb::cast_event(&event) };
            focus_win = event.event();
            ime.update_pos(focus_win, 0, 0);
        }

        if xcb::CONFIGURE_NOTIFY == event_type {
            ime.update_pos(focus_win, 0, 0);
        }

        println!(">>>>{}>>>>", n);
        ime.process_event(&event);
        println!("<<<<{}<<<<", n);
        n += 1;
    }
}

pub fn set_preedit_start_cb<F>(&mut self, f: F)

where F: FnMut(u32) + 'static,

Callback called once the IME has been opened.

The current window (set by update_pos) is supplied as argument. Calls callback only if InputStyle::PREEDIT_CALLBACKS is set.

pub fn set_preedit_draw_cb<F>(&mut self, f: F)

where F: for<'a> FnMut(u32, PreeditInfo<'a>) + 'static,

Callback called whenever the text whitin the IME has changed.

The current window (set by update_pos) is supplied as argument as well as PreeditInfo, which contains, among other things, the current text of the IME. Calls callback only if InputStyle::PREEDIT_CALLBACKS is set.

Examples found in repository

examples/example.rs (lines 70-72)

fn main() {
    let (connection, screen_default_nbr) = xcb::Connection::connect(None).unwrap();
    let connection = Arc::new(connection);
    let screen = connection
        .get_setup()
        .roots()
        .nth(screen_default_nbr as usize)
        .unwrap();

    ImeClient::set_logger(|msg| println!("Log: {}", msg));
    let mut ime = ImeClient::new(
        connection.clone(),
        screen_default_nbr,
        InputStyle::PREEDIT_CALLBACKS,
        None,
    );
    ime.set_commit_string_cb(|win, input| println!("Win {}, got: {}", win, input));
    ime.set_forward_event_cb(|win, e| {
        dbg!(
            win,
            e.response_type(),
            e.detail(),
            e.time(),
            e.root(),
            e.event(),
            e.child(),
            e.root_x(),
            e.root_y(),
            e.event_x(),
            e.event_y(),
            e.state(),
            e.same_screen(),
        );
    });
    ime.set_preedit_draw_cb(|win, info| {
        dbg!(win, info);
    });

    let mut wins = vec![];
    for _ in 0..3 {
        wins.push(create_window(connection.clone(), &screen));
    }

    let mut focus_win = wins[0];
    let mut n = 0;
    loop {
        let event = connection.wait_for_event();
        if event.is_none() {
            break;
        }
        let event = event.unwrap();
        dbg!(event.response_type());

        let event_type = event.response_type() & !0x80;
        if xcb::FOCUS_IN == event_type {
            let event: &xcb::FocusInEvent = unsafe { xcb::cast_event(&event) };
            focus_win = event.event();
            ime.update_pos(focus_win, 0, 0);
        }

        if xcb::CONFIGURE_NOTIFY == event_type {
            ime.update_pos(focus_win, 0, 0);
        }

        println!(">>>>{}>>>>", n);
        ime.process_event(&event);
        println!("<<<<{}<<<<", n);
        n += 1;
    }
}

pub fn set_preedit_done_cb<F>(&mut self, f: F)

where F: FnMut(u32) + 'static,

Callback called once the IME has been closed.

The current window (set by update_pos) is supplied as argument. Calls callback only if InputStyle::PREEDIT_CALLBACKS is set.

Trait Implementations

impl Drop for ImeClient

fn drop(&mut self)

Executes the destructor for this type.