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
128
129
130
131
132
133
134
135
136
137

use bitflags::bitflags;
use windows_sys::Win32::{
    Foundation::HWND,
    UI::Input::{
        Ime::{
            ImmGetContext, ImmGetConversionStatus, ImmGetOpenStatus, ImmReleaseContext,
            ImmSetConversionStatus, ImmSetOpenStatus,
        },
        KeyboardAndMouse::GetFocus,
    },
};

/// `true` for on, `false` for off.
pub type ImeState = bool;

/// Get current IME state for a window.
///
/// Ref: https://github.com/dotnet/wpf/blob/aa997926b405d7ccea7a28f3b02ef8c1409ed4ca/src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Input/InputMethod.cs#L538-L542
pub fn get_window_ime_state(hwnd: HWND) -> ImeState {
    let himc = unsafe { ImmGetContext(hwnd) };
    if himc.is_null() {
        return false;
    }

    let f_open = unsafe { ImmGetOpenStatus(himc) } != 0;
    unsafe { ImmReleaseContext(hwnd, himc) };

    f_open
}

/// Get current IME state for the window with focus.
pub fn get_ime_state() -> ImeState {
    let hwnd = unsafe { GetFocus() };
    get_window_ime_state(hwnd)
}

/// Set current IME state for a window.
///
/// Ref: https://github.com/dotnet/wpf/blob/aa997926b405d7ccea7a28f3b02ef8c1409ed4ca/src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Input/InputMethod.cs#L571-L586
pub fn set_window_ime_state(hwnd: HWND, state: ImeState) {
    let himc = unsafe { ImmGetContext(hwnd) };
    if himc.is_null() {
        return;
    }

    let fopen = unsafe { ImmGetOpenStatus(himc) } != 0;

    // we don't have to call IMM unless the value is changed.
    if fopen != state {
        unsafe { ImmSetOpenStatus(himc, state as _) };
    }

    unsafe { ImmReleaseContext(hwnd, himc) };
}

/// Set current IME state for the window with focus.
pub fn set_ime_state(state: ImeState) {
    let hwnd = unsafe { GetFocus() };
    set_window_ime_state(hwnd, state);
}

/// IME conversion mode bitflags.
///
/// Ref: [IME Conversion Mode Values - Win32 apps | Microsoft Learn](https://learn.microsoft.com/en-us/windows/win32/intl/ime-conversion-mode-values)
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct ImeConversionMode(u32);

bitflags! {
    impl ImeConversionMode: u32 {
        /// Alphanumeric input mode. This is the default, defined as 0x0000.
        const ALPHANUMERIC = 0x0000;
        /// Set to 1 if character code input mode; 0 if not.
        const CHARCODE = 0x0001;
        /// Set to 1 if EUDC conversion mode; 0 if not.
        const EUDC = 0x0002;
        /// Windows Me/98, Windows 2000, Windows XP: Set to 1 if fixed conversion mode; 0 if not.
        const FIXED = 0x0004;
        /// Set to 1 if full shape mode; 0 if half shape mode.
        const FULLSHAPE = 0x0008;
        /// Set to 1 if HANJA convert mode; 0 if not.
        const HANJACONVERT = 0x0010;
        /// Set to 1 if KATAKANA mode; 0 if HIRAGANA mode.
        const KATAKANA = 0x0020;
        /// Set to 1 if NATIVE mode; 0 if ALPHANUMERIC mode.
        const NATIVE = 0x0040;
        /// Set to 1 to prevent processing of conversions by IME; 0 if not.
        const NOCONVERSION = 0x0080;
        /// Set to 1 if ROMAN input mode; 0 if not.
        const ROMAN = 0x0100;
        /// Set to 1 if Soft Keyboard mode; 0 if not.
        const SOFTKBD = 0x0200;
        /// Set to 1 if SYMBOL conversion mode; 0 if not.
        const SYMBOL = 0x0400;
    }
}

/// Get current IME conversion mode for a window.
///
/// Ref: https://github.com/dotnet/wpf/blob/aa997926b405d7ccea7a28f3b02ef8c1409ed4ca/src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Input/InputMethod.cs#L773-L775
pub fn get_window_ime_conversion_mode(hwnd: HWND) -> ImeConversionMode {
    let himc = unsafe { ImmGetContext(hwnd) };
    if himc.is_null() {
        return ImeConversionMode::empty();
    }

    let mut convmode = 0u32;
    let mut sentence = 0u32;
    unsafe { ImmGetConversionStatus(himc, &mut convmode, &mut sentence) };
    unsafe { ImmReleaseContext(hwnd, himc) };

    ImeConversionMode::from_bits_retain(convmode)
}

/// Get current IME conversion mode for the window with focus.
pub fn get_ime_conversion_mode() -> ImeConversionMode {
    let hwnd = unsafe { GetFocus() };
    get_window_ime_conversion_mode(hwnd)
}

/// Set current IME conversion mode for a window.
///
/// Ref: https://github.com/dotnet/wpf/blob/aa997926b405d7ccea7a28f3b02ef8c1409ed4ca/src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Input/InputMethod.cs#L911-L977
pub fn set_window_ime_conversion_mode(hwnd: HWND, convmode: ImeConversionMode) {
    let himc = unsafe { ImmGetContext(hwnd) };
    if himc.is_null() {
        return;
    }

    unsafe { ImmSetConversionStatus(himc, convmode.bits(), 0) };
    unsafe { ImmReleaseContext(hwnd, himc) };
}

/// Set current IME conversion mode for the window with focus.
pub fn set_ime_conversion_mode(convmode: ImeConversionMode) {
    let hwnd = unsafe { GetFocus() };
    set_window_ime_conversion_mode(hwnd, convmode);
}