Files
Dax bcec84f8be labs: signature line for dictation (#2319)
* labs: signature line for dictation (#2314)

* labs: fix signature Paste Last, line check, and validation

Paste Last now remembers whether its text was signed and reinserts a signed one
standalone, so a later unsigned dictation never joins the signature line.
append skips only a signature already on its own line, so "Hex" in
"I love Hex" is signed. A saved signature refuses line and control characters,
and signature_text loads the gate like the other gates. Also fixes the German
summary and updates the docs.
2026-11-22 00:47:26 -05:00

802 lines
28 KiB
Rust
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use std::mem::size_of;
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::{Duration, Instant};
use arboard::SetExtWindows;
use color_eyre::eyre::{Result, WrapErr, eyre};
use windows_sys::Win32::Foundation::HWND;
use windows_sys::Win32::System::DataExchange::{CountClipboardFormats, GetClipboardSequenceNumber};
use windows_sys::Win32::System::Threading::GetCurrentProcessId;
use windows_sys::Win32::UI::Input::KeyboardAndMouse::{
GetAsyncKeyState, GetKeyboardLayout, INPUT, INPUT_0, INPUT_KEYBOARD, KEYBDINPUT,
KEYEVENTF_KEYUP, MAPVK_VK_TO_VSC, MapVirtualKeyExW, SendInput, VK_CONTROL, VK_LWIN, VK_MENU,
VK_RETURN, VK_RWIN, VK_SHIFT, VK_V,
};
use windows_sys::Win32::UI::WindowsAndMessaging::{
GUITHREADINFO, GetClassNameW, GetForegroundWindow, GetGUIThreadInfo, GetWindowThreadProcessId,
IsIconic, IsWindow, IsWindowVisible, SetForegroundWindow,
};
use crate::continuation::{Continuation, InputActivity};
use crate::dictation::paste_target::is_shell_target;
const CLIPBOARD_RESTORE_DELAY: Duration = Duration::from_millis(500);
/// How long a paste waits for the window its capture started in to come back
/// to the front, and how often it asks.
const RETURN_TIMEOUT: Duration = Duration::from_millis(200);
const RETURN_POLL: Duration = Duration::from_millis(10);
/// Remote desktop clients (#866) forward a clipboard change to the remote
/// session asynchronously, and the remote fetches the text only when it
/// pastes. Ctrl+V sent at once can reach the remote before the new
/// clipboard does, and a restore after 500 ms can replace the text before
/// the remote asked for it, so both wait longer there.
const REMOTE_DESKTOP_STEMS: &[&str] = &["mstsc", "msrdc"];
const REMOTE_DESKTOP_PASTE_DELAY: Duration = Duration::from_millis(400);
const REMOTE_DESKTOP_RESTORE_DELAY: Duration = Duration::from_secs(3);
fn is_remote_desktop(stem: Option<&str>) -> bool {
stem.is_some_and(|stem| REMOTE_DESKTOP_STEMS.contains(&stem))
}
/// Java games such as Minecraft (#1362; GLFW and LWJGL windows run inside
/// `javaw`/`java`) take only Ctrl+V as paste and ignore Ctrl+Shift+V, so
/// Terminal paste sends them plain Ctrl+V.
const PLAIN_PASTE_STEMS: &[&str] = &["javaw", "java"];
fn paste_with_shift_into(stem: Option<&str>, terminal_paste: bool) -> bool {
terminal_paste && !stem.is_some_and(|stem| PLAIN_PASTE_STEMS.contains(&stem))
}
/// A paste with Ctrl+Shift+V when this capture asks for it (Labs › Terminal
/// paste shortcut) or the saved Terminal paste setting is on.
fn shift_paste(for_this_capture: bool, terminal_paste: bool) -> bool {
for_this_capture || terminal_paste
}
/// What a paste did with the text.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Paste {
/// The chord was sent to the window in front.
Sent,
/// Nothing was sent: the text stayed on the clipboard, because the window
/// in front was the shell or Labs › Copy dictation only is on.
Copied,
}
enum ClipboardSnapshot {
Empty,
Files(Vec<PathBuf>),
Html { html: String, text: Option<String> },
Image(arboard::ImageData<'static>),
Text(String),
}
impl ClipboardSnapshot {
fn read(clipboard: &mut arboard::Clipboard) -> Result<Self> {
if let Ok(html) = clipboard.get().html() {
return Ok(Self::Html {
html,
text: clipboard.get_text().ok(),
});
}
if let Ok(text) = clipboard.get_text() {
return Ok(Self::Text(text));
}
if let Ok(files) = clipboard.get().file_list()
&& !files.is_empty()
{
return Ok(Self::Files(files));
}
if let Ok(image) = clipboard.get().image() {
return Ok(Self::Image(image));
}
if unsafe { CountClipboardFormats() } == 0 {
return Ok(Self::Empty);
}
Err(eyre!(
"the current clipboard format cannot be preserved safely"
))
}
fn restore(self, clipboard: &mut arboard::Clipboard) -> Result<()> {
match self {
Self::Empty => clipboard.clear()?,
Self::Files(files) => clipboard.set().file_list(&files)?,
Self::Html { html, text } => clipboard.set().html(html, text)?,
Self::Image(image) => clipboard.set_image(image)?,
Self::Text(text) => clipboard.set_text(text)?,
}
Ok(())
}
}
/// The window in front as a paste sees it: its class and process, and the
/// child of the foreground thread that holds the keyboard focus.
#[derive(Default)]
struct Foreground {
window: isize,
class: String,
application: Option<String>,
focus_class: Option<String>,
}
impl Foreground {
/// Reads the window in front now, for one paste's decision and log line.
fn read() -> Self {
// SAFETY: plain Win32 queries; a null foreground window owns nothing.
unsafe {
let window = GetForegroundWindow();
if window.is_null() {
return Self::default();
}
Self {
window: window as isize,
class: window_class(window),
application: crate::windows::input::window_process_path(window).and_then(|path| {
path.file_stem()
.map(|stem| stem.to_string_lossy().to_lowercase())
}),
focus_class: focused_window_class(),
}
}
}
/// Whether a paste here would be lost in the shell.
fn is_shell(&self) -> bool {
is_shell_target(
(self.window != 0).then_some(self.class.as_str()),
self.application.as_deref(),
self.focus_class.as_deref(),
)
}
}
/// The window a capture started in, with the process that owned it then, so
/// a reused handle is not mistaken for the same window.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct CaptureWindow {
window: isize,
pid: u32,
}
impl CaptureWindow {
/// The window in front now, or `None` when nothing is.
pub fn read() -> Option<Self> {
// SAFETY: plain queries; a null foreground window owns no process.
unsafe {
let window = GetForegroundWindow();
if window.is_null() {
return None;
}
let mut pid = 0_u32;
GetWindowThreadProcessId(window, &mut pid);
(pid != 0).then_some(Self {
window: window as isize,
pid,
})
}
}
}
/// The window's class name, empty when Windows has none to give.
fn window_class(window: HWND) -> String {
let mut buffer = [0_u16; 256];
// SAFETY: `buffer` is writable for the length it states.
let length = unsafe { GetClassNameW(window, buffer.as_mut_ptr(), buffer.len() as i32) };
if length <= 0 {
return String::new();
}
String::from_utf16_lossy(&buffer[..length as usize])
}
/// The keyboard-focused child of the foreground thread, if any.
fn focused_window_class() -> Option<String> {
let mut info = GUITHREADINFO {
cbSize: size_of::<GUITHREADINFO>() as u32,
..Default::default()
};
// SAFETY: `info` states its own size; a null thread asks for the one in front.
let filled = unsafe { GetGUIThreadInfo(0, &mut info) } != 0;
(filled && !info.hwndFocus.is_null()).then(|| window_class(info.hwndFocus))
}
pub struct WindowsPaster {
clipboard: arboard::Clipboard,
clipboard_restore: Arc<Mutex<ClipboardRestore>>,
/// Terminal paste: send Ctrl+Shift+V instead of Ctrl+V. Shared so a
/// settings change applies to the next paste without a new paster.
paste_with_shift: Arc<AtomicBool>,
/// The user's own input since the listener started: a paste joins the
/// one before it only while this revision is unchanged.
activity: InputActivity,
continuation: Continuation,
}
#[derive(Default)]
struct ClipboardRestore {
generation: u64,
original: Option<ClipboardSnapshot>,
last_sequence: Option<u32>,
}
impl ClipboardRestore {
fn register(
&mut self,
previous: Option<ClipboardSnapshot>,
previous_sequence: u32,
inserted_sequence: u32,
) -> u64 {
self.generation = self.generation.wrapping_add(1);
if self.last_sequence != Some(previous_sequence) {
self.original = previous;
}
self.last_sequence = Some(inserted_sequence);
self.generation
}
/// Labs › Keep dictation on clipboard: the paste stays on the clipboard,
/// so no earlier snapshot may come back and any pending restore stands
/// down.
fn keep(&mut self) {
self.generation = self.generation.wrapping_add(1);
self.original = None;
self.last_sequence = None;
}
}
impl WindowsPaster {
pub fn new(paste_with_shift: Arc<AtomicBool>, activity: InputActivity) -> Result<Self> {
Ok(Self {
clipboard: arboard::Clipboard::new()
.wrap_err("could not open the Windows clipboard")?,
clipboard_restore: Arc::new(Mutex::new(ClipboardRestore::default())),
paste_with_shift,
activity,
continuation: Continuation::default(),
})
}
/// Pastes `text`, with Ctrl+Shift+V when `shift` asks for it or the
/// saved Terminal paste setting is on. Java games still take Ctrl+V.
/// `return_to` is the window the capture started in: the desktop or a
/// taskbar takes no paste, so Hex returns there first and, when it can't,
/// leaves the transcript on the clipboard instead of sending it nowhere.
/// `standalone` pastes the text without joining the previous dictation
/// and records no continuation for the next one (Labs › Signature).
pub fn paste(
&mut self,
text: &str,
shift: bool,
return_to: Option<CaptureWindow>,
standalone: bool,
) -> Result<Paste> {
if text.trim().is_empty() {
return Err(eyre!("refusing to paste an empty transcript"));
}
let revision = self.activity.revision();
let plain = text;
let mut restore = self
.clipboard_restore
.lock()
.unwrap_or_else(|error| error.into_inner());
let original_sequence = clipboard_sequence();
// Read as the paste commits, so the toggle applies at once.
let keep = crate::labs::keep_on_clipboard();
// A clipboard Hex can't snapshot (an app's private format) never
// blocks the paste: the transcript still goes in, and that
// clipboard just isn't restored afterwards. Keeping the paste needs
// no snapshot at all.
let snapshot = if keep {
None
} else {
match ClipboardSnapshot::read(&mut self.clipboard) {
Ok(snapshot) => Some(snapshot),
Err(error) => {
tracing::warn!(%error, "pasting without restoring the previous Windows clipboard");
None
}
}
};
wait_for_conflicting_modifiers();
// Resolve the target before the clipboard write: a copy for the shell
// leaves the plain transcript, while a paste carries the
// continuation's join.
let mut target = Foreground::read();
let returned = target.is_shell() && return_to.is_some_and(bring_to_front);
if returned {
target = Foreground::read();
}
tracing::info!(
hwnd = target.window,
class = %target.class,
application = target.application.as_deref().unwrap_or(""),
focus = target.focus_class.as_deref().unwrap_or(""),
returned,
"Windows paste target"
);
if clipboard_sequence() != original_sequence {
return Err(eyre!(
"the clipboard changed while the transcript was being prepared"
));
}
let copied = target.is_shell();
let text = if copied || standalone {
plain.to_string()
} else {
text_to_paste(&self.continuation, revision, plain)
};
if keep {
// Labs › Keep dictation on clipboard: an ordinary entry, so
// Windows keeps it in clipboard history (Win+V) and cloud sync,
// as macOS keeps its kept entry ordinary too.
self.clipboard
.set()
.text(text.clone())
.wrap_err("could not place the transcript on the Windows clipboard")?;
restore.keep();
} else {
// Marked so Windows keeps the transcript out of clipboard history
// (Win+V) and cloud sync, as macOS marks it transient (#851).
// A copy for the shell keeps the same marking: the fallback is
// still a dictation, not a kept one.
self.clipboard
.set()
.exclude_from_history()
.exclude_from_cloud()
.text(text.clone())
.wrap_err("could not place the transcript on the Windows clipboard")?;
}
if copied {
// Nothing in front takes a paste: the words stay on the
// clipboard for Paste Last or a manual Ctrl+V instead of being
// sent to the desktop or taskbar and lost.
restore.keep();
drop(restore);
tracing::warn!(
class = %target.class,
application = target.application.as_deref().unwrap_or(""),
"the paste target is the Windows shell; the dictation stays on the clipboard"
);
self.continuation.clear();
return Ok(Paste::Copied);
}
let generation = if keep {
None
} else {
let transcript_sequence = clipboard_sequence();
Some(restore.register(snapshot, original_sequence, transcript_sequence))
};
drop(restore);
let remote_desktop = is_remote_desktop(target.application.as_deref());
if remote_desktop {
thread::sleep(REMOTE_DESKTOP_PASTE_DELAY);
}
let shift = paste_with_shift_into(
target.application.as_deref(),
shift_paste(shift, self.paste_with_shift.load(Ordering::Relaxed)),
);
if let Err(error) = send_paste_shortcut(shift) {
if let Some(generation) = generation {
restore_clipboard_generation(&self.clipboard_restore, generation);
}
return Err(error);
}
// Only a paste that reached the app is continued by the next one, and
// a standalone paste ends the continuation instead.
self.continuation.record(revision, !standalone, text);
let Some(generation) = generation else {
return Ok(Paste::Sent);
};
let clipboard_restore = self.clipboard_restore.clone();
let restore_delay = if remote_desktop {
REMOTE_DESKTOP_RESTORE_DELAY
} else {
CLIPBOARD_RESTORE_DELAY
};
thread::spawn(move || {
thread::sleep(restore_delay);
restore_clipboard_generation(&clipboard_restore, generation);
});
Ok(Paste::Sent)
}
/// Labs › YOLO mode: one press of Return after a paste, once
/// the paste has had [`crate::dictation::yolo_mode::SETTLE`] to land.
pub fn press_return(&mut self) -> Result<()> {
// Return sends the message, so the next dictation starts a new one,
// as macOS's Send mode ends its continuation.
self.continuation.clear();
thread::sleep(crate::dictation::yolo_mode::SETTLE);
wait_for_conflicting_modifiers();
let scan = foreground_scan_code(VK_RETURN);
let inputs = [
keyboard_input(VK_RETURN, scan, 0),
keyboard_input(VK_RETURN, scan, KEYEVENTF_KEYUP),
];
let sent = send_inputs(&inputs);
if sent != inputs.len() as u32 {
send_inputs(&inputs[1..]);
return Err(eyre!(
"Windows accepted only {sent} of 2 synthetic Return events; an elevated target window may reject input"
));
}
Ok(())
}
/// Labs › Copy dictation only: leaves `text` on the clipboard for the
/// user to paste, with no keystroke and no restore. A pending restore
/// stands down and no earlier snapshot comes back.
pub fn copy_only(&mut self, text: &str) -> Result<()> {
if text.trim().is_empty() {
return Err(eyre!("refusing to copy an empty transcript"));
}
// Nothing was inserted, so the next paste starts a new
// continuation.
self.continuation.clear();
let mut restore = self
.clipboard_restore
.lock()
.unwrap_or_else(|error| error.into_inner());
restore.keep();
self.clipboard
.set()
.text(text.to_string())
.wrap_err("could not place the transcript on the Windows clipboard")
}
}
/// What a dictation pastes: `text`, joined onto the previous dictation when
/// nothing in between ended the input session. Dictation and Paste Last
/// both continue their dictation.
fn text_to_paste(continuation: &Continuation, revision: u64, text: &str) -> String {
continuation
.join(revision, true, text)
.unwrap_or_else(|| text.to_string())
}
fn clipboard_sequence() -> u32 {
unsafe { GetClipboardSequenceNumber() }
}
fn restore_clipboard_generation(clipboard_restore: &Arc<Mutex<ClipboardRestore>>, generation: u64) {
let mut restore = clipboard_restore
.lock()
.unwrap_or_else(|error| error.into_inner());
if restore.generation != generation {
return;
}
if restore.last_sequence != Some(clipboard_sequence()) {
restore.original = None;
restore.last_sequence = None;
return;
}
let Some(snapshot) = restore.original.take() else {
restore.last_sequence = None;
return;
};
restore.last_sequence = None;
let result = arboard::Clipboard::new()
.wrap_err("could not reopen the Windows clipboard")
.and_then(|mut clipboard| snapshot.restore(&mut clipboard));
if let Err(error) = result {
tracing::warn!(%error, "could not restore the previous Windows clipboard");
}
}
/// Waits, without a deadline, until Shift, Alt, and Win are up: held, they
/// would turn the synthesized Ctrl+V (or Ctrl+Shift+V, whose Shift Hex
/// presses and releases itself) into a different shortcut. A held Ctrl
/// is harmless, so the user may keep it down after finishing with a chord.
fn wait_for_conflicting_modifiers() {
while [VK_SHIFT, VK_MENU, VK_LWIN, VK_RWIN]
.into_iter()
.any(key_down)
{
thread::sleep(Duration::from_millis(10));
}
}
/// Ctrl plus `key` (Ctrl+Shift plus `key` with `shift`), leaving a Ctrl the
/// user physically holds (`control_held`) untouched: synthesizing its
/// release would leave Windows thinking it is up while the user holds it.
/// Shift goes down after Ctrl and comes up before it. Each key carries its
/// scan code (`scan`), as a physical press does.
fn control_chord(
key: u16,
shift: bool,
control_held: bool,
scan: impl Fn(u16) -> u16,
) -> Vec<INPUT> {
let input = |key, flags| keyboard_input(key, scan(key), flags);
let mut inputs = Vec::with_capacity(6);
if !control_held {
inputs.push(input(VK_CONTROL, 0));
}
if shift {
inputs.push(input(VK_SHIFT, 0));
}
inputs.push(input(key, 0));
inputs.push(input(key, KEYEVENTF_KEYUP));
if shift {
inputs.push(input(VK_SHIFT, KEYEVENTF_KEYUP));
}
if !control_held {
inputs.push(input(VK_CONTROL, KEYEVENTF_KEYUP));
}
inputs
}
/// The scan code of `key` in the foreground window's keyboard layout.
/// Chromium apps derive `KeyboardEvent.code` from it, and VS Code matches
/// its keybindings by that code: without one, its terminal never saw Ctrl+V
/// as Paste and sent ^V to the program inside it (#618).
fn foreground_scan_code(key: u16) -> u16 {
// SAFETY: plain Win32 queries; a null process-ID pointer is allowed.
unsafe {
let thread = GetWindowThreadProcessId(GetForegroundWindow(), std::ptr::null_mut());
MapVirtualKeyExW(u32::from(key), MAPVK_VK_TO_VSC, GetKeyboardLayout(thread)) as u16
}
}
fn key_down(key: u16) -> bool {
unsafe { GetAsyncKeyState(i32::from(key)) < 0 }
}
/// Whether `window` is the desktop or a taskbar rather than a window a paste
/// can land in. The window is not in front, so the foreground thread's focus
/// says nothing about it: its class and process alone decide.
pub(crate) fn is_shell_window(window: HWND) -> bool {
if window.is_null() {
return true;
}
let class = window_class(window);
if !crate::dictation::paste_target::is_shell_class(&class) {
return false;
}
let application = crate::windows::input::window_process_path(window).and_then(|path| {
path.file_stem()
.map(|stem| stem.to_string_lossy().to_lowercase())
});
is_shell_target(Some(&class), application.as_deref(), None)
}
/// Brings the capture's window back to the front when it is still the same
/// process's window and another process can paste into it, and says whether
/// it arrived within [`RETURN_TIMEOUT`]. The shell, Hex's own window, a
/// minimized window, and a handle whose process changed are left alone.
fn bring_to_front(capture: CaptureWindow) -> bool {
let window = capture.window as HWND;
// SAFETY: plain queries on a window that may have closed or been reused
// since it was remembered; `IsWindow`, the pid it had at capture start,
// and `IsIconic` vet the handle before the foreground request.
unsafe {
if IsWindow(window) == 0 || IsWindowVisible(window) == 0 || IsIconic(window) != 0 {
return false;
}
let mut pid = 0_u32;
let thread = GetWindowThreadProcessId(window, &mut pid);
if thread == 0
|| pid != capture.pid
|| pid == GetCurrentProcessId()
|| is_shell_window(window)
{
return false;
}
SetForegroundWindow(window);
}
let started = Instant::now();
loop {
// SAFETY: plain query.
if unsafe { GetForegroundWindow() } == window {
return true;
}
if started.elapsed() >= RETURN_TIMEOUT {
return false;
}
thread::sleep(RETURN_POLL);
}
}
fn send_paste_shortcut(shift: bool) -> Result<()> {
let inputs = control_chord(VK_V, shift, key_down(VK_CONTROL), foreground_scan_code);
let sent = send_inputs(&inputs);
if sent != inputs.len() as u32 {
// Release only what this chord pressed; never a key the user holds.
let cleanup = inputs
.iter()
.filter(|input| unsafe { input.Anonymous.ki.dwFlags } & KEYEVENTF_KEYUP != 0)
.copied()
.collect::<Vec<_>>();
send_inputs(&cleanup);
return Err(eyre!(
"Windows accepted only {sent} of {} synthetic paste events; an elevated target window may reject input",
inputs.len()
));
}
Ok(())
}
fn send_inputs(inputs: &[INPUT]) -> u32 {
unsafe {
SendInput(
inputs.len() as u32,
inputs.as_ptr(),
size_of::<INPUT>() as i32,
)
}
}
fn keyboard_input(key: u16, scan: u16, flags: u32) -> INPUT {
INPUT {
r#type: INPUT_KEYBOARD,
Anonymous: INPUT_0 {
ki: KEYBDINPUT {
wVk: key,
wScan: scan,
dwFlags: flags,
time: 0,
dwExtraInfo: crate::windows::input::HEX_INJECTED,
},
},
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn back_to_back_dictations_join_until_input_breaks_the_session() {
let activity = InputActivity::default();
let mut continuation = Continuation::default();
let revision = activity.revision();
continuation.record(revision, true, "day?".into());
assert_eq!(
text_to_paste(&continuation, activity.revision(), "Oh yeah"),
" Oh yeah"
);
activity.invalidate();
assert_eq!(
text_to_paste(&continuation, activity.revision(), "Oh yeah"),
"Oh yeah"
);
}
#[test]
fn rapid_pastes_keep_the_original_clipboard_for_the_latest_restore() {
let mut restore = ClipboardRestore::default();
let first = restore.register(Some(ClipboardSnapshot::Text("original".into())), 10, 11);
let second = restore.register(Some(ClipboardSnapshot::Text("first paste".into())), 11, 12);
assert_ne!(first, second);
assert_eq!(restore.last_sequence, Some(12));
assert!(matches!(
restore.original.as_ref(),
Some(ClipboardSnapshot::Text(text)) if text == "original"
));
}
#[test]
fn keeping_the_paste_cancels_a_pending_restore() {
let mut restore = ClipboardRestore::default();
let generation = restore.register(Some(ClipboardSnapshot::Text("original".into())), 10, 11);
restore.keep();
assert_ne!(restore.generation, generation);
assert!(restore.original.is_none());
assert_eq!(restore.last_sequence, None);
}
#[test]
fn an_unreadable_clipboard_still_pastes_and_restores_nothing() {
let mut restore = ClipboardRestore::default();
restore.register(Some(ClipboardSnapshot::Text("old".into())), 1, 2);
restore.register(None, 10, 11);
assert_eq!(restore.last_sequence, Some(11));
assert!(restore.original.is_none());
}
#[test]
fn remote_desktop_clients_get_the_slower_paste() {
assert!(is_remote_desktop(Some("mstsc")));
assert!(is_remote_desktop(Some("msrdc")));
assert!(!is_remote_desktop(Some("notepad")));
assert!(!is_remote_desktop(None));
}
#[test]
fn terminal_paste_sends_plain_control_v_to_java_games() {
assert!(paste_with_shift_into(Some("windowsterminal"), true));
assert!(paste_with_shift_into(None, true));
assert!(!paste_with_shift_into(Some("javaw"), true));
assert!(!paste_with_shift_into(Some("java"), true));
assert!(!paste_with_shift_into(Some("notepad"), false));
}
#[test]
fn a_terminal_paste_capture_overrides_the_saved_setting() {
assert!(shift_paste(true, false));
assert!(shift_paste(false, true));
assert!(shift_paste(true, true));
assert!(!shift_paste(false, false));
}
/// US-layout scan codes for the chord's keys.
fn scan(key: u16) -> u16 {
match key {
VK_CONTROL => 0x1D,
VK_SHIFT => 0x2A,
VK_V => 0x2F,
_ => 0,
}
}
#[test]
fn paste_chords_carry_each_keys_scan_code() {
let inputs = control_chord(VK_V, true, false, scan);
assert!(inputs.iter().all(|input| {
let ki = unsafe { input.Anonymous.ki };
ki.wScan == scan(ki.wVk) && ki.wScan != 0
}));
}
fn keys(inputs: &[INPUT]) -> Vec<(u16, bool)> {
inputs
.iter()
.map(|input| {
let ki = unsafe { input.Anonymous.ki };
(ki.wVk, ki.dwFlags & KEYEVENTF_KEYUP != 0)
})
.collect()
}
#[test]
fn paste_chords_press_shift_inside_control_and_leave_a_held_control_alone() {
assert_eq!(
keys(&control_chord(VK_V, false, false, scan)),
[
(VK_CONTROL, false),
(VK_V, false),
(VK_V, true),
(VK_CONTROL, true)
]
);
assert_eq!(
keys(&control_chord(VK_V, false, true, scan)),
[(VK_V, false), (VK_V, true)]
);
assert_eq!(
keys(&control_chord(VK_V, true, false, scan)),
[
(VK_CONTROL, false),
(VK_SHIFT, false),
(VK_V, false),
(VK_V, true),
(VK_SHIFT, true),
(VK_CONTROL, true)
]
);
assert_eq!(
keys(&control_chord(VK_V, true, true, scan)),
[
(VK_SHIFT, false),
(VK_V, false),
(VK_V, true),
(VK_SHIFT, true)
]
);
}
}