687 lines
27 KiB
C#
687 lines
27 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Runtime.InteropServices;
|
|
using System.Windows.Forms;
|
|
using System.Threading;
|
|
using System.Text.Json;
|
|
|
|
namespace DD2Switcher {
|
|
public class Settings {
|
|
public int FirstIndex { get; set; } = -1;
|
|
public int LastIndex { get; set; } = -1;
|
|
public Keys SequenceKeybind { get; set; } = Keys.F1;
|
|
}
|
|
|
|
internal static class Program {
|
|
private static int NumProc = 19;
|
|
private static Process[] windows = new Process[NumProc];
|
|
private static string settingsPath =
|
|
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "DD2Switcher.json");
|
|
|
|
// Public access to tracked windows for the settings form
|
|
public static Process[] GetTrackedWindows() {
|
|
return windows;
|
|
}
|
|
|
|
public static void UntrackWindow(int index) {
|
|
if (index >= 0 && index < NumProc) {
|
|
windows[index] = null;
|
|
|
|
// Update ActiveIndex if needed
|
|
if (ActiveIndex == index) {
|
|
ActiveIndex = -1;
|
|
}
|
|
|
|
// Update first/last indices if needed
|
|
if (FirstIndex == index) {
|
|
FirstIndex = -1;
|
|
}
|
|
if (LastIndex == index) {
|
|
LastIndex = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void StartSequenceMode() {
|
|
Console.WriteLine($"StartSequenceMode called. FirstIndex: {FirstIndex}, LastIndex: {LastIndex}");
|
|
if (FirstIndex >= 0 && LastIndex >= 0 && FirstIndex <= LastIndex) {
|
|
CurrentState = SequenceState.PROCESSING;
|
|
CurrentSequenceIndex = FirstIndex;
|
|
Console.WriteLine($"Starting sequence mode, tabbing to index {CurrentSequenceIndex + 1}");
|
|
TabTo(CurrentSequenceIndex + 1); // Tab to first window
|
|
CurrentState = SequenceState.WAITING;
|
|
Console.WriteLine($"State changed to: {CurrentState}");
|
|
} else {
|
|
Console.WriteLine("Cannot start sequence mode - invalid first/last indices");
|
|
}
|
|
}
|
|
|
|
public static void NextSequenceStep() {
|
|
Console.WriteLine(
|
|
$"NextSequenceStep called. State: {CurrentState}, CurrentIndex: {CurrentSequenceIndex}, LastIndex: {LastIndex}");
|
|
if (CurrentState == SequenceState.INACTIVE)
|
|
return;
|
|
|
|
CurrentState = SequenceState.PROCESSING;
|
|
CurrentSequenceIndex++;
|
|
Console.WriteLine($"Advanced to index {CurrentSequenceIndex}");
|
|
if (CurrentSequenceIndex > LastIndex) {
|
|
// End of sequence - tab back to first
|
|
Console.WriteLine("End of sequence reached, tabbing back to first window");
|
|
TabTo(FirstIndex + 1);
|
|
ExitSequenceMode();
|
|
} else {
|
|
Console.WriteLine($"Tabbing to index {CurrentSequenceIndex + 1}");
|
|
TabTo(CurrentSequenceIndex + 1);
|
|
CurrentState = SequenceState.WAITING;
|
|
Console.WriteLine($"State changed to: {CurrentState}");
|
|
}
|
|
}
|
|
|
|
public static void ExitSequenceMode() {
|
|
CurrentState = SequenceState.INACTIVE;
|
|
CurrentSequenceIndex = -1;
|
|
Console.WriteLine($"State changed to: {CurrentState}");
|
|
}
|
|
|
|
public static bool IsInSequenceMode() {
|
|
return CurrentState != SequenceState.INACTIVE;
|
|
}
|
|
|
|
private static void LoadSettings() {
|
|
try {
|
|
if (File.Exists(settingsPath)) {
|
|
string json = File.ReadAllText(settingsPath);
|
|
var settings = JsonSerializer.Deserialize<Settings>(json);
|
|
FirstIndex = settings.FirstIndex;
|
|
LastIndex = settings.LastIndex;
|
|
SequenceKeybind = settings.SequenceKeybind;
|
|
Console.WriteLine(
|
|
$"Loaded settings: First={FirstIndex}, Last={LastIndex}, Keybind={SequenceKeybind}");
|
|
}
|
|
} catch (Exception ex) {
|
|
Console.WriteLine($"Error loading settings: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
private static void SaveSettings() {
|
|
try {
|
|
var settings =
|
|
new Settings { FirstIndex = FirstIndex, LastIndex = LastIndex, SequenceKeybind = SequenceKeybind };
|
|
string json = JsonSerializer.Serialize(settings, new JsonSerializerOptions { WriteIndented = true });
|
|
File.WriteAllText(settingsPath, json);
|
|
Console.WriteLine($"Saved settings: First={FirstIndex}, Last={LastIndex}, Keybind={SequenceKeybind}");
|
|
} catch (Exception ex) {
|
|
Console.WriteLine($"Error saving settings: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
private static int FindFirstNonNullWindow() {
|
|
for (int i = 0; i < NumProc; i++) {
|
|
if (windows[i] != null && windows[i].MainWindowHandle != IntPtr.Zero) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
private static int FindLastNonNullWindow() {
|
|
for (int i = NumProc - 1; i >= 0; i--) {
|
|
if (windows[i] != null && windows[i].MainWindowHandle != IntPtr.Zero) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
private static int FindNextNonNullWindow(int startIndex) {
|
|
for (int i = startIndex; i < NumProc; i++) {
|
|
if (windows[i] != null && windows[i].MainWindowHandle != IntPtr.Zero) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
private static void SetDefaultFirstLastIndices() {
|
|
if (FirstIndex == -1) {
|
|
FirstIndex = FindFirstNonNullWindow();
|
|
Console.WriteLine($"Set default FirstIndex to: {FirstIndex}");
|
|
}
|
|
if (LastIndex == -1) {
|
|
LastIndex = FindLastNonNullWindow();
|
|
Console.WriteLine($"Set default LastIndex to: {LastIndex}");
|
|
}
|
|
}
|
|
|
|
public static void UpdateSequenceHotkey(Keys newKey) {
|
|
Console.WriteLine($"UpdateSequenceHotkey called with new key: {newKey} (code: {(int)newKey})");
|
|
Console.WriteLine($"Old SequenceKeybind before update: {SequenceKeybind} (code: {(int)SequenceKeybind})");
|
|
|
|
// Unregister old hotkey
|
|
if (sequenceHotkeyId != -1) {
|
|
Console.WriteLine($"Unregistering old hotkey ID: {sequenceHotkeyId}");
|
|
HotKeyManager.UnregisterHotKey(sequenceHotkeyId);
|
|
}
|
|
|
|
// Register new hotkey
|
|
sequenceHotkeyId = HotKeyManager.RegisterHotKey(newKey, KeyModifiers.NoRepeat);
|
|
Console.WriteLine($"Registered new hotkey ID: {sequenceHotkeyId} for key: {newKey}");
|
|
SequenceKeybind = newKey;
|
|
Console.WriteLine($"New SequenceKeybind after update: {SequenceKeybind} (code: {(int)SequenceKeybind})");
|
|
SaveSettings();
|
|
}
|
|
|
|
// Static properties for first/last selection persistence
|
|
public static int FirstIndex { get; set; } = -1;
|
|
public static int LastIndex { get; set; } = -1;
|
|
|
|
// Sequence mode state engine
|
|
public enum SequenceState { INACTIVE, WAITING, PROCESSING }
|
|
|
|
public static SequenceState CurrentState { get; set; } = SequenceState.INACTIVE;
|
|
public static int CurrentSequenceIndex { get; set; } = -1;
|
|
public static Keys SequenceKeybind { get; set; } = Keys.F1;
|
|
private static int sequenceHotkeyId = -1;
|
|
private static int ActiveIndex = -1;
|
|
private static bool AltPressed = false;
|
|
|
|
// Simple list to track last 5 windows
|
|
private static List<int> lastWindows = new List<int>();
|
|
|
|
private static readonly IntPtr defaultAffinity = new(0xFF000000);
|
|
private static readonly IntPtr fullAffinity = new(0xFFFFFFFF);
|
|
private static readonly KeyboardHook keyboardHook = new();
|
|
|
|
[DllImport("user32.dll")]
|
|
public static extern IntPtr GetForegroundWindow();
|
|
|
|
[DllImport("user32.dll")]
|
|
public static extern bool SetForegroundWindow(IntPtr hWnd);
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern short GetKeyState(int nVirtKey);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
[return:MarshalAs(UnmanagedType.Bool)]
|
|
static extern bool AllocConsole();
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, int dwExtraInfo);
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern IntPtr SetWindowsHookEx(int idHook, IntPtr lpfn, IntPtr hMod, uint dwThreadId);
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern bool UnhookWindowsHookEx(IntPtr hhk);
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
|
|
|
|
[DllImport("kernel32.dll")]
|
|
private static extern IntPtr GetModuleHandle(string lpModuleName);
|
|
|
|
private const int WH_MOUSE_LL = 14;
|
|
private const int WM_LBUTTONDOWN = 0x0201;
|
|
private const int WM_RBUTTONDOWN = 0x0204;
|
|
private const int WM_MBUTTONDOWN = 0x0207;
|
|
private static IntPtr mouseHookId = IntPtr.Zero;
|
|
private static IntPtr mouseHookProc = IntPtr.Zero;
|
|
private static MouseHookProc mouseHookDelegate; // Keep reference to prevent GC
|
|
|
|
private delegate IntPtr MouseHookProc(int nCode, IntPtr wParam, IntPtr lParam);
|
|
|
|
private static void HandleSequenceEvent() {
|
|
if (CurrentState == SequenceState.WAITING) {
|
|
Console.WriteLine($"Event detected in state: {CurrentState}, advancing to next step");
|
|
NextSequenceStep();
|
|
}
|
|
}
|
|
|
|
private static IntPtr MouseHookCallback(int nCode, IntPtr wParam, IntPtr lParam) {
|
|
if (nCode >= 0) {
|
|
int wParamInt = (int)wParam;
|
|
if (wParamInt == WM_LBUTTONDOWN || wParamInt == WM_RBUTTONDOWN || wParamInt == WM_MBUTTONDOWN) {
|
|
if (CurrentState == SequenceState.WAITING) {
|
|
Console.WriteLine($"Mouse click detected in state: {CurrentState}");
|
|
HandleSequenceEvent();
|
|
}
|
|
}
|
|
}
|
|
return CallNextHookEx(mouseHookId, nCode, wParam, lParam);
|
|
}
|
|
|
|
private static void CleanWindows() {
|
|
for (int i = 0; i < NumProc; i++) {
|
|
var window = windows[i];
|
|
if (window == null)
|
|
continue;
|
|
if (window.MainWindowHandle == IntPtr.Zero) {
|
|
Console.WriteLine($"Window at index {i} has no main window, removing from tracked windows");
|
|
windows[i] = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void AdjustAffinities() {
|
|
CleanWindows();
|
|
for (int i = 0; i < NumProc; i++) {
|
|
var window = windows[i];
|
|
if (window == null)
|
|
continue;
|
|
if (i != ActiveIndex) {
|
|
try {
|
|
window.ProcessorAffinity = defaultAffinity;
|
|
} catch (Exception e) {
|
|
windows[i] = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
var active = windows[ActiveIndex];
|
|
if (active != null) {
|
|
try {
|
|
active.ProcessorAffinity = fullAffinity;
|
|
} catch (Exception e) {
|
|
windows[ActiveIndex] = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void AdjustPriorities() {
|
|
CleanWindows();
|
|
for (int i = 0; i < NumProc; i++) {
|
|
var window = windows[i];
|
|
if (window == null)
|
|
continue;
|
|
|
|
if (i != ActiveIndex) {
|
|
try {
|
|
window.PriorityClass = ProcessPriorityClass.Idle;
|
|
} catch (Exception e) {
|
|
windows[i] = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
var active = windows[ActiveIndex];
|
|
if (active != null) {
|
|
try {
|
|
active.PriorityClass = ProcessPriorityClass.High;
|
|
} catch (Exception e) {
|
|
windows[ActiveIndex] = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static Process GetForegroundProcess() {
|
|
var foregroundWindow = GetForegroundWindow();
|
|
var process = Process.GetProcesses();
|
|
Process foregroundProcess = null;
|
|
foreach (var p in process)
|
|
if (foregroundWindow == p.MainWindowHandle) {
|
|
foregroundProcess = p;
|
|
break;
|
|
}
|
|
|
|
if (foregroundProcess == null)
|
|
return null;
|
|
return foregroundProcess;
|
|
}
|
|
|
|
private static Boolean ProcessTracked(int id) {
|
|
for (int i = 0; i < NumProc; i++) {
|
|
if (windows[i] != null && windows[i].Id == id) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static void Track(Process process) {
|
|
// First find the first null slot
|
|
int firstNullIndex = -1;
|
|
for (int i = 0; i < NumProc; i++) {
|
|
if (windows[i] == null) {
|
|
firstNullIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (firstNullIndex == -1) {
|
|
Console.WriteLine("No slots available for tracking");
|
|
return;
|
|
}
|
|
|
|
// Compact the array by shifting non-null elements to the left
|
|
for (int i = firstNullIndex + 1; i < NumProc; i++) {
|
|
if (windows[i] != null) {
|
|
windows[firstNullIndex] = windows[i];
|
|
windows[i] = null;
|
|
firstNullIndex++;
|
|
}
|
|
}
|
|
|
|
// Add the new process at the first null slot
|
|
windows[firstNullIndex] = process;
|
|
PushHistory(firstNullIndex);
|
|
ActiveIndex = firstNullIndex;
|
|
Console.WriteLine($"Added {process.ProcessName} to tracked windows at index {firstNullIndex}");
|
|
|
|
// Set default first/last indices if not set
|
|
SetDefaultFirstLastIndices();
|
|
SaveSettings();
|
|
}
|
|
|
|
private static void TrackProcess() {
|
|
CleanWindows();
|
|
var foregroundWindow = GetForegroundWindow();
|
|
var foregroundProcess = Process.GetProcesses().FirstOrDefault(p => p.MainWindowHandle == foregroundWindow);
|
|
if (foregroundProcess == null) {
|
|
Console.WriteLine("No foreground process found");
|
|
return;
|
|
}
|
|
Console.WriteLine($"Foreground process: {foregroundProcess.ProcessName} PID: {foregroundProcess.Id}");
|
|
|
|
var processes = Process.GetProcesses().OrderBy(p => p.Id).ToList();
|
|
foreach (var process in processes) {
|
|
// Console.WriteLine($"Checking {process.ProcessName} at pid {process.Id}");
|
|
if (process.ProcessName == foregroundProcess.ProcessName) {
|
|
Console.WriteLine($"Found {foregroundProcess.ProcessName} at pid {process.Id}");
|
|
if (ProcessTracked(process.Id))
|
|
continue;
|
|
Track(process);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void Swap(int index) {
|
|
index = (index - 1) % NumProc;
|
|
if (index < 0)
|
|
index = NumProc - 1;
|
|
if (index >= NumProc)
|
|
return;
|
|
CleanWindows();
|
|
Console.WriteLine($"Swapping window at index {index}");
|
|
var process = GetForegroundProcess();
|
|
if (process == null)
|
|
return;
|
|
Console.WriteLine($"Foreground process: {process}");
|
|
bool found = false;
|
|
|
|
for (int i = 0; i < NumProc; i++) {
|
|
var window = windows[i];
|
|
if (window != null && window.Id == process.Id) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
for (int i = 0; i < NumProc; i++) {
|
|
var window = windows[i];
|
|
if (window == null) {
|
|
Console.WriteLine($"Adding foreground window to tracked at index {i}...");
|
|
windows[i] = process;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < NumProc; i++) {
|
|
var window = windows[i];
|
|
if (window != null && window.Id == process.Id) {
|
|
windows[i] = windows[index];
|
|
windows[index] = window;
|
|
Console.WriteLine($"Swapped window at index {i} to {index}");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void TabTo(int index) {
|
|
Console.WriteLine($"TabTo called with index: {index}");
|
|
index = (index - 1) % NumProc;
|
|
if (index < 0)
|
|
index = NumProc - 1;
|
|
if (index >= NumProc)
|
|
return;
|
|
CleanWindows();
|
|
Console.WriteLine($"Tab to window at index {index}");
|
|
|
|
// Find the next non-null window if the target is null
|
|
int originalIndex = index;
|
|
while (index < NumProc && (windows[index] == null || windows[index].MainWindowHandle == IntPtr.Zero)) {
|
|
index++;
|
|
}
|
|
if (index >= NumProc) {
|
|
// Try from the beginning
|
|
index = 0;
|
|
while (index < originalIndex &&
|
|
(windows[index] == null || windows[index].MainWindowHandle == IntPtr.Zero)) {
|
|
index++;
|
|
}
|
|
}
|
|
|
|
if (index >= NumProc || windows[index] == null || windows[index].MainWindowHandle == IntPtr.Zero) {
|
|
Console.WriteLine("No valid windows found to tab to");
|
|
return;
|
|
}
|
|
|
|
var window = windows[index];
|
|
Console.WriteLine(
|
|
$"Window at index {index}: {(window == null ? "NULL" : window.ProcessName + " PID:" + window.Id)}");
|
|
|
|
if (window == null || window.MainWindowHandle == IntPtr.Zero) {
|
|
Console.WriteLine($"Window at index {index} does not exist, removing from tracked windows");
|
|
windows[index] = null;
|
|
} else {
|
|
if (ActiveIndex != -1)
|
|
PushHistory(ActiveIndex);
|
|
|
|
Console.WriteLine($"Setting foreground window to: {window.ProcessName} PID:{window.Id}");
|
|
bool result = SetForegroundWindow(window.MainWindowHandle);
|
|
Console.WriteLine($"SetForegroundWindow result: {result}");
|
|
|
|
// Force window to front with additional methods
|
|
if (result) {
|
|
// Bring window to front and activate it
|
|
SetForegroundWindow(window.MainWindowHandle);
|
|
System.Threading.Thread.Sleep(50); // Small delay
|
|
|
|
// Check if it actually worked
|
|
var currentForeground = GetForegroundWindow();
|
|
bool actuallySwitched = (currentForeground == window.MainWindowHandle);
|
|
Console.WriteLine(
|
|
$"Actually switched: {actuallySwitched} (Current: {currentForeground}, Target: {window.MainWindowHandle})");
|
|
}
|
|
|
|
ActiveIndex = index;
|
|
AdjustAffinities();
|
|
AdjustPriorities();
|
|
Console.WriteLine($"Successfully switched to window at index {index}");
|
|
}
|
|
}
|
|
|
|
private static void TabToPrevious() {
|
|
return;
|
|
try {
|
|
var foreground = GetForegroundProcess();
|
|
if (!ProcessTracked(foreground.Id)) {
|
|
Console.WriteLine("Foreground process not tracked, skipping");
|
|
return;
|
|
}
|
|
} catch (Exception e) {
|
|
Console.WriteLine($"Error setting foreground window: {e}");
|
|
}
|
|
|
|
if (lastWindows.Count == 0) {
|
|
Console.WriteLine("No previous window to switch to");
|
|
return;
|
|
}
|
|
CleanWindows();
|
|
|
|
for (int i = lastWindows.Count - 1; i >= 0; i--) {
|
|
int index = lastWindows[i];
|
|
if (index != ActiveIndex) {
|
|
TabTo(index + 1); // Our windows are 1-indexed because... I don't remember why
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static bool IsCapsLockOn() {
|
|
return (GetKeyState(0x14) & 1) == 1;
|
|
}
|
|
|
|
private static void ToggleCapsLock() {
|
|
keybd_event(0x14, 0, 0, 0); // KEYEVENTF_KEYDOWN
|
|
keybd_event(0x14, 0, 0x0002, 0); // KEYEVENTF_KEYUP
|
|
}
|
|
|
|
private static void PushHistory(int index) {
|
|
lastWindows.Add(index);
|
|
if (lastWindows.Count > 50)
|
|
lastWindows.RemoveAt(0);
|
|
}
|
|
|
|
[STAThread]
|
|
private static void Main() {
|
|
// AllocConsole(); // Enable console for debug output
|
|
Application.EnableVisualStyles();
|
|
Application.SetCompatibleTextRenderingDefault(false);
|
|
|
|
// Load settings
|
|
LoadSettings();
|
|
|
|
var processes = Process.GetProcesses();
|
|
var currentProcess = Process.GetCurrentProcess();
|
|
|
|
foreach (var process in processes)
|
|
if (process.Id != currentProcess.Id && process.ProcessName == currentProcess.ProcessName) {
|
|
process.Kill();
|
|
Process.GetCurrentProcess().Kill();
|
|
}
|
|
|
|
bool onlyAlt = false;
|
|
KeyboardHook.Start();
|
|
|
|
// Set up mouse hook for sequence mode
|
|
mouseHookDelegate = new MouseHookProc(MouseHookCallback);
|
|
mouseHookProc = Marshal.GetFunctionPointerForDelegate(mouseHookDelegate);
|
|
mouseHookId = SetWindowsHookEx(WH_MOUSE_LL, mouseHookProc,
|
|
GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName), 0);
|
|
KeyboardHook.KeyDown += (sender, e) => {
|
|
Console.WriteLine($"Key down: {e}");
|
|
if (e == 164 && !onlyAlt) {
|
|
Console.WriteLine("Only alt");
|
|
onlyAlt = true;
|
|
} else {
|
|
Console.WriteLine("Not only alt");
|
|
onlyAlt = false;
|
|
}
|
|
};
|
|
KeyboardHook.KeyUp += (sender, e) => {
|
|
Console.WriteLine($"Key up: {e}");
|
|
if (e == 164 && onlyAlt) { // Left alt
|
|
Console.WriteLine("Tab to previous");
|
|
onlyAlt = false;
|
|
TabToPrevious();
|
|
}
|
|
|
|
// Handle sequence mode event detection with KeyUp
|
|
if (CurrentState == SequenceState.WAITING) {
|
|
// Ignore the sequence keybind itself
|
|
if (e != (int)SequenceKeybind) {
|
|
Console.WriteLine($"Key up detected in state: {CurrentState} - Key: {e}");
|
|
HandleSequenceEvent();
|
|
} else {
|
|
Console.WriteLine($"Ignoring sequence keybind release: {e}");
|
|
}
|
|
}
|
|
};
|
|
|
|
HotKeyManager.RegisterHotKey(Keys.Capital, KeyModifiers.NoRepeat);
|
|
// Register main number keys (0-9)
|
|
for (int i = 0; i < 10; i++) HotKeyManager.RegisterHotKey(Keys.D0 + i, KeyModifiers.Alt);
|
|
|
|
// Register numpad keys (1-9)
|
|
for (int i = 0; i < 9; i++) HotKeyManager.RegisterHotKey(Keys.NumPad1 + i, KeyModifiers.Alt);
|
|
|
|
HotKeyManager.RegisterHotKey(Keys.Oemtilde, KeyModifiers.Alt);
|
|
sequenceHotkeyId = HotKeyManager.RegisterHotKey(SequenceKeybind, KeyModifiers.NoRepeat);
|
|
Console.WriteLine(
|
|
$"Initial sequence hotkey registration - ID: {sequenceHotkeyId}, Key: {SequenceKeybind} (code: {(int)SequenceKeybind})");
|
|
HotKeyManager.HotKeyPressed += HotKeyManager_HotKeyPressed;
|
|
|
|
void HotKeyManager_HotKeyPressed(object sender, HotKeyEventArgs e) {
|
|
Console.WriteLine($"Hotkey pressed: {e.Key} with modifiers {e.Modifiers}");
|
|
Console.WriteLine($"Current sequence keybind: {SequenceKeybind}");
|
|
Console.WriteLine($"Key codes - Pressed: {(int)e.Key}, Expected: {(int)SequenceKeybind}");
|
|
|
|
// Check for sequence mode keybind
|
|
Console.WriteLine(
|
|
$"Checking sequence keybind - Key: {e.Key} == {SequenceKeybind} = {e.Key == SequenceKeybind}");
|
|
Console.WriteLine($"Checking modifiers - Received: {e.Modifiers}, Expected: {KeyModifiers.NoRepeat}");
|
|
if (e.Key == SequenceKeybind) {
|
|
Console.WriteLine("Sequence keybind detected!");
|
|
if (CurrentState != SequenceState.INACTIVE) {
|
|
Console.WriteLine("Advancing sequence step");
|
|
NextSequenceStep();
|
|
} else {
|
|
Console.WriteLine("Starting sequence mode");
|
|
StartSequenceMode();
|
|
}
|
|
return;
|
|
} else {
|
|
Console.WriteLine(
|
|
$"Sequence keybind check failed - Key match: {e.Key == SequenceKeybind}, Modifiers match: {e.Modifiers == KeyModifiers.NoRepeat}");
|
|
}
|
|
|
|
// Cancel sequence mode on any manual window switching
|
|
if (CurrentState != SequenceState.INACTIVE && e.Modifiers == KeyModifiers.Alt) {
|
|
Console.WriteLine("Manual window switching detected, cancelling sequence mode");
|
|
ExitSequenceMode();
|
|
}
|
|
|
|
if (e.Key == Keys.Oemtilde && e.Modifiers == KeyModifiers.Alt && IsCapsLockOn()) {
|
|
TrackProcess();
|
|
ToggleCapsLock();
|
|
return;
|
|
}
|
|
|
|
int index;
|
|
if (e.Key >= Keys.D0 && e.Key <= Keys.D9) {
|
|
index = e.Key - Keys.D0;
|
|
} else if (e.Key >= Keys.NumPad1 && e.Key <= Keys.NumPad9) {
|
|
index = 10 + (e.Key - Keys.NumPad1);
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
if (e.Modifiers == KeyModifiers.Alt) {
|
|
if (IsCapsLockOn()) {
|
|
Swap(index);
|
|
ToggleCapsLock();
|
|
} else {
|
|
TabTo(index);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Run the WinForms application with Form1 as the main form
|
|
Application.Run(new Form1());
|
|
KeyboardHook.Stop();
|
|
|
|
// Clean up mouse hook
|
|
if (mouseHookId != IntPtr.Zero) {
|
|
UnhookWindowsHookEx(mouseHookId);
|
|
}
|
|
}
|
|
}
|
|
}
|