예제 #1
0
        /// <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);
        }
예제 #2
0
        /// <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);
        }
예제 #3
0
        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);
        }
예제 #4
0
        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);
        }