338 lines
12 KiB
C#
338 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using System.Runtime.InteropServices;
|
|
using System.Windows.Forms;
|
|
using System.Threading;
|
|
|
|
namespace DD2Switcher {
|
|
internal static class Program {
|
|
private static int NumProc = 19;
|
|
private static Process[] windows = new Process[NumProc];
|
|
private static int ActiveIndex = -1;
|
|
private static int PreviousIndex = -1;
|
|
private static bool AltPressed = false;
|
|
private static Timer AltTimer;
|
|
|
|
private static readonly IntPtr defaultAffinity = new(0xFF000000);
|
|
private static readonly IntPtr fullAffinity = new(0xFFFFFFFF);
|
|
|
|
[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);
|
|
|
|
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;
|
|
Console.WriteLine($"Added {process.ProcessName} to tracked windows at index {firstNullIndex}");
|
|
}
|
|
|
|
// private static void TrackWows() {
|
|
// CleanWindows();
|
|
// var processes = Process.GetProcesses().OrderBy(p => p.Id).ToList();
|
|
// foreach (var process in processes) {
|
|
// if (process.ProcessName == "UWow-64") {
|
|
// Console.WriteLine($"Found UWow-64 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}");
|
|
// Toggle caps lock off
|
|
keybd_event(0x14, 0, 0, 0); // KEYEVENTF_KEYDOWN
|
|
keybd_event(0x14, 0, 0x0002, 0); // KEYEVENTF_KEYUP
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void TabTo(int index) {
|
|
index = (index - 1) % NumProc;
|
|
if (index < 0)
|
|
index = NumProc - 1;
|
|
if (index >= NumProc)
|
|
return;
|
|
CleanWindows();
|
|
Console.WriteLine($"Tab to window at index {index}");
|
|
|
|
var window = windows[index];
|
|
if (window == null || window.MainWindowHandle == IntPtr.Zero) {
|
|
Console.WriteLine($"Window at index {index} does not exist, removing from tracked windows");
|
|
windows[index] = null;
|
|
} else {
|
|
PreviousIndex = ActiveIndex;
|
|
SetForegroundWindow(window.MainWindowHandle);
|
|
ActiveIndex = index;
|
|
AdjustAffinities();
|
|
AdjustPriorities();
|
|
}
|
|
}
|
|
|
|
private static void TabToPrevious() {
|
|
if (PreviousIndex == -1) {
|
|
Console.WriteLine("No previous window to switch to");
|
|
return;
|
|
}
|
|
CleanWindows();
|
|
Console.WriteLine($"Tab to previous window at index {PreviousIndex}");
|
|
|
|
var window = windows[PreviousIndex];
|
|
if (window == null || window.MainWindowHandle == IntPtr.Zero) {
|
|
Console.WriteLine(
|
|
$"Previous window at index {PreviousIndex} does not exist, removing from tracked windows");
|
|
windows[PreviousIndex] = null;
|
|
PreviousIndex = -1;
|
|
} else {
|
|
var tempIndex = ActiveIndex;
|
|
SetForegroundWindow(window.MainWindowHandle);
|
|
ActiveIndex = PreviousIndex;
|
|
PreviousIndex = tempIndex;
|
|
AdjustAffinities();
|
|
AdjustPriorities();
|
|
}
|
|
}
|
|
|
|
private static void OnAltTimer() {
|
|
if (AltPressed) {
|
|
AltPressed = false;
|
|
AltTimer.Stop();
|
|
TabToPrevious();
|
|
}
|
|
}
|
|
|
|
private static bool IsCapsLockOn() {
|
|
return (GetKeyState(0x14) & 1) == 1;
|
|
}
|
|
|
|
[STAThread]
|
|
private static void Main() {
|
|
// AllocConsole();
|
|
|
|
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();
|
|
}
|
|
|
|
AltTimer = new Timer(OnAltTimer, null, Timeout.Infinite, Timeout.Infinite);
|
|
|
|
HotKeyManager.RegisterHotKey(Keys.Capital, KeyModifiers.NoRepeat);
|
|
HotKeyManager.RegisterHotKey(Keys.Menu, 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);
|
|
HotKeyManager.HotKeyPressed += HotKeyManager_HotKeyPressed;
|
|
|
|
void HotKeyManager_HotKeyPressed(object sender, HotKeyEventArgs e) {
|
|
// if (e.Key == Keys.Oemtilde && e.Modifiers == KeyModifiers.Alt) {
|
|
// TrackWows();
|
|
// return;
|
|
// }
|
|
|
|
if (e.Key == Keys.Menu && e.Modifiers == KeyModifiers.NoRepeat) {
|
|
AltPressed = true;
|
|
AltTimer.Change(150, Timeout.Infinite);
|
|
return;
|
|
}
|
|
|
|
if (e.Modifiers == KeyModifiers.Alt) {
|
|
AltPressed = false;
|
|
AltTimer.Stop();
|
|
}
|
|
|
|
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);
|
|
} else {
|
|
TabTo(index);
|
|
}
|
|
}
|
|
}
|
|
|
|
Console.CancelKeyPress += (sender, e) => { Process.GetCurrentProcess().Kill(); };
|
|
while (true) System.Threading.Thread.Sleep(100000);
|
|
}
|
|
}
|
|
}
|