private static void SendString(string str)
{
List <VK> modifiers = new List <VK>();
bool use_gtk_hack = false, use_office_hack = false;
const int len = 256;
StringBuilder buf = new StringBuilder(len);
var hwnd = NativeMethods.GetForegroundWindow();
if (NativeMethods.GetClassName(hwnd, buf, len) > 0)
{
string wclass = buf.ToString();
/* HACK: GTK+ applications behave differently with Unicode, and some
* applications such as XChat for Windows rename their own top-level
* window, so we parse through the names we know in order to detect
* a GTK+ application. */
if (wclass == "gdkWindowToplevel" || wclass == "xchatWindowToplevel")
{
use_gtk_hack = true;
}
/* HACK: in MS Office, some symbol insertions change the text font
* without returning to the original font. To avoid this, we output
* a space character, then go left, insert our actual symbol, then
* go right and backspace. */
/* These are the actual window class names for Outlook and Word…
* TODO: PowerPoint ("PP(7|97|9|10)FrameClass") */
if (wclass == "rctrl_renwnd32" || wclass == "OpusApp")
{
use_office_hack = true && Settings.InsertZwsp.Value;
}
}
/* Clear keyboard modifiers if we need one of our custom hacks */
if (use_gtk_hack || use_office_hack)
{
VK[] all_modifiers = new VK[]
{
VK.LSHIFT, VK.RSHIFT,
VK.LCONTROL, VK.RCONTROL,
VK.LMENU, VK.RMENU,
};
foreach (VK vk in all_modifiers)
{
if ((NativeMethods.GetKeyState(vk) & 0x80) == 0x80)
{
modifiers.Add(vk);
}
}
foreach (VK vk in modifiers)
{
SendKeyUp(vk);
}
}
if (use_gtk_hack)
{
foreach (var ch in str)
{
if (false)
{
/* FIXME: there is a possible optimisation here where we do
* not have to send the whole unicode sequence for regular
* ASCII characters. However, SendKeyPress() needs a VK, so
* we need an ASCII to VK conversion method, together with
* the proper keyboard modifiers. Maybe not worth it.
* Also, we cannot use KeySequence because GTK+ seems to
* ignore SendInput(). */
//SendKeyPress((VK)char.ToUpper(ch));
}
else
{
/* Wikipedia says Ctrl+Shift+u, release, then type the four
* hex digits, and press Enter.
* (http://en.wikipedia.org/wiki/Unicode_input). */
SendKeyDown(VK.LCONTROL);
SendKeyDown(VK.LSHIFT);
SendKeyPress((VK)'U');
SendKeyUp(VK.LSHIFT);
SendKeyUp(VK.LCONTROL);
foreach (var key in String.Format("{0:X04} ", (short)ch))
{
SendKeyPress((VK)key);
}
}
}
}
else
{
InputSequence Seq = new InputSequence();
if (use_office_hack)
{
Seq.AddInput((ScanCodeShort)'\u200b');
Seq.AddInput((VirtualKeyShort)VK.LEFT);
}
foreach (char ch in str)
{
Seq.AddInput((ScanCodeShort)ch);
}
if (use_office_hack)
{
Seq.AddInput((VirtualKeyShort)VK.RIGHT);
}
Seq.Send();
}
/* Restore keyboard modifiers if we needed one of our custom hacks */
if (use_gtk_hack || use_office_hack)
{
foreach (VK vk in modifiers)
{
SendKeyDown(vk);
}
}
}
private static bool OnKeyInternal(WM ev, VK vk, SC sc, LLKHF flags)
{
//CheckKeyboardLayout();
bool is_keydown = (ev == WM.KEYDOWN || ev == WM.SYSKEYDOWN);
bool is_keyup = !is_keydown;
bool is_capslock_hack = false;
bool has_shift = (NativeMethods.GetKeyState(VK.SHIFT) & 0x80) != 0;
bool has_altgr = (NativeMethods.GetKeyState(VK.LCONTROL) &
NativeMethods.GetKeyState(VK.RMENU) & 0x80) != 0;
bool has_lrshift = (NativeMethods.GetKeyState(VK.LSHIFT) &
NativeMethods.GetKeyState(VK.RSHIFT) & 0x80) != 0;
bool has_capslock = NativeMethods.GetKeyState(VK.CAPITAL) != 0;
// Guess what the system would print if we weren’t interfering. If
// a printable representation exists, use that. Otherwise, default
// to its virtual key code.
Key key = VkToKey(vk, sc, flags, has_shift, has_altgr, has_capslock);
// If Caps Lock is on, and the Caps Lock hack is enabled, we check
// whether this key without Caps Lock gives a non-ASCII alphabetical
// character. If so, we replace “result” with the lowercase or
// uppercase variant of that character.
if (has_capslock && Settings.CapsLockCapitalizes.Value)
{
Key alt_key = VkToKey(vk, sc, flags, has_shift, has_altgr, false);
if (alt_key.IsPrintable() && alt_key.ToString()[0] > 0x7f)
{
string str_upper = alt_key.ToString().ToUpper();
string str_lower = alt_key.ToString().ToLower();
if (str_upper != str_lower)
{
key = new Key(has_shift ? str_lower : str_upper);
is_capslock_hack = true;
}
}
}
// Update statistics
if (is_keydown)
{
// Update single key statistics
Stats.AddKey(key);
// Update key pair statistics if applicable
if (DateTime.Now < m_last_key_time.AddMilliseconds(2000) &&
m_last_key != null)
{
Stats.AddPair(m_last_key, key);
}
// Remember when we pressed a key for the last time
m_last_key_time = DateTime.Now;
m_last_key = key;
}
// FIXME: we don’t properly support compose keys that also normally
// print stuff, such as `.
if (key == Settings.ComposeKey.Value)
{
// If we receive a keyup for the compose key while in emulation
// mode, we’re done. Send a KeyUp event and exit emulation mode.
if (is_keyup && CurrentState == State.Combination)
{
Log.Debug("Combination Off");
CurrentState = State.Idle;
m_compose_down = false;
// If relevant, send an additional KeyUp for the opposite
// key; experience indicates that it helps unstick some
// applications such as mintty.exe.
switch (Settings.ComposeKey.Value.VirtualKey)
{
case VK.LMENU: SendKeyUp(VK.RMENU); break;
case VK.RMENU: SendKeyUp(VK.LMENU); break;
case VK.LSHIFT: SendKeyUp(VK.RSHIFT); break;
case VK.RSHIFT: SendKeyUp(VK.LSHIFT); break;
case VK.LCONTROL: SendKeyUp(VK.RCONTROL); break;
case VK.RCONTROL: SendKeyUp(VK.LCONTROL); break;
}
return(false);
}
if (is_keydown && !m_compose_down)
{
// FIXME: we don't want compose + compose to disable composing,
// since there are compose sequences that use Multi_key.
switch (CurrentState)
{
case State.Sequence:
// FIXME: also, if a sequence was in progress, print it!
CurrentState = State.Idle;
m_sequence.Clear();
break;
case State.Idle:
CurrentState = State.Sequence;
// Lauch the sequence reset expiration thread
// FIXME: do we need to launch a new thread each time the
// compose key is pressed? Let's have a dormant thread instead
if (Settings.ResetDelay.Value > 0)
{
new Thread(() =>
{
while (CurrentState == State.Sequence &&
DateTime.Now < m_last_key_time.AddMilliseconds(Settings.ResetDelay.Value))
{
Thread.Sleep(50);
}
ResetSequence();
}).Start();
}
break;
}
Log.Debug("{0} Composing", IsComposing() ? "Now" : "No Longer");
}
m_compose_down = is_keydown;
return(true);
}
// Feature: emulate capslock key with both shift keys, and optionally
// disable capslock using only one shift key.
if (key.VirtualKey == VK.LSHIFT || key.VirtualKey == VK.RSHIFT)
{
if (is_keyup && has_lrshift && Settings.EmulateCapsLock.Value)
{
SendKeyPress(VK.CAPITAL);
return(false);
}
if (is_keydown && has_capslock && Settings.ShiftDisablesCapsLock.Value)
{
SendKeyPress(VK.CAPITAL);
return(false);
}
}
// If we are not currently composing a sequence, do nothing unless
// one of our hacks forces us to send the key as a string (for
// instance the Caps Lock capitalisation feature).
if (CurrentState != State.Sequence)
{
if (is_capslock_hack && is_keydown)
{
SendString(key.ToString());
return(true);
}
// If this was a dead key, it will be completely ignored. But
// it’s okay since we stored it.
return(false);
}
// If the compose key is down and the user pressed a new key, maybe
// they want to do a key combination instead of composing, such as
// Alt+Tab or Windows+Up. So we abort composing and send the KeyDown
// event for the Compose key that we previously discarded.
//
// Never do this if the event is KeyUp.
// Never do this if we already started a sequence
// Never do this if the key is a modifier key such as shift or alt.
if (m_compose_down && is_keydown &&
m_sequence.Count == 0 && !key.IsModifier() &&
(Settings.KeepOriginalKey.Value || !key.IsUsable()))
{
Log.Debug("Combination On");
ResetSequence();
SendKeyDown(Settings.ComposeKey.Value.VirtualKey);
CurrentState = State.Combination;
return(false);
}
// If the key can't be used in a sequence, just ignore it.
if (!key.IsUsable())
{
return(false);
}
// If we reached this point, everything else ignored this key, so it
// is a key we must add to the current sequence.
if (is_keydown)
{
Log.Debug("Adding To Sequence: {0}", key.FriendlyName);
return(AddToSequence(key));
}
return(true);
}
private static bool OnKeyInternal(WM ev, VK vk, SC sc, LLKHF flags)
{
bool is_keydown = (ev == WM.KEYDOWN || ev == WM.SYSKEYDOWN);
bool is_keyup = !is_keydown;
bool add_to_sequence = is_keydown;
bool is_capslock_hack = false;
bool has_shift = (NativeMethods.GetKeyState(VK.SHIFT) & 0x80) != 0;
bool has_altgr = (NativeMethods.GetKeyState(VK.LCONTROL) &
NativeMethods.GetKeyState(VK.RMENU) & 0x80) != 0;
bool has_lrshift = (NativeMethods.GetKeyState(VK.LSHIFT) &
NativeMethods.GetKeyState(VK.RSHIFT) & 0x80) != 0;
bool has_capslock = NativeMethods.GetKeyState(VK.CAPITAL) != 0;
// Guess what the system would print if we weren’t interfering. If
// a printable representation exists, use that. Otherwise, default
// to its virtual key code.
Key key = KeyboardLayout.VkToKey(vk, sc, flags, has_shift, has_altgr, has_capslock);
// Special handling of Left Control on keyboards with AltGr
if (KeyboardLayout.HasAltGr && key.VirtualKey == VK.LCONTROL)
{
// If this is a key down event with LLKHF_ALTDOWN but no Alt key
// is down, it is actually AltGr.
if (is_keydown && (flags & LLKHF.ALTDOWN) != 0 &&
((NativeMethods.GetKeyState(VK.LMENU) |
NativeMethods.GetKeyState(VK.RMENU)) & 0x80) == 0)
{
m_control_key_was_altgr = true;
return(true);
}
// If this is a key up event bug Left Control is not down, it is
// actually AltGr.
if (is_keyup && m_control_key_was_altgr)
{
m_control_key_was_altgr = false;
return(true);
}
m_control_key_was_altgr = false;
}
// If Caps Lock is on, and the Caps Lock hack is enabled, we check
// whether this key without Caps Lock gives a non-ASCII alphabetical
// character. If so, we replace “result” with the lowercase or
// uppercase variant of that character.
if (has_capslock && Settings.CapsLockCapitalizes.Value)
{
Key alt_key = KeyboardLayout.VkToKey(vk, sc, flags, has_shift, has_altgr, false);
if (alt_key.IsPrintable && alt_key.ToString()[0] > 0x7f)
{
string str_upper = alt_key.ToString().ToUpper();
string str_lower = alt_key.ToString().ToLower();
// Hack for German keyboards: it seems that ToUpper() does
// not properly change ß into ẞ.
if (str_lower == "ß")
{
str_upper = "ẞ";
}
if (str_upper != str_lower)
{
key = new Key(has_shift ? str_lower : str_upper);
is_capslock_hack = true;
}
}
}
// If we are being used to capture a key, send the resulting key.
if (Captured != null)
{
if (is_keyup)
{
Captured.Invoke(key);
}
return(true);
}
// Update statistics
if (is_keydown)
{
// Update single key statistics
Stats.AddKey(key);
// Update key pair statistics if applicable
if (DateTime.Now < m_last_key_time.AddMilliseconds(2000) &&
m_last_key != null)
{
Stats.AddPair(m_last_key, key);
}
// Remember when we pressed a key for the last time
m_last_key_time = DateTime.Now;
m_last_key = key;
}
// If the special Synergy window has focus, we’re actually sending
// keystrokes to another computer; disable WinCompose. Same if it is
// a Cygwin X window.
if (KeyboardLayout.Window.IsOtherDesktop)
{
return(false);
}
// Sanity check in case the configuration changed between two
// key events.
if (m_current_compose_key.VirtualKey != VK.NONE &&
!Settings.ComposeKeys.Value.Contains(m_current_compose_key))
{
CurrentState = State.Idle;
m_current_compose_key = new Key(VK.NONE);
}
// If we receive a keyup for the compose key while in emulation
// mode, we’re done. Send a KeyUp event and exit emulation mode.
if (is_keyup && CurrentState == State.KeyCombination &&
key == m_current_compose_key)
{
bool compose_key_was_altgr = m_compose_key_is_altgr;
Key old_compose_key = m_current_compose_key;
CurrentState = State.Idle;
m_current_compose_key = new Key(VK.NONE);
m_compose_key_is_altgr = false;
m_compose_counter = 0;
Log.Debug("KeyCombination ended (state: {0})", m_state);
// If relevant, send an additional KeyUp for the opposite
// key; experience indicates that it helps unstick some
// applications such as mintty.exe.
switch (old_compose_key.VirtualKey)
{
case VK.LMENU: SendKeyUp(VK.RMENU); break;
case VK.RMENU: SendKeyUp(VK.LMENU);
// If keyup is RMENU and we have AltGr on this
// keyboard layout, send LCONTROL up too.
if (compose_key_was_altgr)
{
SendKeyUp(VK.LCONTROL);
}
break;
case VK.LSHIFT: SendKeyUp(VK.RSHIFT); break;
case VK.RSHIFT: SendKeyUp(VK.LSHIFT); break;
case VK.LCONTROL: SendKeyUp(VK.RCONTROL); break;
case VK.RCONTROL: SendKeyUp(VK.LCONTROL); break;
}
return(false);
}
// If this is the compose key and we’re idle, enter Sequence mode
if (m_compose_counter == 0 && CurrentState == State.Idle &&
is_keydown && Settings.ComposeKeys.Value.Contains(key))
{
CurrentState = State.Sequence;
m_current_compose_key = key;
m_compose_key_is_altgr = key.VirtualKey == VK.RMENU &&
KeyboardLayout.HasAltGr;
++m_compose_counter;
Log.Debug("Now composing (state: {0}) (altgr: {1})",
m_state, m_compose_key_is_altgr);
// Lauch the sequence reset expiration timer
if (Settings.ResetDelay.Value > 0)
{
m_timeout.Change(TimeSpan.FromMilliseconds(Settings.ResetDelay.Value), NEVER);
}
return(true);
}
// If this is a compose key KeyDown event and it’s already down, or it’s
// a KeyUp and it’s already up, eat this event without forwarding it.
if (key == m_current_compose_key &&
is_keydown == ((m_compose_counter & 1) != 0))
{
return(true);
}
// Escape and backspace cancel the current sequence
if (is_keydown && CurrentState == State.Sequence &&
(key.VirtualKey == VK.ESCAPE || key.VirtualKey == VK.BACK))
{
// FIXME: if a sequence was in progress, maybe print it!
ResetSequence();
Log.Debug("No longer composing (state: {0})", m_state);
return(true);
}
// Feature: emulate capslock key with both shift keys, and optionally
// disable capslock using only one shift key.
if (key.VirtualKey == VK.LSHIFT || key.VirtualKey == VK.RSHIFT)
{
if (is_keyup && has_lrshift && Settings.EmulateCapsLock.Value)
{
SendKeyPress(VK.CAPITAL);
return(false);
}
if (is_keydown && has_capslock && Settings.ShiftDisablesCapsLock.Value)
{
SendKeyPress(VK.CAPITAL);
return(false);
}
}
// If we are not currently composing a sequence, do nothing unless
// one of our hacks forces us to send the key as a string (for
// instance the Caps Lock capitalisation feature).
if (CurrentState != State.Sequence)
{
if (is_capslock_hack && is_keydown)
{
SendString(key.ToString());
return(true);
}
// If this was a dead key, it will be completely ignored. But
// it’s okay since we stored it.
Log.Debug("Forwarding {0} “{1}” to system (state: {2})",
is_keydown ? "⭝" : "⭜", key.FriendlyName, m_state);
return(false);
}
//
// From this point we know we are composing
//
// If this is the compose key again, replace its value with our custom
// virtual key.
// FIXME: we don’t properly support compose keys that also normally
// print stuff, such as `.
if (key == m_current_compose_key ||
(Settings.AlwaysCompose.Value && Settings.ComposeKeys.Value.Contains(key)))
{
++m_compose_counter;
key = new Key(VK.COMPOSE);
// If the compose key is AltGr, we only add it to the sequence when
// it’s a KeyUp event, otherwise we may be adding Multi_key to the
// sequence while the user actually wants to enter an AltGr char.
if (m_compose_key_is_altgr && m_compose_counter > 2)
{
add_to_sequence = is_keyup;
}
}
// If the compose key is down and the user pressed a new key, maybe
// instead of composing they want to do a key combination, such as
// Alt+Tab or Windows+Up. So we abort composing and send the KeyDown
// event for the Compose key that we previously discarded. The same
// goes for characters that need AltGr when AltGr is the compose key.
//
// Never do this if the event is KeyUp.
// Never do this if we already started a sequence
// Never do this if the key is a modifier key such as shift or alt.
if (m_compose_counter == 1 && is_keydown &&
m_sequence.Count == 0 && !key.IsModifier())
{
bool keep_original = Settings.KeepOriginalKey.Value;
bool key_unusable = !key.IsUsable();
bool altgr_combination = m_compose_key_is_altgr &&
KeyboardLayout.KeyToAltGrVariant(key) != null;
if (keep_original || key_unusable || altgr_combination)
{
bool compose_key_was_altgr = m_compose_key_is_altgr;
ResetSequence();
if (compose_key_was_altgr)
{
// It’s necessary to use KEYEVENTF_EXTENDEDKEY otherwise the system
// does not understand that we’re sending AltGr.
SendKeyDown(VK.LCONTROL);
SendKeyDown(VK.RMENU, KEYEVENTF.EXTENDEDKEY);
}
else
{
SendKeyDown(m_current_compose_key.VirtualKey);
}
CurrentState = State.KeyCombination;
Log.Debug("KeyCombination started (state: {0})", m_state);
return(false);
}
}
// If the compose key is AltGr and it’s down, check whether the current
// key needs translating.
if (m_compose_key_is_altgr && (m_compose_counter & 1) != 0)
{
Key altgr_variant = KeyboardLayout.KeyToAltGrVariant(key);
if (altgr_variant != null)
{
key = altgr_variant;
// Do as if we already released Compose, otherwise the next KeyUp
// event will cause VK.COMPOSE to be added to the sequence…
++m_compose_counter;
}
}
// If the key can't be used in a sequence, just ignore it.
if (!key.IsUsable())
{
Log.Debug("Forwarding unusable {0} “{1}” to system (state: {2})",
is_keydown ? "⭝" : "⭜", key.FriendlyName, m_state);
return(false);
}
// If we reached this point, everything else ignored this key, so it
// is a key we must add to the current sequence.
if (add_to_sequence)
{
Log.Debug("Adding to sequence: “{0}”", key.FriendlyName);
return(AddToSequence(key));
}
return(true);
}
private static void SendString(string str)
{
List <VK> modifiers = new List <VK>();
/* HACK: GTK+ applications behave differently with Unicode, and some
* applications such as XChat for Windows rename their own top-level
* window, so we parse through the names we know in order to detect
* a GTK+ application. */
bool use_gtk_hack = KeyboardLayout.Window.IsGtk;
/* HACK: Notepad++ and LibreOffice are unable to output high plane
* Unicode characters, so we rely on clipboard hacking when the
* composed string contains such characters. */
bool use_clipboard_hack = KeyboardLayout.Window.IsNPPOrLO &&
HasSurrogates(str);
/* HACK: in MS Office, some symbol insertions change the text font
* without returning to the original font. To avoid this, we output
* a space character, then go left, insert our actual symbol, then
* go right and backspace. */
/* These are the actual window class names for Outlook and Word…
* TODO: PowerPoint ("PP(7|97|9|10)FrameClass") */
bool use_office_hack = KeyboardLayout.Window.IsOffice &&
Settings.InsertZwsp.Value;
/* Clear keyboard modifiers if we need one of our custom hacks */
if (use_gtk_hack || use_office_hack)
{
VK[] all_modifiers =
{
VK.LSHIFT, VK.RSHIFT,
VK.LCONTROL, VK.RCONTROL,
VK.LMENU, VK.RMENU,
/* Needs to be released, too, otherwise Caps Lock + é on
* a French keyboard will print garbage if Caps Lock is
* not released soon enough. See note below. */
VK.CAPITAL,
};
foreach (VK vk in all_modifiers)
{
if ((NativeMethods.GetKeyState(vk) & 0x80) == 0x80)
{
modifiers.Add(vk);
}
}
foreach (VK vk in modifiers)
{
SendKeyUp(vk);
}
}
if (use_gtk_hack)
{
/* XXX: We need to disable caps lock because GTK’s Shift-Ctrl-U
* input mode (see below) doesn’t work when Caps Lock is on. */
bool has_capslock = NativeMethods.GetKeyState(VK.CAPITAL) != 0;
if (has_capslock)
{
SendKeyPress(VK.CAPITAL);
}
foreach (var ch in str)
{
if (false)
{
/* FIXME: there is a possible optimisation here where we do
* not have to send the whole unicode sequence for regular
* ASCII characters. However, SendKeyPress() needs a VK, so
* we need an ASCII to VK conversion method, together with
* the proper keyboard modifiers. Maybe not worth it.
* Also, we cannot use KeySequence because GTK+ seems to
* ignore SendInput(). */
//SendKeyPress((VK)char.ToUpper(ch));
}
else
{
/* Wikipedia says Ctrl+Shift+u, release, then type the four
* hex digits, and press Enter.
* (http://en.wikipedia.org/wiki/Unicode_input). */
SendKeyDown(VK.LCONTROL);
SendKeyDown(VK.LSHIFT);
SendKeyPress((VK)'U');
SendKeyUp(VK.LSHIFT);
SendKeyUp(VK.LCONTROL);
foreach (var key in $"{(short)ch:X04} ")
{
SendKeyPress((VK)key);
}
}
}
if (has_capslock)
{
SendKeyPress(VK.CAPITAL);
}
}
else if (use_clipboard_hack)
{
// We do not use Clipboard.GetDataObject because I have been
// unable to restore the clipboard properly. This is reasonable
// and has been tested with several clipboard content types.
var backup_text = Clipboard.GetText();
var backup_image = Clipboard.GetImage();
var backup_audio = Clipboard.GetAudioStream();
var backup_files = Clipboard.GetFileDropList();
// Use Shift+Insert instead of Ctrl-V because Ctrl-V will misbehave
// if a Shift key is held down. Using Shift+Insert even works if the
// compose key is Insert.
Clipboard.SetText(str);
SendKeyDown(VK.SHIFT);
SendKeyPress(VK.INSERT);
SendKeyUp(VK.SHIFT);
Clipboard.Clear();
if (!string.IsNullOrEmpty(backup_text))
{
Clipboard.SetText(backup_text);
}
if (backup_image != null)
{
Clipboard.SetImage(backup_image);
}
if (backup_audio != null)
{
Clipboard.SetAudio(backup_audio);
}
if (backup_files != null && backup_files.Count > 0)
{
Clipboard.SetFileDropList(backup_files);
}
}
else
{
InputSequence Seq = new InputSequence();
if (use_office_hack)
{
Seq.AddInput((ScanCodeShort)'\u200b');
Seq.AddInput((VirtualKeyShort)VK.LEFT);
}
foreach (char ch in str)
{
Seq.AddInput((ScanCodeShort)ch);
}
if (use_office_hack)
{
Seq.AddInput((VirtualKeyShort)VK.RIGHT);
}
Seq.Send();
}
/* Restore keyboard modifiers if we needed one of our custom hacks */
if (use_gtk_hack || use_office_hack)
{
foreach (VK vk in modifiers)
{
SendKeyDown(vk);
}
}
}
private static void SendString(string str)
{
List <VK> modifiers = new List <VK>();
// HACK: GTK+ applications will crash when receiving surrogate pairs through VK.PACKET,
// so we use the Ctrl-Shift-u special sequence.
bool use_gtk_hack = KeyboardLayout.Window.IsGtk &&
str.Any(x => char.IsSurrogate(x));
// HACK: in MS Office, some symbol insertions change the text font
// without returning to the original font. To avoid this, we output
// a space character, then go left, insert our actual symbol, then
// go right and backspace.
// These are the actual window class names for Outlook and Word…
// TODO: PowerPoint ("PP(7|97|9|10)FrameClass")
bool use_office_hack = KeyboardLayout.Window.IsOffice &&
Settings.InsertZwsp.Value;
InputSequence seq = new InputSequence();
// Clear keyboard modifiers if we need one of our custom hacks
if (use_gtk_hack || use_office_hack)
{
VK[] all_modifiers =
{
VK.LSHIFT, VK.RSHIFT,
VK.LCONTROL, VK.RCONTROL,
VK.LMENU, VK.RMENU,
// Needs to be released, too, otherwise Caps Lock + é on
// a French keyboard will print garbage if Caps Lock is
// not released soon enough. See note below.
VK.CAPITAL,
};
modifiers = all_modifiers.Where(x => (NativeMethods.GetKeyState(x) & 0x80) == 0x80)
.ToList();
modifiers.ForEach(vk => seq.AddKeyEvent(EventType.KeyUp, vk));
}
if (use_office_hack)
{
seq.AddUnicodeInput('\u200b');
seq.AddKeyEvent(EventType.KeyUpDown, VK.LEFT);
}
for (int i = 0; i < str.Length; ++i)
{
char ch = str[i];
if (ch == '\n' || ch == '\r')
{
// On some applications (e.g. Chrome or PowerPoint), \n cannot be injected
// through its scancode, so we send the virtual key instead.
seq.AddKeyEvent(EventType.KeyUpDown, VK.RETURN);
}
else if (use_gtk_hack && char.IsSurrogate(ch))
{
// Sanity check
if (i + 1 >= str.Length || !char.IsHighSurrogate(ch) || !char.IsLowSurrogate(str, i + 1))
{
continue;
}
var codepoint = char.ConvertToUtf32(ch, str[++i]);
// GTK+ hack:
// - We need to disable Caps Lock
// - Wikipedia says Ctrl+Shift+u, release, then type the four hex digits,
// and press Enter (http://en.wikipedia.org/wiki/Unicode_input).
// - The Gimp accepts either Enter or Space but stops immediately in both
// cases.
// - Inkscape stops after Enter, but allows to chain sequences using Space.
bool has_capslock = NativeMethods.GetKeyState(VK.CAPITAL) != 0;
if (has_capslock)
{
seq.AddKeyEvent(EventType.KeyUpDown, VK.CAPITAL);
}
seq.AddKeyEvent(EventType.KeyDown, VK.LCONTROL);
seq.AddKeyEvent(EventType.KeyDown, VK.LSHIFT);
seq.AddKeyEvent(EventType.KeyUpDown, VK.U);
seq.AddKeyEvent(EventType.KeyUp, VK.LSHIFT);
seq.AddKeyEvent(EventType.KeyUp, VK.LCONTROL);
foreach (var key in $"{codepoint:X04}")
{
seq.AddKeyEvent(EventType.KeyUpDown, (VK)key);
}
seq.AddKeyEvent(EventType.KeyUpDown, VK.RETURN);
if (has_capslock)
{
seq.AddKeyEvent(EventType.KeyUpDown, VK.CAPITAL);
}
}
else
{
seq.AddUnicodeInput(ch);
}
}
if (use_office_hack)
{
seq.AddKeyEvent(EventType.KeyUpDown, VK.RIGHT);
}
// Restore keyboard modifier state if we needed one of our custom hacks
modifiers.ForEach(vk => seq.AddKeyEvent(EventType.KeyDown, vk));
// Send the whole keyboard sequence
seq.Send();
}
