Add settings for input source switching

Author: tingkai-c

docs/config.toml

@@ -25,6 +25,7 @@ clipboard_hotkey = "SUPER+SHIFT+2"
 
 # Switch to this macOS input source when RustCast opens.
 # Leave unset to keep the current input source.
+# You can also configure this from the Settings page.
 # The input source must be enabled in macOS Keyboard settings.
 # Examples: "com.apple.keylayout.US", "com.apple.inputmethod.Kotoeri.RomajiTyping.Japanese"
 # input_source_on_open = "com.apple.keylayout.US"

docs/default.toml

@@ -7,6 +7,7 @@ haptic_feedback = false
 show_trayicon = true
 shells = []
 clipboard_hotkey = "SUPER+SHIFT+C"
+# Also configurable from the Settings page.
 # input_source_on_open = "com.apple.keylayout.US"
 restore_input_source_on_close = true
 

src/app.rs

@@ -194,6 +194,7 @@ pub enum SetConfigFields {
     SetThemeFields(SetConfigThemeFields),
     SetBufferFields(SetConfigBufferFields),
     ClipboardPasteOnSelect(bool),
+    InputSourceOnOpen(Option<String>),
 }
 
 #[derive(Debug, Clone)]

src/app/pages/settings.rs

@@ -347,6 +347,55 @@ fn general_tab(config: Box<Config>, theme: crate::config::Theme) -> Column<'stat
         .height(SETTINGS_ITEM_HEIGHT),
     );
 
+    let input_sources = crate::platform::macos::input_source::enabled_input_sources();
+    let input_source_enabled = config.input_source_on_open.is_some();
+    let input_source_default = config
+        .input_source_on_open
+        .clone()
+        .filter(|selected| input_sources.iter().any(|source| &source.id == selected))
+        .or_else(|| input_sources.first().map(|source| source.id.clone()));
+    let input_source_toggle = settings_row_without_reset(settings_item_row([
+        settings_hint_text(
+            theme.clone(),
+            "Input source switching",
+            Some("Switch keyboard input while RustCast is open"),
+        ),
+        Space::new().width(Length::Fill).into(),
+        toggler(input_source_enabled)
+            .style(move |_, status| settings_toggle_style(status))
+            .on_toggle(move |enabled| {
+                Message::SetConfig(SetConfigFields::InputSourceOnOpen(if enabled {
+                    input_source_default.clone()
+                } else {
+                    None
+                }))
+            })
+            .into(),
+    ]));
+
+    let input_source_dropdown = if input_source_enabled && !input_sources.is_empty() {
+        let selected_input_source = config.input_source_on_open.as_ref().and_then(|selected| {
+            input_sources
+                .iter()
+                .find(|source| &source.id == selected)
+                .cloned()
+        });
+        let theme_clone = theme.clone();
+        let theme_clone_2 = theme.clone();
+        settings_row_without_reset(settings_item_row([
+            settings_hint_text(theme.clone(), "Input source on open", None::<String>),
+            Space::new().width(Length::Fill).into(),
+            pick_list(input_sources, selected_input_source, |source| {
+                Message::SetConfig(SetConfigFields::InputSourceOnOpen(Some(source.id)))
+            })
+            .style(move |_, status| picklist_style(&theme_clone, status))
+            .menu_style(move |_| picklist_menu_style(&theme_clone_2))
+            .into(),
+        ]))
+    } else {
+        Space::new().height(0).into()
+    };
+
     let theme_clone = theme.clone();
     let auto_suggest = settings_row_without_reset(settings_item_row([
         settings_hint_text(theme.clone(), "Suggestions on open", None::<String>),
@@ -422,6 +471,8 @@ fn general_tab(config: Box<Config>, theme: crate::config::Theme) -> Column<'stat
         tray_icon,
         clipboard_history,
         cbhist_paste_on_select,
+        input_source_toggle,
+        input_source_dropdown,
         auto_suggest,
     ])
     .spacing(10)

src/app/tile/update.rs

@@ -978,6 +978,9 @@ pub fn handle_update(tile: &mut Tile, message: Message) -> Task<Message> {
                 SetConfigFields::ClipboardPasteOnSelect(v) => {
                     final_config.cbhist_paste_on_select = v
                 }
+                SetConfigFields::InputSourceOnOpen(input_source) => {
+                    final_config.input_source_on_open = input_source
+                }
                 SetConfigFields::ToDefault => {
                     final_config = Config::default();
                 }

src/platform/macos/input_source.rs

@@ -1,42 +1,43 @@
-use std::ffi::{c_char, c_void};
+use std::{ffi::c_void, ptr::NonNull};
 
-use objc2_core_foundation::CFType;
+use objc2_core_foundation::{CFArray, CFRetained, CFString, CFType};
 
 type Boolean = u8;
-type CFIndex = isize;
 type OSStatus = i32;
-type CFStringEncoding = u32;
 type TISInputSourceRef = *const c_void;
 
-const K_CFSTRING_ENCODING_UTF8: CFStringEncoding = 0x0800_0100;
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct InputSource {
+    pub id: String,
+    pub name: String,
+}
+
+impl std::fmt::Display for InputSource {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{} ({})", self.name, self.id)
+    }
+}
 
 #[link(name = "Carbon", kind = "framework")]
 unsafe extern "C" {
-    static kTISPropertyInputSourceID: *const c_void;
+    static kTISPropertyInputSourceID: *const CFString;
+    static kTISPropertyLocalizedName: *const CFString;
 
     fn TISCopyCurrentKeyboardInputSource() -> TISInputSourceRef;
     fn TISCreateInputSourceList(
         properties: *const c_void,
         includeAllInstalled: Boolean,
-    ) -> *const c_void;
+    ) -> *const CFArray;
     fn TISGetInputSourceProperty(
         inputSource: TISInputSourceRef,
-        propertyKey: *const c_void,
+        propertyKey: *const CFString,
     ) -> *const c_void;
     fn TISSelectInputSource(inputSource: TISInputSourceRef) -> OSStatus;
 }
 
 #[link(name = "CoreFoundation", kind = "framework")]
 unsafe extern "C" {
-    fn CFArrayGetCount(theArray: *const c_void) -> CFIndex;
-    fn CFArrayGetValueAtIndex(theArray: *const c_void, idx: CFIndex) -> *const c_void;
     fn CFRelease(cf: *mut CFType);
-    fn CFStringGetCString(
-        theString: *const c_void,
-        buffer: *mut c_char,
-        bufferSize: CFIndex,
-        encoding: CFStringEncoding,
-    ) -> Boolean;
 }
 
 pub fn current_input_source_id() -> Option<String> {
@@ -51,21 +52,28 @@ pub fn current_input_source_id() -> Option<String> {
 }
 
 pub fn select_input_source(id: &str) -> Result<(), String> {
-    let sources = unsafe { TISCreateInputSourceList(std::ptr::null(), false as Boolean) };
-    if sources.is_null() {
+    let Some(sources) = input_source_list(false) else {
         return Err("TISCreateInputSourceList returned null".to_string());
-    }
+    };
+
+    select_input_source_from_list(&sources, id)
+}
 
-    let result = select_input_source_from_list(sources, id);
-    unsafe { CFRelease(sources.cast_mut().cast()) };
-    result
+pub fn enabled_input_sources() -> Vec<InputSource> {
+    input_source_list(false)
+        .map(|sources| input_sources_from_list(&sources))
+        .unwrap_or_default()
 }
 
-fn select_input_source_from_list(sources: *const c_void, id: &str) -> Result<(), String> {
-    let count = unsafe { CFArrayGetCount(sources) };
+fn input_source_list(include_all_installed: bool) -> Option<CFRetained<CFArray>> {
+    let sources =
+        unsafe { TISCreateInputSourceList(std::ptr::null(), include_all_installed as Boolean) };
+    NonNull::new(sources.cast_mut()).map(|sources| unsafe { CFRetained::from_raw(sources) })
+}
 
-    for idx in 0..count {
-        let source = unsafe { CFArrayGetValueAtIndex(sources, idx) };
+fn select_input_source_from_list(sources: &CFArray, id: &str) -> Result<(), String> {
+    for idx in 0..sources.count() {
+        let source = unsafe { sources.value_at_index(idx) };
         if source.is_null() {
             continue;
         }
@@ -83,6 +91,20 @@ fn select_input_source_from_list(sources: *const c_void, id: &str) -> Result<(),
     Err(format!("input source not found: {id}"))
 }
 
+fn input_sources_from_list(sources: &CFArray) -> Vec<InputSource> {
+    (0..sources.count())
+        .filter_map(|idx| {
+            let source = unsafe { sources.value_at_index(idx) };
+            if source.is_null() {
+                return None;
+            }
+            let id = input_source_id(source)?;
+            let name = input_source_name(source).unwrap_or_else(|| id.clone());
+            Some(InputSource { id, name })
+        })
+        .collect()
+}
+
 fn input_source_id(source: TISInputSourceRef) -> Option<String> {
     let id_ref = unsafe { TISGetInputSourceProperty(source, kTISPropertyInputSourceID) };
     if id_ref.is_null() {
@@ -92,21 +114,16 @@ fn input_source_id(source: TISInputSourceRef) -> Option<String> {
     cf_string_to_string(id_ref)
 }
 
-fn cf_string_to_string(value: *const c_void) -> Option<String> {
-    let mut buffer = vec![0u8; 1024];
-    let ok = unsafe {
-        CFStringGetCString(
-            value,
-            buffer.as_mut_ptr().cast(),
-            buffer.len() as CFIndex,
-            K_CFSTRING_ENCODING_UTF8,
-        )
-    };
-
-    if ok == 0 {
+fn input_source_name(source: TISInputSourceRef) -> Option<String> {
+    let name_ref = unsafe { TISGetInputSourceProperty(source, kTISPropertyLocalizedName) };
+    if name_ref.is_null() {
         return None;
     }
 
-    let nul = buffer.iter().position(|&byte| byte == 0)?;
-    Some(String::from_utf8_lossy(&buffer[..nul]).into_owned())
+    cf_string_to_string(name_ref)
+}
+
+fn cf_string_to_string(value: *const c_void) -> Option<String> {
+    NonNull::new(value.cast_mut().cast::<CFString>())
+        .map(|value| unsafe { value.as_ref() }.to_string())
 }