Пример #1
0
 public static void UnRegisterHotkeys()
 {
     HotkeysManager.Unregister("GGWPBurst");
     HotkeysManager.Unregister("GGWPHoJ");
     HotkeysManager.Unregister("GGWPHoJHealer");
     HotkeysManager.Unregister("GGWPDivineSteed");
 }
Пример #2
0
        private static void RegisterHotkeyAssignment(string name, Keys key, Action <Hotkey> callback)
        {
            Keys         keyCode = key & Keys.KeyCode;
            ModifierKeys mods    = ModifierKeys.NoRepeat;

            if ((key & Keys.Shift) != 0)
            {
                mods |= ModifierKeys.Shift;
            }
            if ((key & Keys.Alt) != 0)
            {
                mods |= ModifierKeys.Alt;
            }
            if ((key & Keys.Control) != 0)
            {
                mods |= ModifierKeys.Control;
            }

            if (name == "LogMark")
            {
                Logger.Write(LogColor.Hilite, "Hotkey: To add a LOGMARK, press: [{0}]", key.ToFormattedString());
            }
            else
            {
                Logger.Write(LogColor.Hilite, "Hotkey: To disable {0}, press: [{1}]", name, key.ToFormattedString());
            }
            HotkeysManager.Register(name, keyCode, mods, callback);
        }
Пример #3
0
        internal static void Stop()
        {
            if (!_HotkeysRegistered)
            {
                return;
            }

            _HotkeysRegistered = false;

            // remove hotkeys for commands with 1:1 key assignment
            HotkeysManager.Unregister("LogMark");
            HotkeysManager.Unregister("AOE");
            HotkeysManager.Unregister("Combat");
            HotkeysManager.Unregister("Movement");

/* Suspend Movement keys have to be polled for now instead of using HotKey interface
 * since defining a HotKey won't allow the key to pass through to game client window
 *
 *          // remove hotkeys for commands with 1:M key assignment
 *          if (_registeredMovementSuspendKeys != null)
 *          {
 *              foreach (var key in _registeredMovementSuspendKeys)
 *              {
 *                  HotkeysManager.Unregister("Movement Suspend(" + key.ToString() + ")");
 *              }
 *          }
 */
        }
Пример #4
0
        public void RegisterAbilityChain(AbilityChain abilityChain)
        {
            if (Main.Product != Product.Premium)
            {
                return;
            }
            if (HotkeysManager.Hotkeys.Any(o => o.Name == "Paws_" + abilityChain.Name))
            {
                return;
            }

            AbilityChains.Add(abilityChain);

            var hotKey = HotkeysManager.Hotkeys.FirstOrDefault(o => o.Name == abilityChain.Name);

            if (hotKey != null)
            {
                HotkeysManager.Unregister(hotKey);
            }

            var registeredHotKey = HotkeysManager.Register("Paws_" + abilityChain.Name, abilityChain.HotKey,
                                                           abilityChain.ModiferKey, KeyIsPressed);

            Log.AbilityChain(string.Format("Ability chain successfully registered ({0}: {1} + {2}).",
                                           registeredHotKey.Name, registeredHotKey.ModifierKeys, registeredHotKey.Key));
        }
Пример #5
0
        public void CreateBehavior()
        {
            foreach (var hk in hotkeys)
            {
                HotkeysManager.Register(hk.Name,
                                        hk.Key,
                                        hk.Mod,
                                        _hk =>
                {
                    SimcraftImpl.inst.toggle_hkvar(hk.Name);
                });
            }

            if (Assembly == null)
            {
                throw new Exception(Name + " has not been compiled");
            }
            var mem = Assembly.GetTypes()[0].GetMembers()[0];
            var typ = Assembly.GetTypes()[0];

            //SimcraftImpl.Write("func: " + mem);

            //SimcraftImpl.Write(

            typ.InvokeMember(mem.Name,
                             BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Static | BindingFlags.InvokeMethod,
                             null, null, new object[0]);

            //PrintResolutionTable();


            //SimcraftImpl.Write(SimcraftImpl.inst.actions.ToString());
        }
Пример #6
0
 public void Unload()
 {
     foreach (var hk in hotkeys)
     {
         HotkeysManager.Unregister(hk.Name);
     }
 }
Пример #7
0
        public MainWindow()
        {
            InitializeComponent();

            // need to setup the global hook. this can go in
            // App.xaml.cs's constructor if you want
            HotkeysManager.SetupSystemHook();

            Closing += MainWindow_Closing;
        }
Пример #8
0
        public MainWindow()
        {
            InitializeComponent();

            HotkeysManager.SetupSystemHook();

            GlobalHotkey hotkey1 = new GlobalHotkey(ModifierKeys.Alt, Key.N, Hotkey1);
            GlobalHotkey hotkey2 = new GlobalHotkey(ModifierKeys.Alt, Key.M, Hotkey2);

            HotkeysManager.AddHotkey(hotkey1);
            HotkeysManager.AddHotkey(hotkey2);

            #region send application to tray

            System.Windows.Forms.NotifyIcon ni = new System.Windows.Forms.NotifyIcon();
            ni.Icon    = new System.Drawing.Icon("image.ico");
            ni.Visible = true;
            ni.Click  +=
                delegate(object sender, EventArgs e)
            {
                this.Show();
                this.WindowState = System.Windows.WindowState.Normal;
            };
            ni.DoubleClick +=
                delegate(object sender, EventArgs e)
            {
                this.WindowState = System.Windows.WindowState.Normal;
                close            = true;
                this.Close();
            };

            #endregion

            audioController = new CoreAudioController();
            defaultOutput   = audioController.DefaultPlaybackDevice;

            var OutputDevices = audioController.GetPlaybackDevices(DeviceState.Active);

            foreach (var device in OutputDevices)
            {
                dropDownMenu.Items.Add(device.FullName);
                dropDownMenu2.Items.Add(device.FullName);
            }

            data = SaveLoadManager.Load();


            if (data != null)
            {
                dropDownMenu.Text  = data.device1Name;
                dropDownMenu2.Text = data.device2Name;
            }

            AddHotKeys();
        }
Пример #9
0
 public static void RemoveHotkeys()
 {
     if (!KeysRegistered)
     {
         return;
     }
     HotkeysManager.Unregister("noAoe");
     NoAoe          = false;
     KeysRegistered = false;
     //Lua.DoString(@"print('Hotkeys: \124cFFE61515 Removed!')");
     Logging.Write(Colors.OrangeRed, "Hotkeys: Removed!");
 }
Пример #10
0
        public static void RegisterHotKeys()
        {
            if (KeysRegistered)
            {
                return;
            }
            CooldownsOn = true;
            NoAoe       = false;
            Questing    = false;
            ForceAttack = false;

            HotkeysManager.Register("noAoe", Keys.V, ModifierKeys.Alt, ret =>
            {
                NoAoe = !NoAoe;
                StyxWoW.Overlay.AddToast((NoAoe ? "Aoe Mode Disabled" : "Aoe Mode Enabled"), 2000);
            });

            HotkeysManager.Register("CooldownsOn", Keys.G, ModifierKeys.Control, ret =>
            {
                CooldownsOn = !CooldownsOn;
                StyxWoW.Overlay.AddToast((CooldownsOn ? "BurstMode Activated!" : "BurstMode Disabled!"), 2000);
            });

            HotkeysManager.Register("Logging", Keys.L, ModifierKeys.Control, ret =>
            {
                Main.Debug = !Main.Debug;
                StyxWoW.Overlay.AddToast((Main.Debug ? "Logging Activated!" : "Logging Disabled!"), 2000);
            });

            HotkeysManager.Register("Quest Mode", Keys.N, ModifierKeys.Control, ret =>
            {
                Questing = !Questing;
                StyxWoW.Overlay.AddToast((Questing ? "Quest Mode Activated!" : "Quest Mode Disabled!"), 2000);
                //  QuestingLabel.setText("Questing : "+Questing.ToString());
                //  Log.Gui("Questing pressed... Questing is : " + Questing.ToString());
            });


            HotkeysManager.Register("Manual Pause", Keys.P, ModifierKeys.Control, ret =>
            {
                StyxWoW.Overlay.AddToast(("Manual Pause for 2 seconds"), 2000);
                Main.PauseTimer.Restart();
            });


            //At some fights Meelerange won't cut it (for Example Gorefiend, so just force the bot to attack)
            HotkeysManager.Register("Force Attack", Keys.L, ModifierKeys.Alt, ret =>
            {
                StyxWoW.Overlay.AddToast(("Force Attackmode , to disable press alt + L again"), 2000);
                ForceAttack = !ForceAttack;
            });
        }
Пример #11
0
        //private DictLookUpEditManager lookUpEditManager;

        public BaseForm()
        {
            this.FormBorderStyle = FormBorderStyle.None;
            this.MinimizeBox     = false;
            this.MaximizeBox     = false;
            this.StartPosition   = FormStartPosition.Manual;
            this.ShowInTaskbar   = false;
            this.ShowIcon        = false;
            base.Padding         = new Padding(BorderPens.Length, BorderPens.Length + TitleHeight, BorderPens.Length, BorderPens.Length + 1);

            hotkeysManager = new HotkeysManager();
            //lookUpEditManager = new DictLookUpEditManager();
        }
Пример #12
0
        protected override void OnClosing(CancelEventArgs e)
        {
            if (!close)
            {
                e.Cancel = true;
                this.Hide();
            }
            else
            {
                HotkeysManager.ShutdownSystemHook();
            }

            base.OnClosing(e);
        }
Пример #13
0
        /// <summary>
        ///     Rebuilds and reloads all of the abilities. Useful after changing settings.
        /// </summary>
        public static void Init()
        {
            _singletonInstance = new AbilityChainsManager();

            var pawsHotKeys = HotkeysManager.Hotkeys.Where(o => o.Name.StartsWith("Paws_"));

            var hotKeys = pawsHotKeys as Hotkey[] ?? pawsHotKeys.ToArray();

            for (var i = 0; i < hotKeys.Count(); i++)
            {
                var hotKey = hotKeys.ElementAt(i);
                HotkeysManager.Unregister(hotKey);

                Log.Diagnostics(string.Format("Unregistered Hotkey {0}", hotKey.Name));
            }
        }
Пример #14
0
 public static void removeHotkeys()
 {
     if (!keysRegistered)
     {
         return;
     }
     HotkeysManager.Unregister("AoEOn");
     HotkeysManager.Unregister("cooldownsOn");
     HotkeysManager.Unregister("manualOn");
     VengeanceAoEOn       = false;
     VengeanceDefensiveOn = false;
     cooldownsOn          = false;
     manualOn             = false;
     keysRegistered       = false;
     StyxWoW.Overlay.AddToast(("Hotkeys: Removed!"), 2000);
     Logging.Write(Colors.Red, "Hotkeys: Removed!");
 }
Пример #15
0
        internal static void Start(bool needReset = false)
        {
            if (needReset)
            {
                InitKeyStates();
            }

            _HotkeysRegistered = true;

            // Hook the  hotkeys for the appropriate WOW Window...
            HotkeysManager.Initialize(StyxWoW.Memory.Process.MainWindowHandle);

            if (HotkeySettings.LogMarkKey != Keys.None)
            {
                RegisterHotkeyAssignment("LogMark", HotkeySettings.LogMarkKey, (hk) => { Logger.LogMark(); TellUser("LogMark #{0} Added", Logger.LogMarkIndex); });
            }

            // define hotkeys for behaviors when using them as toggles (press once to disable, press again to enable)
            // .. otherwise, keys are polled for in Pulse()
            if (HotkeySettings.KeysToggleBehavior)
            {
                // register hotkey for commands with 1:1 key assignment
                if (HotkeySettings.AoeToggle != Keys.None)
                {
                    RegisterHotkeyAssignment("AOE", HotkeySettings.AoeToggle, (hk) => { AoeToggle(); });
                }

                if (HotkeySettings.CombatToggle != Keys.None)
                {
                    RegisterHotkeyAssignment("Combat", HotkeySettings.CombatToggle, (hk) => { CombatToggle(); });
                }

                // register hotkey for commands with 1:1 key assignment
                if (HotkeySettings.PullMoreToggle != Keys.None)
                {
                    RegisterHotkeyAssignment("PullMore", HotkeySettings.PullMoreToggle, (hk) => { PullMoreToggle(); });
                }

                // note: important to not check MovementManager if movement disabled here, since MovementManager calls us
                // .. and the potential for side-effects exists.  check SingularSettings directly for this only
                if (!SingularSettings.Instance.DisableAllMovement && HotkeySettings.MovementToggle != Keys.None)
                {
                    RegisterHotkeyAssignment("Movement", HotkeySettings.MovementToggle, (hk) => { MovementToggle(); });
                }
            }
        }
Пример #16
0
 protected virtual void UnregisterHotkeys()
 {
     HotkeysManager.Unregister("Toggle Interrupt");
     HotkeysManager.Unregister("PvP Toggle");
     HotkeysManager.Unregister("PvE Toggle");
     HotkeysManager.Unregister("Burst");
     HotkeysManager.Unregister("Hex Focus");
     HotkeysManager.Unregister("Movement");
     HotkeysManager.Unregister("Useful Stuff");
     HotkeysManager.Unregister("AOE");
     HotkeysManager.Unregister("Boss Mechs");
     HotkeysManager.Unregister("Weave");
     HotkeysManager.Unregister("Dispelling");
     HotkeysManager.Unregister("Trace");
     HotkeysManager.Unregister("LFR Mode");
     HotkeysManager.Unregister("Manual Context");
 }
Пример #17
0
        public CashierView()
        {
            InitializeComponent();
            this.Loaded += Load;

            togglebuttonScanner.IsChecked = Properties.Settings.Default.Setting_ScannerIsUsed;

            // set hotkey
            // key: +
            HotkeysManager.AddHotkey(ModifierKeys.None, Key.Add, () => {
                ButtonAutomationPeer peer  = new ButtonAutomationPeer(btnPayment);
                IInvokeProvider invokeProv = peer.GetPattern(PatternInterface.Invoke) as IInvokeProvider;
                invokeProv.Invoke();
            });

            // key: ` (below esc)
            HotkeysManager.AddHotkey(ModifierKeys.None, Key.OemTilde, () => {
                tbBarcode.Focus();
            });
        }
Пример #18
0
        public override void Initialize()
        {
            LatestVersion = Helpers.Version.CheckVersion();

            Helpers.Logger.PrintLog("You are using Version {0} of GGWP", Helpers.Version.CurrentLocalVersion.ToString());

            if (!LatestVersion)
            {
                Helpers.Logger.PrintLog(Colors.Red, "There is a new Version of Wrathful Paladin available, go to https://github.com/oruna/paladin-cr/ and download the latest Version");
            }

            HotkeysManager.Initialize(StyxWoW.Memory.Process.MainWindowHandle);
            PaladinSettings.Instance.Load();

            Lua.Events.AttachEvent("PLAYER_REGEN_DISABLED", OnCombatStarted);
            Lua.Events.AttachEvent("UPDATE_BATTLEFIELD_STATUS", BGArena);

            Hotkeys.RegisterHotkeys();
            Talents.Init();
        }
Пример #19
0
 public static void RegisterHotkeys()
 {
     HotkeysManager.Register("Simcraft Pause",
                             SimCSettings.currentSettings.Execution.key,
                             SimCSettings.currentSettings.Execution.mod,
                             hk =>
     {
         IsPaused = !IsPaused;
         if (IsPaused)
         {
             LuaDoString("print('Execution Paused!')");
             // Make the bot use less resources while paused.
             TreeRoot.TicksPerSecond = 5;
         }
         else
         {
             LuaDoString("print('Execution Resumed!')");
             // Kick it back into overdrive!
             TreeRoot.TicksPerSecond = 8;
         }
     });
     HotkeysManager.Register("Simcraft AOE",
                             SimCSettings.currentSettings.Aoe.key,
                             SimCSettings.currentSettings.Aoe.mod,
                             hk =>
     {
         _aoeEnabled = !_aoeEnabled;
         LuaDoString("if _G[\"kane_aoe\"] == true then _G[\"kane_aoe\"] = nil; print('AOE enabled'); else _G[\"kane_aoe\"] = true; print('AOE disabled') end");
     });
     HotkeysManager.Register("Simcraft Cooldowns",
                             SimCSettings.currentSettings.Cooldowns.key,
                             SimCSettings.currentSettings.Cooldowns.mod,
                             hk =>
     {
         _cdsEnabled = !_cdsEnabled;
         LuaDoString("if _G[\"kane_cds\"] == true then _G[\"kane_cds\"] = nil; print('Cds enabled') else _G[\"kane_cds\"] = true; print('Cds disabled') end");
     });
 }
Пример #20
0
        public static void RegisterHotkeys()
        {
            if (PaladinSettings.Instance.BurstHotkey != System.Windows.Forms.Keys.None)
            {
                HotkeysManager.Register("GGWPBurst", PaladinSettings.Instance.BurstHotkey, PaladinSettings.Instance.BurstModifierKey, x =>
                {
                    Helpers.Logger.PrintLog("Burst Hotkey Detected");
                    Globals.ActivateBurst = true;
                });
            }

            if (PaladinSettings.Instance.HoJHotKey != System.Windows.Forms.Keys.None)
            {
                HotkeysManager.Register("GGWPHoJ", PaladinSettings.Instance.HoJHotKey, PaladinSettings.Instance.HoJModifierKey, x =>
                {
                    Helpers.Logger.PrintLog("HoJ Hotkey Detected");
                    Globals.HoJTarget = Globals.CurrentTarget != null ? Globals.CurrentTarget : StyxWoW.Me.CurrentTarget;
                });
            }

            if (PaladinSettings.Instance.HoJHealerHotKey != System.Windows.Forms.Keys.None)
            {
                HotkeysManager.Register("GGWPHoJHealer", PaladinSettings.Instance.HoJHealerHotKey, PaladinSettings.Instance.HoJHealerModifierKey, x =>
                {
                    Helpers.Logger.PrintLog("HoJ Healer Hotkey Detected");
                    Globals.HoJTarget = Unit.UnfriendlyPlayers.Where(u => u.IsHealer()).OrderBy(u => u.Distance).FirstOrDefault();
                });
            }

            if (PaladinSettings.Instance.DivineSteedHotkey != System.Windows.Forms.Keys.None)
            {
                HotkeysManager.Register("GGWPDivineSteed", PaladinSettings.Instance.DivineSteedHotkey, PaladinSettings.Instance.DivineSteedModifierKey, x =>
                {
                    Helpers.Logger.PrintLog("Divine Steed Hotkey Detected");
                    Globals.ActivateDivineSteed = true;
                });
            }
        }
Пример #21
0
        //OnLoad
        public MainWindow()
        {
            InitializeComponent();

            //Bindings
            HotkeysManager.SetupSystemHook();

            //Add
            HotkeysManager.AddHotkey(new GlobalHotkey(ModifierKeys.Control, Key.Add, () => { Add(); }));
            HotkeysManager.AddHotkey(new GlobalHotkey(ModifierKeys.Control, Key.OemPlus, () => { Add(); }));
            HotkeysManager.AddHotkey(new GlobalHotkey(ModifierKeys.Control, Key.D1, () => { Add(); }));
            //Subtract
            HotkeysManager.AddHotkey(new GlobalHotkey(ModifierKeys.Control, Key.Subtract, () => { Subtract(); }));
            HotkeysManager.AddHotkey(new GlobalHotkey(ModifierKeys.Control, Key.OemMinus, () => { Subtract(); }));
            HotkeysManager.AddHotkey(new GlobalHotkey(ModifierKeys.Control, Key.OemTilde, () => { Subtract(); }));
            //Reset
            //HotkeysManager.AddHotkey(new GlobalHotkey(ModifierKeys.Control, Key.R, () => { Reset(); }));

            //stay at front
            this.Topmost = true;

            //for OnExit
            this.Closed += new EventHandler(MainWindow_Closed);

            //try reads the text file & catch creates one if one doesn't exist
            try
            {
                tb.Text = File.ReadAllText("xyz.txt");
                _value  = int.Parse(tb.Text);
            }
            catch
            {
                Write();
                tb.Text = "Welcome!";
            }
        }
Пример #22
0
        protected virtual void RegisterHotkeys()
        {
            HotkeysManager.Register("Manual Context",
                                    Keys.L,
                                    ModifierKeys.Alt,
                                    o =>
            {
                ManualContext = !ManualContext;
                Logging.Write("Manual Context enabled: " + ManualContext);
                Lua.DoString("print('Manual Context Enabled: " + ManualContext + "')");
            });
            ManualContext = false;

            HotkeysManager.Register("Trace",
                                    Keys.T,
                                    ModifierKeys.Alt,
                                    o =>
            {
                Trace = !Trace;
                Logging.Write("Trace enabled: " + Trace);
                Lua.DoString("print('Trace Enabled: " + Trace + "')");
            });
            Trace = false;

            HotkeysManager.Register("Dispelling",
                                    Keys.D,
                                    ModifierKeys.Alt,
                                    o =>
            {
                Dispell = !Dispell;
                Logging.Write("Dispelling enabled: " + Dispell);
                Lua.DoString("print('Dispelling Enabled: " + Dispell + "')");
            });
            Dispell = true;

            HotkeysManager.Register("Toggle Interupt",
                                    Keys.NumPad1,
                                    ModifierKeys.Alt,
                                    o =>
            {
                InterruptsEnabled = !InterruptsEnabled;
                Logging.Write("Interrupts enabled: " + InterruptsEnabled);
                Lua.DoString("print('Interrupts Enabled: " + InterruptsEnabled + "')");
            });
            InterruptsEnabled = true;

            HotkeysManager.Register("PvP Toggle",
                                    Keys.P,
                                    ModifierKeys.Alt,
                                    o =>
            {
                PvPRot = !PvPRot;
                Logging.Write("PvP enabled: " + PvPRot);
                Lua.DoString("print('PvP Enabled: " + PvPRot + "')");
            });
            PvPRot = false;

            HotkeysManager.Register("PvE Toggle",
                                    Keys.O,
                                    ModifierKeys.Alt,
                                    o =>
            {
                PvERot = !PvERot;
                Logging.Write("PvE enabled: " + PvERot);
                Lua.DoString("print('PvE Enabled: " + PvERot + "')");
            });
            PvERot = false;

            HotkeysManager.Register("Burst",
                                    Keys.NumPad1,
                                    ModifierKeys.Control,
                                    o =>
            {
                Burst = !Burst;
                Logging.Write("Burst enabled: " + Burst);
                Lua.DoString("print('Burst Enabled: " + Burst + "')");
            });
            Burst = true;

            HotkeysManager.Register("Hex Focus",
                                    Keys.NumPad2,
                                    ModifierKeys.Control,
                                    o =>
            {
                HexFocus = !HexFocus;
                Logging.Write("Hex Focus enabled: " + HexFocus);
                Lua.DoString("print('Hex Focus Enabled: " + HexFocus + "')");
            });
            HexFocus = false;

            HotkeysManager.Register("Movement Enabled",
                                    Keys.M,
                                    ModifierKeys.Alt,
                                    o =>
            {
                Movement = !Movement;
                Logging.Write("Movement Enabled: " + Movement);
                Lua.DoString("print('Movement Enabled: " + Movement + "')");
            });
            Movement = false;

            HotkeysManager.Register("Useful Stuff",
                                    Keys.NumPad3,
                                    ModifierKeys.Control,
                                    o =>
            {
                UsefulStuff = !UsefulStuff;
                Logging.Write("Useful Stuff enabled: " + UsefulStuff);
                Lua.DoString("print('Useful Stuff Enabled: " + UsefulStuff + "')");
            });
            UsefulStuff = false;

            HotkeysManager.Register("AOE",
                                    Keys.NumPad4,
                                    ModifierKeys.Control,
                                    o =>
            {
                Aoe = !Aoe;
                Logging.Write("AOE enabled: " + Aoe);
                Lua.DoString("print('AOE Enabled: " + Aoe + "')");
            });
            Aoe = true;

            HotkeysManager.Register("Boss Mechs",
                                    Keys.NumPad5,
                                    ModifierKeys.Control,
                                    o =>
            {
                BossMechs = !BossMechs;
                Logging.Write("Boss Mechs enabled: " + BossMechs);
                Lua.DoString("print('Boss Mechs Enabled: " + BossMechs + "')");
            });
            BossMechs = false;

            HotkeysManager.Register("Weave",
                                    Keys.NumPad6,
                                    ModifierKeys.Control,
                                    o =>
            {
                Weave = !Weave;
                Logging.Write("Weave enabled: " + Weave);
                Lua.DoString("print('Weave Enabled: " + Weave + "')");
            });
            Weave = true;

            HotkeysManager.Register("LFR Mode",
                                    Keys.NumPad7,
                                    ModifierKeys.Control,
                                    o =>
            {
                LFRMode = !LFRMode;
                Logging.Write("LFR Mode enabled: " + LFRMode);
                Lua.DoString("print('LFR Mode Enabled: " + LFRMode + "')");
            });
            LFRMode = false;
        }
Пример #23
0
 //OnExit
 void MainWindow_Closed(object sender, EventArgs e)
 {
     HotkeysManager.ShutdownSystemHook();
 }
Пример #24
0
 public static void UnregisterHotkeys()
 {
     HotkeysManager.Unregister("Simcraft Pause");
     HotkeysManager.Unregister("Simcraft Cooldowns");
     HotkeysManager.Unregister("Simcraft AOE");
 }
Пример #25
0
        public static void registerHotkeys()
        {
            if (keysRegistered)
            {
                return;
            }
            TypeConverter converter = TypeDescriptor.GetConverter(typeof(Keys));

            // ++++++++++ General AoE +++++++++++++++
            if (!string.IsNullOrEmpty(HotkeySettings.Instance.HotkeyVengeanceAoeKey) && HotkeySettings.Instance.HotkeyVengeanceAoeModifier > 0)
            {
                HotkeysManager.Register("AoEOn", (Keys)converter.ConvertFromString(HotkeySettings.Instance.HotkeyVengeanceAoeKey), (ModifierKeys)HotkeySettings.Instance.HotkeyVengeanceAoeModifier, ret =>
                {
                    VengeanceAoEOn = !VengeanceAoEOn;
                    HavocAoEOn     = !HavocAoEOn;
                    StyxWoW.Overlay.AddToast((VengeanceAoEOn ? "AoE Mode: Enabled!" : "AoE Mode: Disabled!"), 2000);
                });
            }

            if (!string.IsNullOrEmpty(HotkeySettings.Instance.HotkeyGeneralRotationOnlyKey) && HotkeySettings.Instance.HotkeyGeneralRotationOnlyModifier > 0)
            {
                HotkeysManager.Register("RotationOnly", (Keys)converter.ConvertFromString(HotkeySettings.Instance.HotkeyGeneralRotationOnlyKey), (ModifierKeys)HotkeySettings.Instance.HotkeyGeneralRotationOnlyModifier, ret =>
                {
                    RotationOnlyOn = !RotationOnlyOn;
                    StyxWoW.Overlay.AddToast((RotationOnlyOn ? "Rotation Only: Enabled!" : "Rotation Only: Disabled!"), 2000);
                });
            }

            if (Me.Specialization == WoWSpec.DemonHunterVengeance)
            {
                // ++++++++ VENGEANCE SPEC ONLY ++++++++++

                if (HotkeySettings.Instance.HotkeyVengeanceDefensiveModifier > 0 && !string.IsNullOrEmpty(HotkeySettings.Instance.HotkeyVengeanceDefensiveKey))
                {
                    HotkeysManager.Register("VengeanceDefensiveOn", (Keys)converter.ConvertFromString(HotkeySettings.Instance.HotkeyVengeanceDefensiveKey), (ModifierKeys)HotkeySettings.Instance.HotkeyVengeanceDefensiveModifier, ret =>
                    {
                        VengeanceDefensiveOn = !VengeanceDefensiveOn;
                        StyxWoW.Overlay.AddToast((VengeanceDefensiveOn ? "Defensive Mode: Enabled!" : "Defensive Mode: Disabled!"), 2000);
                    });
                }
            }

            if (Me.Specialization == WoWSpec.DemonHunterHavoc)
            {
                if (HotkeySettings.Instance.HotkeyHavocOffensiveModifier > 0 && !string.IsNullOrEmpty(HotkeySettings.Instance.HotkeyHavocOffensiveKey))
                {
                    HotkeysManager.Register("HavocOffensiveOn", (Keys)converter.ConvertFromString(HotkeySettings.Instance.HotkeyHavocOffensiveKey), (ModifierKeys)HotkeySettings.Instance.HotkeyHavocOffensiveModifier, ret =>
                    {
                        HavocOffensiveOn = !HavocOffensiveOn;
                        StyxWoW.Overlay.AddToast((HavocOffensiveOn ? "Offensive Cooldowns: Enabled!" : "Offensive Cooldowns: Disabled!"), 2000);
                    });
                }
            }

            HotkeysManager.Register("ManualOn", Keys.S, ModifierKeys.Alt, ret =>
            {
                manualOn = !manualOn;
                StyxWoW.Overlay.AddToast((manualOn ? "Manual Mode: Enabled!" : "Manual Mode: Disabled!"), 2000);
            });
            keysRegistered = true;
            StyxWoW.Overlay.AddToast(("Hotkeys: Registered!"), 2000);
            Logging.Write(Colors.Green, "Hotkeys: Registered!");
        }