//--------------------------------------------------------------------------------------------------
#endregion
#region Keyboard Input
static bool _SendKeyEvent(int key, bool isUp)
{
bool success = false;
int vkey = key & 0xff;
Application.Current.Dispatcher.Invoke(() =>
{
var sourceElement = Keyboard.PrimaryDevice.ActiveSource;
var focusElement = Keyboard.PrimaryDevice.FocusedElement;
if (focusElement == null || sourceElement == null)
{
return;
}
var tunnelArgs = new KeyEventArgs(Keyboard.PrimaryDevice, sourceElement, 0, KeyInterop.KeyFromVirtualKey(vkey));
tunnelArgs.RoutedEvent = isUp ? Keyboard.PreviewKeyUpEvent : Keyboard.PreviewKeyDownEvent;
focusElement.RaiseEvent(tunnelArgs);
if (!tunnelArgs.Handled)
{
var bubbleArgs = new KeyEventArgs(Keyboard.PrimaryDevice, sourceElement, 0, KeyInterop.KeyFromVirtualKey(vkey));
bubbleArgs.RoutedEvent = isUp ? Keyboard.KeyUpEvent : Keyboard.KeyDownEvent;
focusElement.RaiseEvent(bubbleArgs);
if (!bubbleArgs.Handled && !isUp)
{
var sb = new StringBuilder();
byte[] bKeyState = new byte[255];
if ((key & 0x0100) > 0)
{
bKeyState[0x10] = 0x80;
}
if ((key & 0x0200) > 0)
{
bKeyState[0x11] = 0x80;
}
if ((key & 0x0400) > 0)
{
bKeyState[0x12] = 0x80;
}
uint lScanCode = Win32Api.MapVirtualKey((uint)(vkey), Win32Api.MapVirtualKeyMapTypes.MAPVK_VK_TO_VSC);
Win32Api.ToUnicode((uint)(vkey), lScanCode, bKeyState, sb, 5, 0);
TextCompositionManager.StartComposition(new TextComposition(InputManager.Current, Keyboard.FocusedElement, sb.ToString()));
}
}
success = true;
});
return(success);
}
protected virtual IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
{
bool unicode = UnmanagedMethods.IsWindowUnicode(hWnd);
const double wheelDelta = 120.0;
uint timestamp = unchecked ((uint)UnmanagedMethods.GetMessageTime());
RawInputEventArgs e = null;
WindowsMouseDevice.Instance.CurrentWindow = this;
switch ((UnmanagedMethods.WindowsMessage)msg)
{
case UnmanagedMethods.WindowsMessage.WM_ACTIVATE:
var wa = (UnmanagedMethods.WindowActivate)(ToInt32(wParam) & 0xffff);
switch (wa)
{
case UnmanagedMethods.WindowActivate.WA_ACTIVE:
case UnmanagedMethods.WindowActivate.WA_CLICKACTIVE:
Activated?.Invoke();
break;
case UnmanagedMethods.WindowActivate.WA_INACTIVE:
Deactivated?.Invoke();
break;
}
return(IntPtr.Zero);
case UnmanagedMethods.WindowsMessage.WM_DESTROY:
//Window doesn't exist anymore
_hwnd = IntPtr.Zero;
//Remove root reference to this class, so unmanaged delegate can be collected
s_instances.Remove(this);
Closed?.Invoke();
//Free other resources
Dispose();
return(IntPtr.Zero);
case UnmanagedMethods.WindowsMessage.WM_DPICHANGED:
var dpi = ToInt32(wParam) & 0xffff;
var newDisplayRect = (UnmanagedMethods.RECT)Marshal.PtrToStructure(lParam, typeof(UnmanagedMethods.RECT));
Position = new Point(newDisplayRect.left, newDisplayRect.top);
_scaling = dpi / 96.0;
ScalingChanged?.Invoke(_scaling);
return(IntPtr.Zero);
case UnmanagedMethods.WindowsMessage.WM_KEYDOWN:
case UnmanagedMethods.WindowsMessage.WM_SYSKEYDOWN:
e = new RawKeyEventArgs(
WindowsKeyboardDevice.Instance,
timestamp,
RawKeyEventType.KeyDown,
KeyInterop.KeyFromVirtualKey(ToInt32(wParam)), WindowsKeyboardDevice.Instance.Modifiers);
break;
case UnmanagedMethods.WindowsMessage.WM_KEYUP:
case UnmanagedMethods.WindowsMessage.WM_SYSKEYUP:
e = new RawKeyEventArgs(
WindowsKeyboardDevice.Instance,
timestamp,
RawKeyEventType.KeyUp,
KeyInterop.KeyFromVirtualKey(ToInt32(wParam)), WindowsKeyboardDevice.Instance.Modifiers);
break;
case UnmanagedMethods.WindowsMessage.WM_CHAR:
// Ignore control chars
if (ToInt32(wParam) >= 32)
{
e = new RawTextInputEventArgs(WindowsKeyboardDevice.Instance, timestamp,
new string((char)ToInt32(wParam), 1));
}
break;
case UnmanagedMethods.WindowsMessage.WM_LBUTTONDOWN:
case UnmanagedMethods.WindowsMessage.WM_RBUTTONDOWN:
case UnmanagedMethods.WindowsMessage.WM_MBUTTONDOWN:
e = new RawMouseEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
msg == (int)UnmanagedMethods.WindowsMessage.WM_LBUTTONDOWN
? RawMouseEventType.LeftButtonDown
: msg == (int)UnmanagedMethods.WindowsMessage.WM_RBUTTONDOWN
? RawMouseEventType.RightButtonDown
: RawMouseEventType.MiddleButtonDown,
DipFromLParam(lParam), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_LBUTTONUP:
case UnmanagedMethods.WindowsMessage.WM_RBUTTONUP:
case UnmanagedMethods.WindowsMessage.WM_MBUTTONUP:
e = new RawMouseEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
msg == (int)UnmanagedMethods.WindowsMessage.WM_LBUTTONUP
? RawMouseEventType.LeftButtonUp
: msg == (int)UnmanagedMethods.WindowsMessage.WM_RBUTTONUP
? RawMouseEventType.RightButtonUp
: RawMouseEventType.MiddleButtonUp,
DipFromLParam(lParam), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_MOUSEMOVE:
if (!_trackingMouse)
{
var tm = new UnmanagedMethods.TRACKMOUSEEVENT
{
cbSize = Marshal.SizeOf(typeof(UnmanagedMethods.TRACKMOUSEEVENT)),
dwFlags = 2,
hwndTrack = _hwnd,
dwHoverTime = 0,
};
UnmanagedMethods.TrackMouseEvent(ref tm);
}
e = new RawMouseEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
RawMouseEventType.Move,
DipFromLParam(lParam), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_MOUSEWHEEL:
e = new RawMouseWheelEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
ScreenToClient(DipFromLParam(lParam)),
new Vector(0, (ToInt32(wParam) >> 16) / wheelDelta), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_MOUSEHWHEEL:
e = new RawMouseWheelEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
ScreenToClient(DipFromLParam(lParam)),
new Vector(-(ToInt32(wParam) >> 16) / wheelDelta, 0), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_MOUSELEAVE:
_trackingMouse = false;
e = new RawMouseEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
RawMouseEventType.LeaveWindow,
new Point(), WindowsKeyboardDevice.Instance.Modifiers);
break;
case UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN:
case UnmanagedMethods.WindowsMessage.WM_NCRBUTTONDOWN:
case UnmanagedMethods.WindowsMessage.WM_NCMBUTTONDOWN:
e = new RawMouseEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
msg == (int)UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN
? RawMouseEventType.NonClientLeftButtonDown
: msg == (int)UnmanagedMethods.WindowsMessage.WM_NCRBUTTONDOWN
? RawMouseEventType.RightButtonDown
: RawMouseEventType.MiddleButtonDown,
new Point(0, 0), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_PAINT:
UnmanagedMethods.PAINTSTRUCT ps;
if (UnmanagedMethods.BeginPaint(_hwnd, out ps) != IntPtr.Zero)
{
var f = Scaling;
var r = ps.rcPaint;
Paint?.Invoke(new Rect(r.left / f, r.top / f, (r.right - r.left) / f, (r.bottom - r.top) / f));
UnmanagedMethods.EndPaint(_hwnd, ref ps);
}
return(IntPtr.Zero);
case UnmanagedMethods.WindowsMessage.WM_SIZE:
if (Resized != null &&
(wParam == (IntPtr)UnmanagedMethods.SizeCommand.Restored ||
wParam == (IntPtr)UnmanagedMethods.SizeCommand.Maximized))
{
var clientSize = new Size(ToInt32(lParam) & 0xffff, ToInt32(lParam) >> 16);
Resized(clientSize / Scaling);
}
return(IntPtr.Zero);
case UnmanagedMethods.WindowsMessage.WM_MOVE:
PositionChanged?.Invoke(new Point((short)(ToInt32(lParam) & 0xffff), (short)(ToInt32(lParam) >> 16)));
return(IntPtr.Zero);
}
if (e != null && Input != null)
{
Input(e);
if (e.Handled)
{
return(IntPtr.Zero);
}
}
return(UnmanagedMethods.DefWindowProc(hWnd, msg, wParam, lParam));
}
/// <summary>
/// Registers a system-wide hot key.
/// </summary>
/// <param name="handle">The handle of the window that will process hot key messages.</param>
/// <param name="id">The hot key ID.</param>
/// <param name="key">The key.</param>
/// <param name="modifiers">The key modifiers.</param>
/// <returns><c>true</c> if hot key was registered; otherwise, <c>false</c>.</returns>
public static bool RegisterHotKey(IntPtr handle, int id, Key key, ModifierKeys modifiers)
{
var virtualCode = KeyInterop.VirtualKeyFromKey(key);
return(RegisterHotKey(handle, id, (uint)modifiers, (uint)virtualCode));
}
private void MakeMenu(ActiveAbility activeAbility)
{
var main = _main.MenuWithTexture("", $"{activeAbility.Ability.Id}", $"{activeAbility.Ability.Id}");
var enable = main.Item("Enable", true);
var key = main.Item("Invoke Key", new KeyBind('0'));
var ignore = main.Item("Ignore invisibility", false);
MenuItem <bool> useOnMainHeroAfterInvoke = null;
MenuItem <bool> use = null;
if (activeAbility is InvokerAlacrity || activeAbility is InvokerForgeSpirit ||
activeAbility is InvokerGhostWalk || activeAbility is InvokerIceWall)
{
useOnMainHeroAfterInvoke = main.Item("Use on main hero after Invoke", false);
use = main.Item("Use if already invoked", false);
}
else if (activeAbility is InvokerTornado || activeAbility is InvokerChaosMeteor ||
activeAbility is InvokerDeafeningBlast || activeAbility is InvokerEmp ||
activeAbility is InvokerSunStrike || activeAbility is InvokerColdSnap)
{
useOnMainHeroAfterInvoke = main.Item("Use after Invoke", false);
use = main.Item("Use if already invoked", false);
if (activeAbility is InvokerSunStrike)
{
delayForCataclysm = main.Item("time for double click for cataclysm", new Slider(0, 0, 100));
}
// if (activeAbility is InvokerSunStrike)
// {
// useCataclysm = main.Item("Use cactaclysm", false);
// }
}
var reInvoke = main.Item("Use invoke if skill in slot #5", false);
((IHaveFastInvokeKey)activeAbility).Key =
key.Value.Key == '0' ? Key.None : KeyInterop.KeyFromVirtualKey((int)key.Value.Key);
var value = key.Value.Active;
isFirstClick = true;
key.PropertyChanged += async(sender, args) =>
{
if (!enable)
{
return;
}
if (key)
{
if (value)
{
return;
}
value = true;
if (_config.SmartSphere.InChanging.Sleeping)
{
while (_config.SmartSphere.InChanging.Sleeping)
{
await Task.Delay(5);
}
}
if (!_config.Main.Me.IsAlive || !_config.Main.Me.CanCastAbilities())
{
return;
}
if ( /*|| !activeAbility.CanBeCasted ||*/
_config.Main.Me.HasAnyModifiers(_config.Main.AbilitiesInCombo.GhostWalk.ModifierName,
"item_glimmer_cape") && !ignore)
{
return;
}
if (!ObjectManager.LocalPlayer.Selection.Any(x => x.Equals(_config.Main.Me)))
{
return;
}
var slot = activeAbility.Ability.AbilitySlot;
if (reInvoke && slot == AbilitySlot.Slot_5)
{
_config.Main.Combo.InvokeThisShit(activeAbility);
return;
}
if (slot == AbilitySlot.Slot_4 ||
slot == AbilitySlot.Slot_5)
{
if (use != null && use)
{
JustUse(activeAbility);
}
return;
}
if (!_config.Main.AbilitiesInCombo.Invoke.CanBeCasted)
{
return;
}
if (useOnMainHeroAfterInvoke == null)
{
InvokeThenCast(activeAbility);
}
else
{
InvokeThenCast(activeAbility, useOnMainHeroAfterInvoke);
}
}
else
{
if (value)
{
value = false;
}
else
{
((IHaveFastInvokeKey)activeAbility).Key = KeyInterop.KeyFromVirtualKey((int)key.Value.Key);
Console.WriteLine(
$"({activeAbility}) Changed: to {((IHaveFastInvokeKey) activeAbility).Key} ({key.Value.Key})");
}
//Console.WriteLine($"({activeAbility}) Changed: to {((IHaveFastInvokeKey)activeAbility).Key} ({key.Value.Key})");
}
};
}
/// <summary>
/// 返回具有状态的键的状态
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static bool GetState(Key key)
{
return(SoftKeyboardManager.GetKeyState(KeyInterop.VirtualKeyFromKey(key)) == 1);
}
public void SetKey(Key key, string keyName)
{
this.Key = key;
this.KeyName = keyName;
this.VirtualKey = KeyInterop.VirtualKeyFromKey(this.Key);
}
/// <summary>
/// Get keyboard input for the console.
/// </summary>
/// <param name="e"></param>
private void GetConsoleInput(KeyEventArgs e)
{
var keyChar = KeyInterop.GetCharFromKey(e.KeyCode, (e.Modifiers & Keys.Shift) != 0);
var capsLock = System.Windows.Forms.Control.IsKeyLocked(Keys.CapsLock);
if (char.IsLetter(keyChar))
{
if (capsLock || e.Shift)
{
keyChar = char.ToUpper(keyChar);
}
else
{
keyChar = char.ToLower(keyChar);
}
}
else
{
switch (e.KeyCode)
{
case Keys.Back:
if (_input.GetText().Length < 1)
{
_input.Hide();
_output.Hide();
_output.EnableFadeOut();
_consoleActive = false;
}
_input.RemoveLastChar();
return;
case Keys.Up:
_output.ScrollUp();
return;
case Keys.Down:
_output.ScrollDown();
return;
case Keys.Enter:
var text = _input.GetText();
_output.WriteLine(text);
_output.EnableFadeOut();
_input.Hide();
_input.Clear();
_consoleActive = false;
ExecuteCommandString(text);
return;
}
}
_input.AddChar(keyChar);
}
protected override void OnActivate()
{
Log.Debug("pre init");
Mode = new InvokerMode(
Key.G,
OrbwalkerManager,
Input,
this);
Quas = Owner.GetAbilityById(AbilityId.invoker_quas);
Wex = Owner.GetAbilityById(AbilityId.invoker_wex);
Exort = Owner.GetAbilityById(AbilityId.invoker_exort);
BlockerSleeper = new Sleeper();
SunStrike = new AbilityInfo(Exort, Exort, Exort, Owner.GetAbilityById(AbilityId.invoker_sun_strike));
ColdSnap = new AbilityInfo(Quas, Quas, Quas, Owner.GetAbilityById(AbilityId.invoker_cold_snap));
Alacrity = new AbilityInfo(Wex, Wex, Exort, Owner.GetAbilityById(AbilityId.invoker_alacrity));
Meteor = new AbilityInfo(Exort, Exort, Wex, Owner.GetAbilityById(AbilityId.invoker_chaos_meteor));
Blast = new AbilityInfo(Quas, Exort, Wex, Owner.GetAbilityById(AbilityId.invoker_deafening_blast));
ForgeSpirit = new AbilityInfo(Exort, Exort, Quas, Owner.GetAbilityById(AbilityId.invoker_forge_spirit));
GhostWalk = new AbilityInfo(Quas, Quas, Wex, Owner.GetAbilityById(AbilityId.invoker_ghost_walk));
IceWall = new AbilityInfo(Quas, Quas, Exort, Owner.GetAbilityById(AbilityId.invoker_ice_wall));
Tornado = new AbilityInfo(Wex, Wex, Quas, Owner.GetAbilityById(AbilityId.invoker_tornado));
Emp = new AbilityInfo(Wex, Wex, Wex, Owner.GetAbilityById(AbilityId.invoker_emp));
_invokeSleeper = new Sleeper();
GlobalGhostWalkSleeper = new Sleeper();
AbilityInfos = new List <AbilityInfo>
{
SunStrike,
ColdSnap,
Alacrity,
Meteor,
Blast,
ForgeSpirit,
GhostWalk,
IceWall,
Tornado,
Emp
};
//retards re coming
foreach (var ability in AbilityInfos)
{
ability.LoadInvoker(this);
}
Empty1 = Owner.GetAbilityById(AbilityId.invoker_empty1);
Empty2 = Owner.GetAbilityById(AbilityId.invoker_empty2);
InvokeAbility = Owner.GetAbilityById(AbilityId.invoker_invoke);
Log.Debug("post init");
Config = new Config(this);
Log.Debug("new config");
Config.ComboKey.Item.ValueChanged += HotkeyChanged;
Log.Debug("event to config");
OrbwalkerManager.Value.Activate();
Log.Debug("activate OrbwalkerManager");
TargetManager.Value.Activate();
Log.Debug("activate TargetManager");
Mode.UpdateConfig(Config);
Log.Debug("load config");
OrbwalkerManager.Value.RegisterMode(Mode);
Log.Debug("RegisterMode");
foreach (var valueOrbwalkingMode in OrbwalkerManager.Value.OrbwalkingModes)
{
Log.Warn($"Mode: {valueOrbwalkingMode.Value}");
}
foreach (var valueOrbwalkingMode in OrbwalkerManager.Value.CustomOrbwalkingModes)
{
Log.Warn($"Custom Mode: {valueOrbwalkingMode}");
}
Mode.Load();
var key = KeyInterop.KeyFromVirtualKey((int)Config.ComboKey.Item.GetValue <KeyBind>().Key);
Mode.Key = key;
Log.Debug($"_mode loaded. Key for combo -> {Mode.Key}");
InventoryManager.Value.Attach(this);
Log.Debug("InventoryManager Attach");
SelectedCombo = 0;
InventoryManager.Value.CollectionChanged += ValueOnCollectionChanged;
//if (InventoryManager.Value.Inventory.Items.Any(x => x.Id == AbilityId.item_cyclone))
/*if (Eul!=null)
* {
* _eulCombo1 = new Combo(this, new[]
* {
* new AbilityInfo(Eul.Ability), SunStrike, Meteor, Blast, ColdSnap, Alacrity, ForgeSpirit
* });
* _eulCombo2 = new Combo(this, new[]
* {
* new AbilityInfo(Eul.Ability), Meteor, Blast, ColdSnap, Alacrity, ForgeSpirit
* });
* _eulCombo3 = new Combo(this, new[]
* {
* new AbilityInfo(Eul.Ability), SunStrike, IceWall, ColdSnap, Alacrity, ForgeSpirit
* });
* Config.ComboPanel.Combos.Add(_eulCombo1);
* Config.ComboPanel.Combos.Add(_eulCombo2);
* Config.ComboPanel.Combos.Add(_eulCombo3);
* }*/
Unit.OnModifierAdded += HeroOnOnModifierAdded;
Unit.OnModifierRemoved += HeroOnOnModifierRemoved;
SpCounter = new SphereCounter();
}
/// <summary>
/// 注册热键
/// </summary>
public void RegisterHotKey()
{
//重新进行注册
if (IsKeyRegistered)
{
UnregisterHotKey();
}
IsKeyRegistered = NativeMethods.RegisterHotKey(IntPtr.Zero, _id, KeyModifier, KeyInterop.VirtualKeyFromKey(Key));
//如果注册失败,说明热键已经被占用
if (!IsKeyRegistered)
{
#pragma warning disable CA1303 // 请不要将文本作为本地化参数传递
throw new ApplicationException("Hotkey already in use");
#pragma warning restore CA1303 // 请不要将文本作为本地化参数传递
}
}
/// <summary>
/// Registers a window handle (HWND) that identifies as the main application window.
/// </summary>
/// <param name="handle">A <see cref="IntPtr" /> representing window handle (HWND).</param>
public void RegisterWindow(IntPtr handle)
{
Check.ArgumentEx.Handle(handle, nameof(handle));
if (Handle == IntPtr.Zero)
{
Handle = handle;
if (!Native.RegisterHotKey(Handle, HotKeyId, Modifiers, (System.Windows.Forms.Keys)KeyInterop.VirtualKeyFromKey(Key)))
{
throw Throw.Win32("Hotkey already in use.");
}
ComponentDispatcher.ThreadPreprocessMessage += ComponentDispatcher_ThreadPreprocessMessage;
}
else
{
throw Throw.InvalidOperation("Window was already registered.");
}
}
protected virtual unsafe IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
{
const double wheelDelta = 120.0;
uint timestamp = unchecked ((uint)GetMessageTime());
RawInputEventArgs e = null;
switch ((WindowsMessage)msg)
{
case WindowsMessage.WM_ACTIVATE:
{
var wa = (WindowActivate)(ToInt32(wParam) & 0xffff);
switch (wa)
{
case WindowActivate.WA_ACTIVE:
case WindowActivate.WA_CLICKACTIVE:
{
Activated?.Invoke();
break;
}
case WindowActivate.WA_INACTIVE:
{
Deactivated?.Invoke();
break;
}
}
return(IntPtr.Zero);
}
case WindowsMessage.WM_NCCALCSIZE:
{
if (ToInt32(wParam) == 1 && !HasFullDecorations)
{
return(IntPtr.Zero);
}
break;
}
case WindowsMessage.WM_CLOSE:
{
bool?preventClosing = Closing?.Invoke();
if (preventClosing == true)
{
return(IntPtr.Zero);
}
break;
}
case WindowsMessage.WM_DESTROY:
{
//Window doesn't exist anymore
_hwnd = IntPtr.Zero;
//Remove root reference to this class, so unmanaged delegate can be collected
s_instances.Remove(this);
Closed?.Invoke();
_mouseDevice.Dispose();
_touchDevice?.Dispose();
//Free other resources
Dispose();
return(IntPtr.Zero);
}
case WindowsMessage.WM_DPICHANGED:
{
var dpi = ToInt32(wParam) & 0xffff;
var newDisplayRect = Marshal.PtrToStructure <RECT>(lParam);
_scaling = dpi / 96.0;
ScalingChanged?.Invoke(_scaling);
SetWindowPos(hWnd,
IntPtr.Zero,
newDisplayRect.left,
newDisplayRect.top,
newDisplayRect.right - newDisplayRect.left,
newDisplayRect.bottom - newDisplayRect.top,
SetWindowPosFlags.SWP_NOZORDER |
SetWindowPosFlags.SWP_NOACTIVATE);
return(IntPtr.Zero);
}
case WindowsMessage.WM_KEYDOWN:
case WindowsMessage.WM_SYSKEYDOWN:
{
e = new RawKeyEventArgs(
WindowsKeyboardDevice.Instance,
timestamp,
_owner,
RawKeyEventType.KeyDown,
KeyInterop.KeyFromVirtualKey(ToInt32(wParam), ToInt32(lParam)),
WindowsKeyboardDevice.Instance.Modifiers);
break;
}
case WindowsMessage.WM_MENUCHAR:
{
// mute the system beep
return((IntPtr)((int)MenuCharParam.MNC_CLOSE << 16));
}
case WindowsMessage.WM_KEYUP:
case WindowsMessage.WM_SYSKEYUP:
{
e = new RawKeyEventArgs(
WindowsKeyboardDevice.Instance,
timestamp,
_owner,
RawKeyEventType.KeyUp,
KeyInterop.KeyFromVirtualKey(ToInt32(wParam), ToInt32(lParam)),
WindowsKeyboardDevice.Instance.Modifiers);
break;
}
case WindowsMessage.WM_CHAR:
{
// Ignore control chars
if (ToInt32(wParam) >= 32)
{
e = new RawTextInputEventArgs(WindowsKeyboardDevice.Instance, timestamp, _owner,
new string((char)ToInt32(wParam), 1));
}
break;
}
case WindowsMessage.WM_LBUTTONDOWN:
case WindowsMessage.WM_RBUTTONDOWN:
case WindowsMessage.WM_MBUTTONDOWN:
case WindowsMessage.WM_XBUTTONDOWN:
{
if (ShouldIgnoreTouchEmulatedMessage())
{
break;
}
e = new RawPointerEventArgs(
_mouseDevice,
timestamp,
_owner,
(WindowsMessage)msg switch
{
WindowsMessage.WM_LBUTTONDOWN => RawPointerEventType.LeftButtonDown,
WindowsMessage.WM_RBUTTONDOWN => RawPointerEventType.RightButtonDown,
WindowsMessage.WM_MBUTTONDOWN => RawPointerEventType.MiddleButtonDown,
WindowsMessage.WM_XBUTTONDOWN =>
HighWord(ToInt32(wParam)) == 1 ?
RawPointerEventType.XButton1Down :
RawPointerEventType.XButton2Down
},
DipFromLParam(lParam), GetMouseModifiers(wParam));
break;
}
/// <summary>
/// Create raw keyevent arguments.
/// </summary>
/// <param name="VKCode"></param>
/// <param name="isSysKey"></param>
public RawKeyEventArgs(int VKCode, bool isSysKey)
{
this.VKCode = VKCode;
this.IsSysKey = isSysKey;
this.Key = KeyInterop.KeyFromVirtualKey(VKCode);
}
public static bool IsKeyPressed(Key key) => IsKeyPressed((Keys)KeyInterop.VirtualKeyFromKey(key));
public static int RegisterHotKey(Key key, ModifierKeys modifiers = ModifierKeys.None, bool noRepeat = true) => RegisterHotKey((Keys)KeyInterop.VirtualKeyFromKey(key), modifiers, noRepeat);
private void MainWindow_OnLoaded(object sender, RoutedEventArgs e)
{
Utility.CreateFileFromResource(Directories.ConfigFilePath, "LeagueSharp.Loader.Resources.config.xml");
try
{
Config.Instance = ((Config)Utility.MapXmlFileToClass(typeof(Config), Directories.ConfigFilePath));
}
catch (Exception ee)
{
File.Delete(Directories.ConfigFilePath);
System.Windows.MessageBox.Show("Couldn't load config.xml");
Environment.Exit(0);
}
Browser.Visibility = Visibility.Hidden;
DataContext = this;
GeneralSettingsItem.IsSelected = true;
if (!File.Exists(Directories.CoreFilePath))
{
System.Windows.MessageBox.Show(string.Format("Couldn't find {0}", Path.GetFileName(Directories.CoreFilePath)));
Environment.Exit(0);
}
Updater.MainWindow = this;
Updater.UpdateLoader();
Updater.GetRepositories(
delegate(List <string> list)
{
if (list.Count > 0)
{
Config.Instance.KnownRepositories.Clear();
foreach (var repo in list)
{
Config.Instance.KnownRepositories.Add(repo);
}
}
});
if (Config.Instance.FirstRun)
{
LSUriScheme.CreateRegistryKeys(false);
}
//Try to login with the saved credentials.
if (!Auth.Login(Config.Instance.Username, Config.Instance.Password).Item1)
{
ShowLoginDialog();
}
else
{
OnLogin(Config.Instance.Username);
}
Config.Instance.FirstRun = false;
//Used to reload the assemblies from inside the game.
KeyboardHook.SetHook();
KeyboardHook.OnKeyUpTrigger += KeyboardHookOnOnKeyUpTrigger;
KeyboardHook.HookedKeys.Add(KeyInterop.VirtualKeyFromKey(Config.Instance.Hotkeys.SelectedHotkeys.First(h => h.Name == "Reload").Hotkey));
KeyboardHook.HookedKeys.Add(KeyInterop.VirtualKeyFromKey(Config.Instance.Hotkeys.SelectedHotkeys.First(h => h.Name == "CompileAndReload").Hotkey));
foreach (var hk in Config.Instance.Hotkeys.SelectedHotkeys)
{
hk.PropertyChanged += hk_PropertyChanged;
}
InjectThread = new Thread(
() =>
{
while (true)
{
if (Config.Instance.Install)
{
Injection.Pulse();
}
Thread.Sleep(3000);
}
});
InjectThread.Start();
Config.Instance.PropertyChanged += ConfigOnPropertyChanged;
foreach (var gameSetting in Config.Instance.Settings.GameSettings)
{
gameSetting.PropertyChanged += GameSettingOnPropertyChanged;
}
SettingsTabItem.Visibility = Visibility.Hidden;
}
private async void _listener_OnKeyPressed(object sender, INPUT e)
{
bool error = false; string message = "";
try
{
if (Keyboard.Modifiers == ModifierKeys.Control)
{
Key k = KeyInterop.KeyFromVirtualKey(e.ki.wVk);
int virtualKey = KeyInterop.VirtualKeyFromKey(k);
if (k == Key.N)
{
// Invio della clipboard del client
ClientManager.NotifyClipboardAsynch();
}
else if (k == Key.M)
{
// Richiesta della clipboard al server
ClipboardTrasfer.SendUpdateRequest();
}
else if (virtualKey >= (int)VirtualKeyCode.VK_1 && virtualKey <= (int)VirtualKeyCode.VK_9) // Switch
{
virtualKey -= (int)VirtualKeyCode.VK_0;
if (virtualKey <= listIp.Count)
{
serverIP = IPAddress.Parse(listIp[virtualKey - 1].ipAddress);
Connection.disconnectFromServer();
ConnectWindow c = new ConnectWindow();
c.Show();
}
}
else if (virtualKey == (int)VirtualKeyCode.VK_0) // Disconnect
{
MessageDialogResult result = await this.ShowMessageAsync("Exit", "Are you sure you want to disconnect?", MessageDialogStyle.AffirmativeAndNegative, WPFProperties.metroDialogSettings);
if (result == MessageDialogResult.Affirmative)
{
if (disconnectButton.IsEnabled)
{
Connection.disconnectFromServer();
}
}
}
else
{
ClientManager.NotifyInputAsynch(e);
}
}
else
{
ClientManager.NotifyInputAsynch(e);
}
}
catch (Exception ex)
{
error = true;
message = ex.Message;
}
if (error)
{
MessageDialogResult result = await this.ShowMessageAsync("Error: " + message, "You are now disconnected from server", MessageDialogStyle.Affirmative, WPFProperties.metroDialogSettings);
}
}
public override void OnLoad()
{
base.OnLoad();
var heroMenu = new Menu("Naga", "zaioNaga", false, "npc_dota_hero_naga_siren", true);
heroMenu.AddItem(new MenuItem("zaioNagaAbilitiesText", "Supported Abilities"));
var supportedStuff = new MenuItem("zaioNagaAbilities", string.Empty);
supportedStuff.SetValue(new AbilityToggler(SupportedAbilities.ToDictionary(x => x, y => true)));
heroMenu.AddItem(supportedStuff);
heroMenu.AddItem(new MenuItem("zaioNagaKillstealAbilitiesText", "Supported Killsteal Abilities"));
var supportedKillsteal = new MenuItem("zaioNagaKillstealAbilities", string.Empty);
supportedKillsteal.SetValue(new AbilityToggler(KillstealAbilities.ToDictionary(x => x, y => true)));
heroMenu.AddItem(supportedKillsteal);
OnLoadMenuItems(supportedStuff, supportedKillsteal);
_functionWheelItem =
new MenuItem("zaioNagaFunctionWheel", "Function Wheel").SetValue(new KeyBind(0, KeyBindType.Press));
_functionWheelItem.Tooltip = "Hotkey for showing the function wheel.";
_functionWheelItem.ValueChanged += _functionWheelItem_ValueChanged;
heroMenu.AddItem(_functionWheelItem);
_stackAnctientsItem = new MenuItem("zaioNagaStackAncients", "Stack Ancients?").SetValue(false);
heroMenu.AddItem(_stackAnctientsItem);
ZaioMenu.LoadHeroSettings(heroMenu);
_illuAbility = MyHero.GetAbilityById(AbilityId.naga_siren_mirror_image);
_rootAbility = MyHero.GetAbilityById(AbilityId.naga_siren_ensnare);
_ripTideAbility = MyHero.GetAbilityById(AbilityId.naga_siren_rip_tide);
_stackJungleEntry = new WheelEntry("Stack Jungle", StackJungle, false);
_farmJungleEntry = new WheelEntry("Farm Jungle", FarmJungleFunc);
_pushLaneEntry = new WheelEntry("Push Lanes", PushLanesFunc);
_mixedModeEntry = new WheelEntry("Mixed Mode", MixedMode);
var key = KeyInterop.KeyFromVirtualKey((int)_functionWheelItem.GetValue <KeyBind>().Key);
_functionWheel = new FunctionWheel(key)
{
_mixedModeEntry,
_pushLaneEntry,
_farmJungleEntry,
_stackJungleEntry
};
_availableCamps = new List <JungleCamp>(JungleCamps.GetCamps);
Log.Debug($"Init jungle camps! {_availableCamps.Count}");
if (MyHero.Team == Team.Dire)
{
Log.Debug($"using radiant to dire creep lanes");
_enemyCreepRouteTop = _radiantToDireTop;
_enemyCreepRouteMid = _radiantToDireMid;
_enemyCreepRouteBottom = _radiantToDireBot;
}
else
{
Log.Debug($"using reversed radiant to dire creep lanes");
_enemyCreepRouteTop = new List <Vector3>(_radiantToDireTop);
_enemyCreepRouteMid = new List <Vector3>(_radiantToDireMid);
_enemyCreepRouteBottom = new List <Vector3>(_radiantToDireBot);
_enemyCreepRouteTop.Reverse();
_enemyCreepRouteMid.Reverse();
_enemyCreepRouteBottom.Reverse();
}
Game.OnIngameUpdate += Game_OnIngameUpdate;
}
private void txtVnos_PreviewKeyDown(object sender, KeyEventArgs e)
{
int pomožna = (int)(KeyInterop.VirtualKeyFromKey(e.Key));
vnešenZnak = (char)(pomožna);
praviZnak = trenutnaVrstica.tekst[štČrk];
if (e.Key == Key.CapsLock)
{
return; //če smo prižgali caps lock naj ne šteje črk
}
if (e.Key == Key.Enter)
{
return; //samo, da ne šteje črk
}
var jeS = false;
if (Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift))
{
jeS = true;
m.PreveriShift();
}
if (e.Key == Key.RightShift || e.Key == Key.LeftShift)
{
return;
}
var jeKapps = Console.CapsLock;
if ((!jeKapps && !jeS) || (jeKapps && jeS))
{
vnešenZnak = char.ToLower(vnešenZnak);
}
if (vnešenZnak == 186 && ((!jeKapps && !jeS) || (jeKapps && jeS)))
{
vnešenZnak = 'č';
}
if (vnešenZnak == 186 && ((jeKapps && !jeS) || (jeS && !jeKapps)))
{
vnešenZnak = 'Č';
}
if (vnešenZnak == 253 && ((!jeKapps && !jeS) || (jeKapps && jeS)))
{
vnešenZnak = 'đ';
}
if (vnešenZnak == 221 && ((jeKapps && !jeS) || (jeS && !jeKapps)))
{
vnešenZnak = 'Đ';
}
if (vnešenZnak == 254 && ((!jeKapps && !jeS) || (jeKapps && jeS)))
{
vnešenZnak = 'ć';
}
if (vnešenZnak == 222 && ((jeKapps && !jeS) || (jeS && !jeKapps)))
{
vnešenZnak = 'Ć';
}
if (vnešenZnak == 251 && ((!jeKapps && !jeS) || (jeKapps && jeS)))
{
vnešenZnak = 'š';
}
if (vnešenZnak == 219 && ((jeKapps && !jeS) || (jeS && !jeKapps))) //!!
{
vnešenZnak = 'Š';
}
if (vnešenZnak == 252 && ((!jeKapps && !jeS) || (jeKapps && jeS)))
{
vnešenZnak = 'ž';
}
if (vnešenZnak == 220 && ((jeKapps && !jeS) || (jeS && !jeKapps)))
{
vnešenZnak = 'Ž';
}
//if (vnešenZnak == 269 && !jeKapps && !jeS)
// vnešenZnak = 'è';
if (vnešenZnak == 191 && !jeKapps && !jeS)
{
vnešenZnak = '\'';
}
if (vnešenZnak == 191 && (jeKapps || jeS))
{
vnešenZnak = '?';
}
if (vnešenZnak == 226 && !jeKapps && !jeS)
{
vnešenZnak = '<';
}
if (vnešenZnak == 226 && (jeKapps || jeS))
{
vnešenZnak = '>';
}
if (vnešenZnak == 190 && jeS)
{
vnešenZnak = ':';
}
if (vnešenZnak == 190 && !jeS)
{
vnešenZnak = '.';
}
if (vnešenZnak == 188 && !jeS)
{
vnešenZnak = ',';
}
if (vnešenZnak == 188 && jeS)
{
vnešenZnak = ';';
}
if (vnešenZnak == 189 && !jeKapps && !jeS)
{
vnešenZnak = '-';
}
if (vnešenZnak == 189 && (jeKapps || jeS))
{
vnešenZnak = '_';
}
if (vnešenZnak == 187 && !jeKapps && !jeS)
{
vnešenZnak = '+';
}
if (vnešenZnak == 187 && (jeKapps || jeS))
{
vnešenZnak = '*';
}
if (vnešenZnak == 48 && (jeKapps || jeS))
{
vnešenZnak = '=';
}
if (vnešenZnak == 49 && (jeKapps || jeS))
{
vnešenZnak = '!';
}
if (vnešenZnak == 50 && (jeKapps || jeS))
{
vnešenZnak = '"';
}
if (vnešenZnak == 51 && (jeS))
{
vnešenZnak = '#';
}
if (vnešenZnak == 52 && (jeS))
{
vnešenZnak = '$';
}
if (vnešenZnak == 53 && (jeS))
{
vnešenZnak = '%';
}
if (vnešenZnak == 54 && (jeS))
{
vnešenZnak = '&';
}
if (vnešenZnak == 55 && (jeS))
{
vnešenZnak = '/';
}
if (vnešenZnak == 56 && (jeS))
{
vnešenZnak = '(';
}
if (vnešenZnak == 57 && (jeS))
{
vnešenZnak = ')';
}
številoUdarcev++;
switch (načinDela)
{
case NačinDela.Ignoriraj:
if (e.Key == Key.Back)
{
e.Handled = true;
return;
}
if (vnešenZnak != praviZnak)
{
napake++;
txtN.Text = napake.ToString();
m.PobarvajNapačno(e.Key);
narobe.Add(e.Key);
e.Handled = true;
return;
}
if (vnešenZnak == praviZnak && narobe.Count > 0)
{
m.Ponastavi(narobe);
narobe = new List <Key>();
}
break;
case NačinDela.Ponovno:
//if (e.Key == VirtualKey.Enter) //dodano, ker je šlo prehitro v novo vrstico
// return; //prenos noavzgor, verjetno je problem še kje druge
break;
case NačinDela.Briši:
if (e.Key == Key.Back)
{
štČrk--;
return;
}
break;
case NačinDela.Uredi:
case NačinDela.LahekTest:
if (e.Key == Key.Back)
{
štČrk--;
return;
}
//če grem levo ali desno v bistvu vrivam in se nič ne spremeni
//kontrola je na koncu vrtsice
break;
case NačinDela.Test:
if (e.Key == Key.Back)
{
e.Handled = true;
return;
}
if (vnešenZnak != praviZnak)
{
napake++;
txtNapake.Text = napake.ToString();
e.Handled = true;
return;
}
break;
}
štČrk++;
}
public static void Add(string name, KeyCombination combination)
{
if (handle == null)
{
throw new Exception("Hotkey: 窗口句柄尚未初始化!");
}
int i = index++;
try
{
bool result = RegisterHotKey(handle, i, combination.ModifierKeys, (uint)KeyInterop.VirtualKeyFromKey(combination.Key));
if (!result)
{
throw new HotKeyAlreadyExistsException("快捷键已被占用");
}
combination.ID = i;
hotkeys.Add(name, combination);
keymap.Add(i, name);
}
catch (Exception)
{
throw;
}
}
private void KeyUp(object sender, KeyEventArgsCustom e)
{
switch (SelectedKeyboardImitationIndex)
{
case 0: //Если AHK
AddCommand($"AHKKeyUp(\"{Utilities.KeyCodeToUnicode.VKCodeToUnicode((uint)KeyInterop.VirtualKeyFromKey(e.Key))}\")");
break;
case 1:
AddCommand(string.Format(@"KeyUp(""{0}"")", e.Key));
break;
}
}
void HotkeyEdited(Key NewKey, Modifiers NewModifiers)
{
HotkeyEdited((Keys)KeyInterop.VirtualKeyFromKey(NewKey), NewModifiers);
}
protected virtual unsafe IntPtr AppWndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
{
const double wheelDelta = 120.0;
uint timestamp = unchecked ((uint)GetMessageTime());
RawInputEventArgs e = null;
var shouldTakeFocus = false;
switch ((WindowsMessage)msg)
{
case WindowsMessage.WM_ACTIVATE:
{
var wa = (WindowActivate)(ToInt32(wParam) & 0xffff);
switch (wa)
{
case WindowActivate.WA_ACTIVE:
case WindowActivate.WA_CLICKACTIVE:
{
Activated?.Invoke();
break;
}
case WindowActivate.WA_INACTIVE:
{
Deactivated?.Invoke();
break;
}
}
return(IntPtr.Zero);
}
case WindowsMessage.WM_NCCALCSIZE:
{
if (ToInt32(wParam) == 1 && !HasFullDecorations || _isClientAreaExtended)
{
return(IntPtr.Zero);
}
break;
}
case WindowsMessage.WM_CLOSE:
{
bool?preventClosing = Closing?.Invoke();
if (preventClosing == true)
{
return(IntPtr.Zero);
}
// Based on https://github.com/dotnet/wpf/blob/master/src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Window.cs#L4270-L4337
// We need to enable parent window before destroying child window to prevent OS from activating a random window behind us.
// This is described here: https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-enablewindow#remarks
// Our window closed callback will set enabled state to a correct value after child window gets destroyed.
// We need to verify if parent is still alive (perhaps it got destroyed somehow).
if (_parent != null && IsWindow(_parent._hwnd))
{
var wasActive = GetActiveWindow() == _hwnd;
_parent.SetEnabled(true);
// We also need to activate our parent window since again OS might try to activate a window behind if it is not set.
if (wasActive)
{
SetActiveWindow(_parent._hwnd);
}
}
break;
}
case WindowsMessage.WM_DESTROY:
{
//Window doesn't exist anymore
_hwnd = IntPtr.Zero;
//Remove root reference to this class, so unmanaged delegate can be collected
s_instances.Remove(this);
Closed?.Invoke();
_mouseDevice.Dispose();
_touchDevice?.Dispose();
//Free other resources
Dispose();
return(IntPtr.Zero);
}
case WindowsMessage.WM_DPICHANGED:
{
var dpi = ToInt32(wParam) & 0xffff;
var newDisplayRect = Marshal.PtrToStructure <RECT>(lParam);
_scaling = dpi / 96.0;
ScalingChanged?.Invoke(_scaling);
SetWindowPos(hWnd,
IntPtr.Zero,
newDisplayRect.left,
newDisplayRect.top,
newDisplayRect.right - newDisplayRect.left,
newDisplayRect.bottom - newDisplayRect.top,
SetWindowPosFlags.SWP_NOZORDER |
SetWindowPosFlags.SWP_NOACTIVATE);
return(IntPtr.Zero);
}
case WindowsMessage.WM_KEYDOWN:
case WindowsMessage.WM_SYSKEYDOWN:
{
e = new RawKeyEventArgs(
WindowsKeyboardDevice.Instance,
timestamp,
_owner,
RawKeyEventType.KeyDown,
KeyInterop.KeyFromVirtualKey(ToInt32(wParam), ToInt32(lParam)),
WindowsKeyboardDevice.Instance.Modifiers);
break;
}
case WindowsMessage.WM_MENUCHAR:
{
// mute the system beep
return((IntPtr)((int)MenuCharParam.MNC_CLOSE << 16));
}
case WindowsMessage.WM_KEYUP:
case WindowsMessage.WM_SYSKEYUP:
{
e = new RawKeyEventArgs(
WindowsKeyboardDevice.Instance,
timestamp,
_owner,
RawKeyEventType.KeyUp,
KeyInterop.KeyFromVirtualKey(ToInt32(wParam), ToInt32(lParam)),
WindowsKeyboardDevice.Instance.Modifiers);
break;
}
case WindowsMessage.WM_CHAR:
{
// Ignore control chars
if (ToInt32(wParam) >= 32)
{
e = new RawTextInputEventArgs(WindowsKeyboardDevice.Instance, timestamp, _owner,
new string((char)ToInt32(wParam), 1));
}
break;
}
case WindowsMessage.WM_LBUTTONDOWN:
case WindowsMessage.WM_RBUTTONDOWN:
case WindowsMessage.WM_MBUTTONDOWN:
case WindowsMessage.WM_XBUTTONDOWN:
{
shouldTakeFocus = ShouldTakeFocusOnClick;
if (ShouldIgnoreTouchEmulatedMessage())
{
break;
}
e = new RawPointerEventArgs(
_mouseDevice,
timestamp,
_owner,
(WindowsMessage)msg switch
{
WindowsMessage.WM_LBUTTONDOWN => RawPointerEventType.LeftButtonDown,
WindowsMessage.WM_RBUTTONDOWN => RawPointerEventType.RightButtonDown,
WindowsMessage.WM_MBUTTONDOWN => RawPointerEventType.MiddleButtonDown,
WindowsMessage.WM_XBUTTONDOWN =>
HighWord(ToInt32(wParam)) == 1 ?
RawPointerEventType.XButton1Down :
RawPointerEventType.XButton2Down
},
DipFromLParam(lParam), GetMouseModifiers(wParam));
break;
}
protected virtual IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
{
bool unicode = UnmanagedMethods.IsWindowUnicode(hWnd);
const double wheelDelta = 120.0;
uint timestamp = unchecked ((uint)UnmanagedMethods.GetMessageTime());
RawInputEventArgs e = null;
WindowsMouseDevice.Instance.CurrentWindow = this;
switch ((UnmanagedMethods.WindowsMessage)msg)
{
case UnmanagedMethods.WindowsMessage.WM_ACTIVATE:
var wa = (UnmanagedMethods.WindowActivate)((int)wParam & 0xffff);
switch (wa)
{
case UnmanagedMethods.WindowActivate.WA_ACTIVE:
case UnmanagedMethods.WindowActivate.WA_CLICKACTIVE:
_isActive = true;
Activated?.Invoke();
break;
case UnmanagedMethods.WindowActivate.WA_INACTIVE:
_isActive = false;
Deactivated?.Invoke();
break;
}
return(IntPtr.Zero);
case UnmanagedMethods.WindowsMessage.WM_DESTROY:
if (Closed != null)
{
UnmanagedMethods.UnregisterClass(_className, Marshal.GetHINSTANCE(GetType().Module));
Closed();
}
return(IntPtr.Zero);
case UnmanagedMethods.WindowsMessage.WM_DPICHANGED:
var dpi = (int)wParam & 0xffff;
_scaling = dpi / 96.0;
ScalingChanged?.Invoke(_scaling);
break;
case UnmanagedMethods.WindowsMessage.WM_KEYDOWN:
case UnmanagedMethods.WindowsMessage.WM_SYSKEYDOWN:
e = new RawKeyEventArgs(
WindowsKeyboardDevice.Instance,
timestamp,
RawKeyEventType.KeyDown,
KeyInterop.KeyFromVirtualKey((int)wParam), WindowsKeyboardDevice.Instance.Modifiers);
break;
case UnmanagedMethods.WindowsMessage.WM_KEYUP:
case UnmanagedMethods.WindowsMessage.WM_SYSKEYUP:
e = new RawKeyEventArgs(
WindowsKeyboardDevice.Instance,
timestamp,
RawKeyEventType.KeyUp,
KeyInterop.KeyFromVirtualKey((int)wParam), WindowsKeyboardDevice.Instance.Modifiers);
break;
case UnmanagedMethods.WindowsMessage.WM_CHAR:
// Ignore control chars
if (wParam.ToInt32() >= 32)
{
e = new RawTextInputEventArgs(WindowsKeyboardDevice.Instance, timestamp,
new string((char)wParam.ToInt32(), 1));
}
break;
case UnmanagedMethods.WindowsMessage.WM_LBUTTONDOWN:
case UnmanagedMethods.WindowsMessage.WM_RBUTTONDOWN:
case UnmanagedMethods.WindowsMessage.WM_MBUTTONDOWN:
e = new RawMouseEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
msg == (int)UnmanagedMethods.WindowsMessage.WM_LBUTTONDOWN
? RawMouseEventType.LeftButtonDown
: msg == (int)UnmanagedMethods.WindowsMessage.WM_RBUTTONDOWN
? RawMouseEventType.RightButtonDown
: RawMouseEventType.MiddleButtonDown,
DipFromLParam(lParam), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_LBUTTONUP:
case UnmanagedMethods.WindowsMessage.WM_RBUTTONUP:
case UnmanagedMethods.WindowsMessage.WM_MBUTTONUP:
e = new RawMouseEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
msg == (int)UnmanagedMethods.WindowsMessage.WM_LBUTTONUP
? RawMouseEventType.LeftButtonUp
: msg == (int)UnmanagedMethods.WindowsMessage.WM_RBUTTONUP
? RawMouseEventType.RightButtonUp
: RawMouseEventType.MiddleButtonUp,
DipFromLParam(lParam), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_MOUSEMOVE:
if (!_trackingMouse)
{
var tm = new UnmanagedMethods.TRACKMOUSEEVENT
{
cbSize = Marshal.SizeOf(typeof(UnmanagedMethods.TRACKMOUSEEVENT)),
dwFlags = 2,
hwndTrack = _hwnd,
dwHoverTime = 0,
};
UnmanagedMethods.TrackMouseEvent(ref tm);
}
e = new RawMouseEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
RawMouseEventType.Move,
DipFromLParam(lParam), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_MOUSEWHEEL:
e = new RawMouseWheelEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
ScreenToClient(DipFromLParam(lParam)),
new Vector(0, ((int)wParam >> 16) / wheelDelta), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_MOUSELEAVE:
_trackingMouse = false;
e = new RawMouseEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
RawMouseEventType.LeaveWindow,
new Point(), WindowsKeyboardDevice.Instance.Modifiers);
break;
case UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN:
case UnmanagedMethods.WindowsMessage.WM_NCRBUTTONDOWN:
case UnmanagedMethods.WindowsMessage.WM_NCMBUTTONDOWN:
e = new RawMouseEventArgs(
WindowsMouseDevice.Instance,
timestamp,
_owner,
msg == (int)UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN
? RawMouseEventType.NonClientLeftButtonDown
: msg == (int)UnmanagedMethods.WindowsMessage.WM_NCRBUTTONDOWN
? RawMouseEventType.RightButtonDown
: RawMouseEventType.MiddleButtonDown,
new Point(0, 0), GetMouseModifiers(wParam));
break;
case UnmanagedMethods.WindowsMessage.WM_PAINT:
if (Paint != null)
{
UnmanagedMethods.PAINTSTRUCT ps;
if (UnmanagedMethods.BeginPaint(_hwnd, out ps) != IntPtr.Zero)
{
UnmanagedMethods.RECT r;
UnmanagedMethods.GetUpdateRect(_hwnd, out r, false);
var f = Scaling;
Paint(new Rect(r.left / f, r.top / f, (r.right - r.left) / f, (r.bottom - r.top) / f));
UnmanagedMethods.EndPaint(_hwnd, ref ps);
}
}
return(IntPtr.Zero);
case UnmanagedMethods.WindowsMessage.WM_SIZE:
if (Resized != null)
{
var clientSize = new Size((int)lParam & 0xffff, (int)lParam >> 16);
Resized(clientSize / Scaling);
}
return(IntPtr.Zero);
}
if (e != null && Input != null)
{
Input(e);
if (e.Handled)
{
return(IntPtr.Zero);
}
}
return(UnmanagedMethods.DefWindowProc(hWnd, msg, wParam, lParam));
}
private void ChangeHotKey(int mod, Key Key, int hotkeyId)
{
ChangeHotKey(mod, KeyInterop.VirtualKeyFromKey(Key), hotkeyId);
}
public RawKeyEventArgs(int vkCode, bool isSysKey)
{
VKCode = vkCode;
IsSysKey = isSysKey;
Key = KeyInterop.KeyFromVirtualKey(VKCode);
}
private void OnKeyPress(object sender, KeyEventArgs e)
{
var formsKey = (Keys)KeyInterop.VirtualKeyFromKey(e.Key);
_controller.KeyDown((int)formsKey);
}
public IntPtr SetWindowsHookExOverride(int idHook, KeyboardHookDelegate lpfn, IntPtr hMod, uint dwThreadId)
{
_interface.DebugWriteLine("Hook install intercepted and overriden.");
var result = originalSetWindowsHookExW(
idHook,
(nCode, wParam, lParam) =>
{
var vkCode = Marshal.ReadInt32(lParam);
var currentKey = KeyInterop.KeyFromVirtualKey(vkCode);
var keyEvent = (KeyEvent)wParam.ToUInt32();
var isCurrentKeyDown = keyEvent == KeyEvent.WM_KEYDOWN;
var shouldIgnoreHook = _interface.GetShouldIgnoreHook();
var shouldOverride = ctrlIsDown &&
(currentKey == Key.V) &&
!shouldIgnoreHook;
switch (currentKey)
{
case Key.LeftCtrl:
case Key.RightCtrl:
ctrlIsDown = isCurrentKeyDown;
break;
case Key.V:
vIsDown = isCurrentKeyDown;
break;
}
var fetchOriginalResult = new Lazy <IntPtr>(() => lpfn(nCode, wParam, lParam));
if (!shouldOverride)
{
var value = fetchOriginalResult.Value.ToInt32();
_interface.DebugWriteLine($"Original call for {currentKey} {(isCurrentKeyDown ? "down" : "up")} returned {value}.");
if ((value != 1) && (value != -1))
{
return(fetchOriginalResult.Value);
}
}
switch (currentKey)
{
case Key.LeftCtrl:
case Key.RightCtrl:
shouldOverride = true;
break;
case Key.V:
shouldOverride = ctrlIsDown;
break;
case Key.Down:
case Key.Up:
case Key.Left:
case Key.Right:
shouldOverride = ctrlIsDown && vIsDown;
break;
}
if (shouldOverride || shouldIgnoreHook)
{
return(CallNextHookEx(
new IntPtr(idHook), nCode, wParam, lParam));
}
return(fetchOriginalResult.Value);
},
hMod,
dwThreadId);
return(result);
}
void hk_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
KeyboardHook.HookedKeys.Add(KeyInterop.VirtualKeyFromKey(((HotkeyEntry)sender).Hotkey));
}
private void OnKeyUp(object sender, System.Windows.Input.KeyEventArgs args)
{
if (mCurrentBinding == null)
{
return;
}
mCurrentPressedKeys.Remove(args.Key);
if (mCurrentPressedKeys.Count != 0)
{
return;
}
var border = mCurrentBinding.Label.Parent as System.Windows.Controls.Border;
if (border != null)
{
border.BorderBrush = new SolidColorBrush(Color.FromRgb(0, 0, 0));
}
var bindField = mCurrentBinding.Tag as Tuple <FieldInfo, object>;
if (bindField != null && mCurrentKeys.Count > 0)
{
bindField.Item1.SetValue(bindField.Item2, mCurrentKeys.Select(k => (Keys)KeyInterop.VirtualKeyFromKey(k)).ToArray());
KeyBindings.Save();
}
mCurrentBinding = null;
}
public Configuration GetConfiguration(int pid)
{
var reload = 0x74;
var recompile = 0x77;
var antiAfk = false;
var console = false;
var towerRange = false;
var extendedZoom = false;
var drawings = true;
var ping = true;
var menuToggle = 0x78;
var menuPress = 0x10;
var selectedLanguage = "";
var statistics = true;
try
{
reload =
KeyInterop.VirtualKeyFromKey(
Config.Instance.Hotkeys.SelectedHotkeys.First(h => h.Name == "Reload").Hotkey);
recompile =
KeyInterop.VirtualKeyFromKey(
Config.Instance.Hotkeys.SelectedHotkeys.First(h => h.Name == "CompileAndReload").Hotkey);
antiAfk = Config.Instance.Settings.GameSettings.First(s => s.Name == "Anti-AFK").SelectedValue == "True";
console = Config.Instance.Settings.GameSettings.First(s => s.Name == "Debug Console").SelectedValue
== "True";
towerRange =
Config.Instance.Settings.GameSettings.First(s => s.Name == "Display Enemy Tower Range")
.SelectedValue == "True";
extendedZoom = Config.Instance.Settings.GameSettings.First(s => s.Name == "Extended Zoom").SelectedValue
== "True";
drawings = Config.Instance.Settings.GameSettings.First(s => s.Name == "Show Drawings").SelectedValue
== "True";
ping = Config.Instance.Settings.GameSettings.First(s => s.Name == "Show Ping").SelectedValue == "True";
statistics =
Config.Instance.Settings.GameSettings.First(s => s.Name == "Send Anonymous Assembly Statistics")
.SelectedValue == "True";
menuToggle =
KeyInterop.VirtualKeyFromKey(
Config.Instance.Hotkeys.SelectedHotkeys.First(h => h.Name == "ShowMenuToggle").Hotkey);
menuPress =
KeyInterop.VirtualKeyFromKey(
Config.Instance.Hotkeys.SelectedHotkeys.First(h => h.Name == "ShowMenuPress").Hotkey);
selectedLanguage = Config.Instance.SelectedLanguage;
}
catch
{
// ignored
}
return(new Configuration
{
DataDirectory = Directories.AppDataDirectory,
LeagueSharpDllPath = PathRandomizer.LeagueSharpDllPath,
LibrariesDirectory = Directories.CoreDirectory,
ReloadKey = reload,
ReloadAndRecompileKey = recompile,
MenuToggleKey = menuToggle,
MenuKey = menuPress,
UnloadKey = 0x75,
AntiAfk = antiAfk,
Console = console,
TowerRange = towerRange,
SelectedLanguage = selectedLanguage,
ExtendedZoom = extendedZoom,
ShowPing = ping,
ShowDrawing = drawings,
SendStatistics = statistics,
Permissions = null
});
}
