ib-ime 0.1.0

A library for controlling input controls' IME (Input Method Editor) behavior on Windows.
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use bon::Builder;
use windows_sys::Win32::{
    Foundation::{HWND, LPARAM, LRESULT, WPARAM},
    UI::{
        Shell::{DefSubclassProc, SetWindowSubclass},
        WindowsAndMessaging::{WM_KILLFOCUS, WM_NCDESTROY, WM_SETFOCUS},
    },
};

use crate::imm::{
    ImeConversionMode, ImeState, get_window_ime_conversion_mode, get_window_ime_state,
    set_ime_conversion_mode, set_window_ime_state,
};

const SUBCLASS_ID: usize = 0;

struct SubclassData {
    config: ImeHookConfig,
    original_state: ImeState,
    original_conversion_mode: ImeConversionMode,
}

unsafe extern "system" fn wnd_proc(
    hwnd: HWND,
    umsg: u32,
    wparam: WPARAM,
    lparam: LPARAM,
    _id: usize,
    data: usize,
) -> LRESULT {
    #[cfg(test)]
    eprintln!("hwnd: {hwnd:p}, msg: {umsg:X}, wparam: {wparam:X}, wparam: {lparam:X}");

    match umsg {
        WM_SETFOCUS => {
            // Save original IME state
            let original_state = get_window_ime_state(hwnd);
            let original_conversion_mode = get_window_ime_conversion_mode(hwnd);
            #[cfg(feature = "log")]
            {
                eprintln!("get_ime_state: {original_state:?}");
                eprintln!("get_ime_conversion_mode: {original_conversion_mode:?}");
            }

            // Get config from subclass data to determine preferred state
            let subclass_data = unsafe { (data as *mut SubclassData).read() };
            let config = subclass_data.config;

            if let Some(conversion_mode) = config.default_ime_conversion_mode {
                set_ime_conversion_mode(conversion_mode);
            }
            if let Some(state) = config.default_ime_state {
                set_window_ime_state(hwnd, state);
            }

            // Store original state in subclass data
            let original_data = Box::new(SubclassData {
                original_state,
                original_conversion_mode,
                config,
            });
            unsafe { (data as *mut SubclassData).write(*original_data) };
        }
        WM_KILLFOCUS if data != 0 => {
            // Restore original IME state and conversion mode
            let data = unsafe { (data as *mut SubclassData).read() };
            #[cfg(feature = "log")]
            {
                eprintln!("set_ime_state: {:?}", data.original_state);
                eprintln!(
                    "set_ime_conversion_mode: {:?}",
                    data.original_conversion_mode
                );
            }
            set_ime_conversion_mode(data.original_conversion_mode);
            set_window_ime_state(wparam as _, data.original_state);
        }
        WM_NCDESTROY => {
            // Free the subclass data when window is destroyed
            if data != 0 {
                let _ = unsafe { Box::from_raw(data as *mut SubclassData) };
            }
        }
        _ => {}
    }

    let res = unsafe { DefSubclassProc(hwnd, umsg, wparam, lparam) };
    res
}

/// Configuration for IME hook behavior.
#[derive(Clone, Copy, PartialEq, Eq, Debug, Builder)]
pub struct ImeHookConfig {
    pub default_ime_state: Option<ImeState>,
    pub default_ime_conversion_mode: Option<ImeConversionMode>,
}

impl ImeHookConfig {
    pub fn default_off() -> Self {
        Self {
            default_ime_state: Some(false),
            default_ime_conversion_mode: Some(ImeConversionMode::ALPHANUMERIC),
        }
    }
}

impl ImeHookConfig {
    pub fn hook_window(self, hwnd: HWND) -> bool {
        // Allocate subclass data on heap
        let subclass_data = Box::new(SubclassData {
            config: self,
            original_state: false,
            original_conversion_mode: ImeConversionMode::empty(),
        });
        let subclass_data_ptr = Box::into_raw(subclass_data) as usize;

        let result =
            unsafe { SetWindowSubclass(hwnd, Some(wnd_proc), SUBCLASS_ID, subclass_data_ptr) != 0 };

        if !result {
            // Cleanup if setting subclass failed
            let _ = unsafe { Box::from_raw(subclass_data_ptr as *mut SubclassData) };
        }

        result
    }
}