librush 0.2.2

艾刷 (libRush = lib + IBus + Rust + h): 用 rust 编写的 ibus 模块, 不用 GObject (ibus module written in pure rust, without GObject) (输入法, input method)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use xkeysym::{KeyCode, Keysym};
use zbus::{ObjectServer, fdo, object_server::SignalEmitter};

use super::server::Pmims;
use crate::ibus::{IBusEngine, IBusFactory, IBusModifierState};

#[derive(Debug, Clone)]
pub struct PmimEngine {
    s: Pmims,
}

impl PmimEngine {
    pub fn new(s: Pmims) -> Self {
        Self { s }
    }
}

impl IBusEngine for PmimEngine {
    async fn process_key_event(
        &mut self,
        se: SignalEmitter<'_>,
        server: &ObjectServer,
        keyval: Keysym,
        keycode: KeyCode,
        state: IBusModifierState,
    ) -> fdo::Result<bool> {
        self.s
            .process_key_event(se, server, keyval.into(), keycode.into(), state.raw_value())
            .await
    }

    async fn set_cursor_location(
        &mut self,
        se: SignalEmitter<'_>,
        server: &ObjectServer,
        x: i32,
        y: i32,
        w: i32,
        h: i32,
    ) -> fdo::Result<()> {
        self.s.set_cursor_location(se, server, x, y, w, h).await
    }

    async fn focus_in(&mut self, se: SignalEmitter<'_>, server: &ObjectServer) -> fdo::Result<()> {
        self.s.focus_in(se, server).await
    }

    async fn focus_out(&mut self, se: SignalEmitter<'_>, server: &ObjectServer) -> fdo::Result<()> {
        self.s.focus_out(se, server).await
    }

    async fn reset(&mut self, se: SignalEmitter<'_>, server: &ObjectServer) -> fdo::Result<()> {
        self.s.reset(se, server).await
    }

    async fn enable(&mut self, se: SignalEmitter<'_>, server: &ObjectServer) -> fdo::Result<()> {
        self.s.enable(se, server).await
    }

    async fn disable(&mut self, se: SignalEmitter<'_>, server: &ObjectServer) -> fdo::Result<()> {
        self.s.disable(se, server).await
    }
}

#[derive(Debug, Clone)]
pub struct PmimFactory {
    s: Pmims,
}

impl PmimFactory {
    pub fn new(s: Pmims) -> Self {
        Self { s }
    }
}

impl IBusFactory<PmimEngine> for PmimFactory {
    fn create_engine(&mut self, name: String) -> Result<PmimEngine, String> {
        let 名称 = "pmim";

        if 名称 == name {
            Ok(PmimEngine::new(self.s.clone()))
        } else {
            Err(format!("unknown name: {}", name))
        }
    }
}