Esempio n. 1
0
        private void btnKeyboadHook_Click(object sender, EventArgs e)
        {
            KeyboardHook.Enable();
            KeyboardHook.Add(Keys.S, new KeyboardHook.KeyPressed(TestKeyboadHook));

            bool capsLock   = KeyboardHelper.CapsLock;
            bool numLock    = KeyboardHelper.NumLock;
            bool scrollLock = KeyboardHelper.ScrollLock;

            KeyboardHelper.SendKeys("{TAB}"); //发送Tab键
            KeyboardHelper.SendKeys("%{F4}"); //发送Alt + F4退出
        }
Esempio n. 2
0
        internal IMetaKey Add(IList <ICombination> sequence, KeyEvent keyEvent, KeyCommand command,
                              string stateTree = KeyStateTrees.Default)
        {
            foreach (var combination in sequence)
            {
                foreach (var keyInChord in combination.Chord)
                {
                    foreach (var code in keyInChord.Codes)
                    {
                        var key = (Key)code;
                        if (!key.IsCommonChordKey())
                        {
                            var keyStateTree = KeyStateTree.GetOrCreateStateTree(KeyStateTrees.ChordMap);
                            if (!keyStateTree.Contains(key))
                            {
                                MapOnHit(key.ToCombination(), key.ToCombination(), e => !e.IsVirtual, false);
                            }
                        }
                    }
                }
            }

            return(_hook.Add(sequence, new KeyEventCommand(keyEvent, command), stateTree));
        }
Esempio n. 3
0
        public void EnableLevelSpyKeys(Keys plusKey, Keys minusKey, Keys centerKey, string prefix, string prefixSpy, string prefixCenter)
        {
            spyPlusKey   = plusKey;
            spyMinusKey  = minusKey;
            spyCenterKey = centerKey;

            #region LevelSpy Keys

            KeyboardHook.Add(spyPlusKey, new KeyboardHook.KeyPressed(delegate()
            {
                if (Core.Client.Window.IsActive && Core.Client.LoggedIn)
                {
                    Core.Client.Map.NameSpyOn();
                    Core.Client.Map.FullLightOn();
                    if (Core.Client.Map.LevelSpyOn(floorOfSpy + 1))
                    {
                        floorOfSpy++;
                    }

                    if (floorOfSpy == 0)
                    {
                        Core.Client.Map.LevelSpyOff();

                        if (ShowNames)
                        {
                            Core.Client.Map.NameSpyOn();
                        }
                        else
                        {
                            Core.Client.Map.NameSpyOff();
                        }

                        if (FullLight)
                        {
                            Core.Client.Map.FullLightOn();
                        }
                        else
                        {
                            Core.Client.Map.FullLightOff();
                        }
                    }
                    if (floorOfSpy > 0)
                    {
                        sign = "+";
                    }
                    else
                    {
                        sign = "";
                    }

                    Core.Client.Statusbar = prefix + prefixSpy + sign + floorOfSpy;
                    return(false);
                }
                return(true);
            }));

            KeyboardHook.Add(spyMinusKey, new KeyboardHook.KeyPressed(delegate()
            {
                if (Core.Client.Window.IsActive && Core.Client.LoggedIn)
                {
                    if (floorOfSpy == 0 && Core.Player.Z == 7)
                    {
                        Core.Client.Map.LevelSpyOff();
                        Core.Client.Statusbar = prefix + prefixCenter;
                    }
                    else
                    {
                        Core.Client.Map.NameSpyOn();
                        Core.Client.Map.FullLightOn();

                        if (Core.Client.Map.LevelSpyOn(floorOfSpy - 1))
                        {
                            floorOfSpy--;
                        }

                        if (floorOfSpy == 0)
                        {
                            Core.Client.Map.LevelSpyOff();

                            if (ShowNames)
                            {
                                Core.Client.Map.NameSpyOn();
                            }
                            else
                            {
                                Core.Client.Map.NameSpyOff();
                            }

                            if (FullLight)
                            {
                                Core.Client.Map.FullLightOn();
                            }
                            else
                            {
                                Core.Client.Map.FullLightOff();
                            }
                        }
                        if (floorOfSpy > 0)
                        {
                            sign = "+";
                        }
                        else
                        {
                            sign = "";
                        }

                        Core.Client.Statusbar = prefix + prefixSpy + sign + floorOfSpy;
                    }
                    return(false);
                }
                return(true);
            }));

            KeyboardHook.Add(spyCenterKey, new KeyboardHook.KeyPressed(delegate()
            {
                if (Core.Client.Window.IsActive && Core.Client.LoggedIn)
                {
                    Core.Client.Map.LevelSpyOff();
                    Core.Client.Statusbar = prefix + prefixCenter;
                    Core.Client.Map.NameSpyOn();
                    Core.Client.Map.FullLightOn();
                    return(false);
                }
                return(true);
            }));

            #endregion
        }
Esempio n. 4
0
        protected override void OnLoad(EventArgs e)
        {
            Visible       = false;
            ShowInTaskbar = false;

            hooker.Add("Toggle Play", Keys.MediaPlayPause);
            hooker.Add("Stop", Keys.MediaStop);

            if (stationSwitcher.Checked == true)
            {
                hooker.Add("Next Station", Keys.MediaNextTrack);
                hooker.Add("Previous Station", Keys.MediaPreviousTrack);
            }

            hooker.HotkeyDown += (sender, q) => {
                switch (q.Name)
                {
                case "Toggle Play":
                    _status = Bass.BASS_ChannelIsActive(stream);
                    Console.WriteLine(_status);
                    if (_status == BASSActive.BASS_ACTIVE_STOPPED || _status == BASSActive.BASS_ACTIVE_PAUSED)
                    {
                        play.PerformClick();
                    }
                    else if (_status == BASSActive.BASS_ACTIVE_PLAYING)
                    {
                        pause.PerformClick();
                    }
                    break;

                case "Stop":
                    stop.PerformClick();
                    break;

                case "Previous Station":
                    previous.PerformClick();
                    break;

                case "Next Station":
                    next.PerformClick();
                    break;
                }
            };

            if (enableMMKeys.Checked == true)
            {
                hooker.Hook();
            }
            else
            {
                if (hooker.IsHooked)
                {
                    hooker.Unhook();
                }
            }

            XmlDocument prefs = new XmlDocument();

            prefs.Load(path + "\\preferences.xml");
            XmlNode prefsRoot = prefs.FirstChild;

            if (prefsRoot["autoplay"].InnerText == "true")
            {
                foreach (ToolStripMenuItem item in stations.DropDownItems)
                {
                    foreach (ToolStripMenuItem tmp in item.DropDownItems)
                    {
                        if (tmp.Text == prefsRoot["lastStation"].InnerText)
                        {
                            tmp.PerformClick();
                            break;
                        }
                    }
                }
            }

            base.OnLoad(e);
        }