Пример #1
0
 /// <summary>
 /// Add a pair of pressed keys to the stats
 /// </summary>
 /// <param name="key_a"></param>
 /// <param name="key_b"></param>
 public static void AddPair(Key key_a, Key key_b)
 {
     int count = 0;
     KeySequence s = new KeySequence() { key_a, key_b };
     m_pair_stats.TryGetValue(s, out count);
     m_pair_stats[s] = count + 1;
 }
Пример #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 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);
                Log.Debug("Valid sequence! Sending {0}", tosend);
                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);
                Log.Debug("Sending previously valid sequence {0}", tosend);
                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;
    }
Пример #3
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 compose_is_altgr = m_possible_altgr_keys.Count > 0
                       && Settings.ComposeKey.Value.VirtualKey == VK.RMENU;

        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();

                // 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;
                }
            }
        }

        // 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.
        if (m_window_is_synergy)
        {
            return false;
        }

        // 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 && key == Settings.ComposeKey.Value
             && CurrentState == State.Combination)
        {
            Log.Debug("Combination Off");
            CurrentState = State.Idle;
            m_compose_counter = 0;

            // 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);
                               if (compose_is_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 (is_keydown && key == Settings.ComposeKey.Value
             && m_compose_counter == 0 && CurrentState == State.Idle)
        {
            Log.Debug("Now Composing");
            CurrentState = State.Sequence;
            ++m_compose_counter;

            // 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();
            }

            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 == Settings.ComposeKey.Value
             && 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!
            Log.Debug("No Longer Composing");
            ResetSequence();
            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 Key to System (not composing)");
            return false;
        }

        // 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 = compose_is_altgr &&
                        m_possible_altgr_keys.ContainsKey(key.ToString());

            if (keep_original || key_unusable || altgr_combination)
            {
                Log.Debug("Combination On");
                ResetSequence();
                if (compose_is_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(Settings.ComposeKey.Value.VirtualKey);
                }
                CurrentState = State.Combination;
                return false;
            }
        }

        // If this is the compose key again, use our custom virtual key
        // FIXME: we don’t properly support compose keys that also normally
        // print stuff, such as `.
        if (key == Settings.ComposeKey.Value)
        {
            ++m_compose_counter;
            key = new Key(VK.COMPOSE);

            // If the compose key is AltGr, we only add it to the sequence
            // if it’s a KeyUp event, otherwise we may be adding Multi_key to the
            // sequence when the user actually wants to enter an AltGr char.
            if (compose_is_altgr && m_compose_counter > 2)
                add_to_sequence = is_keyup;
        }

        // If the compose key is AltGr and it’s down, check whether the current
        // key needs translating.
        if (compose_is_altgr && (m_compose_counter & 1) != 0)
        {
            string altgr_variant;
            if (m_possible_altgr_keys.TryGetValue(key.ToString(), out altgr_variant))
            {
                key = new 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 Key to System (no possible sequence uses it)");
            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;
    }
Пример #4
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;
    }
Пример #5
0
 public static bool IsUsableKey(Key key)
 {
     return key.IsPrintable() || m_key_names.ContainsValue(key);
 }
Пример #6
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 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 key was just pressed. If we can not find a printable
        // representation for the key, default to its virtual key code.
        Key key = new Key(vk);

        byte[] keystate = new byte[256];
        NativeMethods.GetKeyboardState(keystate);
        keystate[(int)VK.SHIFT] = (byte)(has_shift ? 0x80 : 0x00);
        keystate[(int)VK.CONTROL] = (byte)(has_altgr ? 0x80 : 0x00);
        keystate[(int)VK.MENU] = (byte)(has_altgr ? 0x80 : 0x00);
        keystate[(int)VK.CAPITAL] = (byte)(has_capslock ? 0x01 : 0x00);



        string str_if_normal = KeyToUnicode(vk, sc, keystate, flags);
        string str_if_dead = KeyToUnicode(VK.SPACE);
        if (str_if_normal != "")
        {
            // This appears to be a normal, printable key
            key = new Key(str_if_normal);
        }
        else if (str_if_dead != " ")
        {
            // This appears to be a dead key
            key = new Key(str_if_dead);
        }

        // Special case: we don't consider characters such as Esc as printable
        // otherwise they are not properly serialised in the config file.
        if (key.IsPrintable() && key.ToString()[0] < ' ')
        {
            key = new Key(vk);
        }

        Log("WM.{0} {1} (VK:0x{2:X02} SC:0x{3:X02})",
            ev.ToString(), key.FriendlyName, (int)vk, (int)sc);

        // FIXME: we don’t properly support compose keys that also normally
        // print stuff, such as `.
        if (key == Settings.ComposeKey.Value)
        {
            if (is_keyup)
            {
                // If we receive a keyup for the compose key, but we hadn't
                // previously marked it as down, it means we're in emulation
                // mode and we need to cancel it.
                if (!m_compose_down)
                {
                    Log("Fallback Off");
                    SendKeyUp(Settings.ComposeKey.Value.VirtualKey);
                }

                m_compose_down = false;
            }
            else 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.
                // FIXME: also, if a sequence was in progress, print it!
                m_compose_down = true;
                m_composing = !m_composing;
                if (!m_composing)
                    m_sequence.Clear();

                Log("{0} Composing", m_composing ? "Now" : "No Longer");

                // 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 (m_composing && Settings.ResetDelay.Value > 0)
                {
                    new Thread(() =>
                    {
                        while (m_composing && DateTime.Now < m_last_key_time.AddMilliseconds(Settings.ResetDelay.Value))
                            Thread.Sleep(50);
                        ResetSequence();
                    }).Start();
                }
            }

            Changed(null, new EventArgs());

            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. But if
        // this was a dead key, eat it.
        if (!m_composing)
        {
            return false;
        }

        // If the compose key is down, maybe there is a key combination
        // going on, such as Alt+Tab or Windows+Up, so we abort composing
        // and tell the OS that the key is down.
        if (m_compose_down && (Settings.KeepOriginalKey.Value
                                || !Settings.IsUsableKey(key)))
        {
            Log("Fallback On");
            ResetSequence();
            SendKeyDown(Settings.ComposeKey.Value.VirtualKey);
            return false;
        }

        // If the key can't be used in a sequence, just ignore it.
        if (!Settings.IsUsableKey(key))
        {
            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)
        {
            return AddToSequence(key);
        }

        return true;
    }
Пример #7
0
 /// <summary>
 /// Add a pressed key to the stats
 /// </summary>
 /// <param name="key"></param>
 public static void AddKey(Key key)
 {
     int count = 0;
     m_key_stats.TryGetValue(key, out count);
     m_key_stats[key] = count + 1;
 }