Пример #1
0
        /// <summary>
        /// Initialize the composer.
        /// </summary>
        public static void Init()
        {
            KeyboardLeds.StartMonitoring();
            KeyboardLayout.CheckForChanges();

            m_timeout       = new DispatcherTimer();
            m_timeout.Tick += (o, e) => ResetSequence();
        }
Пример #2
0
        /// <summary>
        /// Get input from the keyboard hook; return true if the key was handled
        /// and needs to be removed from the input chain.
        /// </summary>
        public static bool OnKey(WM ev, VK vk, SC sc, LLKHF flags)
        {
            // Remember when the user touched a key for the last time
            m_last_key_time = DateTime.Now;

            // We need to check the keyboard layout before we save the dead
            // key, otherwise we may be saving garbage.
            KeyboardLayout.CheckForChanges();

            KeyboardLayout.SaveDeadKey();
            bool ret = OnKeyInternal(ev, vk, sc, flags);

            KeyboardLayout.RestoreDeadKey();

            return(ret);
        }
Пример #3
0
        /// <summary>
        /// Get input from the keyboard hook; return true if the key was handled
        /// and needs to be removed from the input chain.
        /// </summary>
        public static bool OnKey(WM ev, VK vk, SC sc, LLKHF flags)
        {
            // Remember when the user touched a key for the last time
            m_last_key_time = DateTime.Now;

            // Do nothing if we are disabled; NOTE: this disables stats, too
            if (Settings.Disabled.Value)
            {
                return(false);
            }

            // We need to check the keyboard layout before we save the dead
            // key, otherwise we may be saving garbage.
            KeyboardLayout.CheckForChanges();

            KeyboardLayout.SaveDeadKey();
            bool ret = OnKeyInternal(ev, vk, sc, flags);

            KeyboardLayout.RestoreDeadKey();

            return(ret);
        }
Пример #4
0
 /// <summary>
 /// Initialize the composer.
 /// </summary>
 public static void Init()
 {
     StartMonitoringKeyboardLeds();
     KeyboardLayout.CheckForChanges();
 }
Пример #5
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);

            // 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_keydown)
                {
                    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 (is_keydown && Settings.ComposeKeys.Value.Contains(key) &&
                m_compose_counter == 0 && CurrentState == State.Idle)
            {
                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 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 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 == m_current_compose_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 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);
        }