/// <summary>
/// Add a key to the sequence currently being built. If necessary, output
/// the finished sequence or trigger actions for invalid sequences.
/// </summary>
private static bool AddToSequence(Key key)
{
KeySequence old_sequence = new KeySequence(m_sequence);
m_sequence.Add(key);
// We try the following, in this order:
// 1. if m_sequence + key is a valid prefix, it means the user
// could type other characters to build a longer sequence,
// so just append key to m_sequence.
// 2. if m_sequence + key is a valid sequence, we can't go further,
// we append key to m_sequence and output the result.
// 3. if m_sequence is a valid sequence, the user didn't type a
// valid key, so output the m_sequence result _and_ process key.
// 4. (optionally) try again 1. 2. and 3. ignoring case.
// 5. none of the characters make sense, output all of them as if
// the user didn't press Compose.
foreach (bool ignore_case in Settings.CaseInsensitive.Value ?
new bool[] { false, true } : new bool[] { false })
{
if (Settings.IsValidPrefix(m_sequence, ignore_case))
{
// Still a valid prefix, continue building sequence
return(true);
}
if (Settings.IsValidSequence(m_sequence, ignore_case))
{
string tosend = Settings.GetSequenceResult(m_sequence,
ignore_case);
Stats.AddSequence(m_sequence);
ResetSequence();
SendString(tosend);
return(true);
}
// Some code duplication with the above block, but this way
// what we are doing is more clear.
if (Settings.IsValidSequence(old_sequence, ignore_case))
{
string tosend = Settings.GetSequenceResult(old_sequence,
ignore_case);
Stats.AddSequence(old_sequence);
ResetSequence();
SendString(tosend);
return(false);
}
}
// Unknown characters for sequence, print them if necessary
if (!Settings.DiscardOnInvalid.Value)
{
foreach (Key k in m_sequence)
{
// FIXME: what if the key is e.g. left arrow?
if (k.IsPrintable())
{
SendString(k.ToString());
}
}
}
if (Settings.BeepOnInvalid.Value)
{
SystemSounds.Beep.Play();
}
ResetSequence();
return(true);
}
/// <summary>
/// Add a key to the sequence currently being built. If necessary, output
/// the finished sequence or trigger actions for invalid sequences.
/// </summary>
private static bool AddToSequence(Key key)
{
KeySequence old_sequence = new KeySequence(m_sequence);
m_sequence.Add(key);
// We try the following, in this order:
// 1. if m_sequence + key is a valid sequence, we don't go further,
// we append key to m_sequence and output the result.
// 2. if m_sequence + key is a valid prefix, it means the user
// could type other characters to build a longer sequence,
// so just append key to m_sequence.
// 3. if m_sequence + key is a valid generic prefix, continue as well.
// 4. if m_sequence + key is a valid sequence, send it.
// 5. (optionally) try again 1. and 2. ignoring case.
// 6. none of the characters make sense, output all of them as if
// the user didn't press Compose.
foreach (bool ignore_case in Settings.CaseInsensitive.Value ?
new bool[] { false, true } : new bool[] { false })
{
if (Settings.IsValidSequence(m_sequence, ignore_case))
{
string tosend = Settings.GetSequenceResult(m_sequence,
ignore_case);
SendString(tosend);
Log.Debug("Valid sequence! Sent “{0}”", tosend);
Stats.AddSequence(m_sequence);
ResetSequence();
return(true);
}
if (Settings.IsValidPrefix(m_sequence, ignore_case))
{
// Still a valid prefix, continue building sequence
return(true);
}
if (!ignore_case)
{
if (Settings.IsValidGenericPrefix(m_sequence))
{
return(true);
}
if (Settings.GetGenericSequenceResult(m_sequence, out var tosend))
{
SendString(tosend);
Log.Debug("Valid generic sequence! Sent “{0}”", tosend);
Stats.AddSequence(m_sequence);
ResetSequence();
return(true);
}
}
// Try to swap characters if the corresponding option is set
if (m_sequence.Count == 2 && Settings.SwapOnInvalid.Value)
{
var other_sequence = new KeySequence()
{
m_sequence[1], m_sequence[0]
};
if (Settings.IsValidSequence(other_sequence, ignore_case))
{
string tosend = Settings.GetSequenceResult(other_sequence,
ignore_case);
SendString(tosend);
Log.Debug("Found swapped sequence! Sent “{0}”", tosend);
Stats.AddSequence(other_sequence);
ResetSequence();
return(true);
}
}
}
// FIXME: At this point we know the key can’t be part of a valid
// sequence, but this should not be a hard error if the key is a
// modifier key.
OnInvalidSequence();
return(true);
}
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)
{
bool is_altgr = false;
// If this is a key down event with LLKHF_ALTDOWN but no Alt key
// is down, it is actually AltGr.
is_altgr |= is_keydown && (flags & LLKHF.ALTDOWN) != 0 &&
((NativeMethods.GetKeyState(VK.LMENU) |
NativeMethods.GetKeyState(VK.RMENU)) & 0x80) == 0;
// If this is a key up event but Left Control is not down, it is
// actually AltGr.
is_altgr |= is_keyup && m_control_down_was_altgr;
m_control_down_was_altgr = is_altgr && is_keydown;
if (is_altgr)
{
// Eat the key if one of our compose keys is AltGr
if (Settings.ComposeKeys.Value.Contains(new Key(VK.RMENU)))
{
goto exit_discard_key;
}
// Otherwise the keypress is not for us, ignore it
goto exit_forward_key;
}
}
// 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.PrintableResult[0] > 0x7f)
{
string str_upper = alt_key.PrintableResult.ToUpper();
string str_lower = alt_key.PrintableResult.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);
}
goto exit_discard_key;
}
// 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)
{
goto exit_forward_key;
}
// Sanity check in case the configuration changed between two
// key events.
if (CurrentComposeKey.VirtualKey != VK.NONE &&
!Settings.ComposeKeys.Value.Contains(CurrentComposeKey))
{
CurrentState = State.Idle;
CurrentComposeKey = new Key(VK.NONE);
}
// Magic sequence handling. If the exact sequence is typed, we
// enter compose state.
if (m_magic_pos < m_magic_sequence.Count &&
m_magic_sequence[m_magic_pos].Key == key.VirtualKey &&
m_magic_sequence[m_magic_pos].Value == is_keydown)
{
++m_magic_pos;
Log.Debug($"Magic key {m_magic_pos}/{m_magic_sequence.Count}");
if (CurrentState == State.Idle && m_magic_pos == m_magic_sequence.Count)
{
CurrentState = State.Sequence;
CurrentComposeKey = new Key(VK.NONE);
Log.Debug($"Magic sequence entered (state: {m_state})");
m_magic_pos = 0;
goto exit_forward_key;
}
}
else
{
m_magic_pos = 0;
}
// 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 == CurrentComposeKey)
{
bool compose_key_was_altgr = m_compose_key_is_altgr;
Key old_compose_key = CurrentComposeKey;
CurrentState = State.Idle;
CurrentComposeKey = 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;
}
goto exit_forward_key;
}
// 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;
CurrentComposeKey = 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.ResetTimeout.Value > 0)
{
m_timeout.Interval = TimeSpan.FromMilliseconds(Settings.ResetTimeout.Value);
m_timeout.Start();
}
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 == CurrentComposeKey &&
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);
goto exit_forward_key;
}
if (is_keydown && has_capslock && Settings.ShiftDisablesCapsLock.Value)
{
SendKeyPress(VK.CAPITAL);
goto exit_forward_key;
}
}
// 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.PrintableResult);
return(true);
}
// If this was a dead key, it will be completely ignored. But
// it’s okay since we stored it.
goto exit_forward_key;
}
//
// From this point we know we are composing
//
if (m_timeout.IsEnabled)
{
// Extend the expiration timer due date
m_timeout.Stop();
m_timeout.Start();
}
// 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 == CurrentComposeKey ||
(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(CurrentComposeKey.VirtualKey);
}
CurrentState = State.KeyCombination;
Log.Debug("KeyCombination started (state: {0})", m_state);
goto exit_forward_key;
}
}
// 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)
{
goto exit_forward_key;
}
// If we reached this point, everything else ignored this key, so it
// is a key we should add to the current sequence.
if (add_to_sequence)
{
Log.Debug("Adding to sequence: “{0}”", key.FriendlyName);
return(AddToSequence(key));
}
exit_discard_key:
return(true);
exit_forward_key:
Log.Debug("Forwarding {0} “{1}” to system (state: {2})",
is_keydown ? "⭝" : "⭜", key.FriendlyName, m_state);
return(false);
}
