refactor: Steam-Wrapper-Logik nach focusfix.py verlagert , launch.vbs jetzt obsolet/optional

- Projektname auf FocusFix geändert

focusfix.py

@@ -0,0 +1,273 @@
+"""
+focusfix.py
+Bringt ein gestartetes Spiel automatisch in den Vordergrund.
+
+Verwendung:
+    pythonw focusfix.py [--timeout 120] --process GameName
+    pythonw focusfix.py [--timeout 120] "C:\\Path\\To\\Game.exe" [args...]
+
+Abhängigkeiten (im .venv):
+    pip install psutil pywin32
+"""
+
+import argparse
+import ctypes
+import logging
+import subprocess
+import sys
+import time
+
+import psutil
+import win32api
+import win32con
+import win32gui
+import win32process
+
+from pathlib import Path
+
+_LOG_PATH = Path(__file__).resolve().parent / "focusfix.log"
+logging.basicConfig(
+    filename=str(_LOG_PATH),
+    level=logging.DEBUG,
+    format="%(asctime)s %(levelname)s %(message)s",
+)
+
+# Minimale Fensterbreite in Pixeln, um den Splashscreen auszuschließen.
+MIN_WINDOW_WIDTH = 800
+
+# Anzahl der Fokus-Versuche und Pause dazwischen
+FOCUS_RETRIES = 15
+FOCUS_RETRY_DELAY = 2.0
+
+
+def derive_process_name(command: list[str]) -> str:
+    if not command:
+        raise ValueError("No game command provided")
+    return Path(command[0]).stem
+
+
+def launch_game(command: list[str]) -> subprocess.Popen:
+    logging.info("Launching game command: %r", command)
+    return subprocess.Popen(command)
+
+
+def find_process_pids(name: str) -> set[int]:
+    pids = set()
+    for proc in psutil.process_iter(["pid", "name"]):
+        try:
+            if name.lower() in proc.info["name"].lower():
+                pids.add(proc.info["pid"])
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            pass
+    return pids
+
+
+def find_game_window(pids: set[int]) -> int | None:
+    found = []
+
+    def callback(hwnd, _):
+        if not win32gui.IsWindowVisible(hwnd):
+            return True
+        try:
+            _, pid = win32process.GetWindowThreadProcessId(hwnd)
+        except Exception:
+            return True
+        if pid not in pids:
+            return True
+        try:
+            rect = win32gui.GetWindowRect(hwnd)
+        except Exception:
+            return True
+        width = rect[2] - rect[0]
+        height = rect[3] - rect[1]
+        if width >= MIN_WINDOW_WIDTH:
+            title = win32gui.GetWindowText(hwnd)
+            logging.debug("Candidate window: hwnd=%s title=%r size=%dx%d pid=%d", hwnd, title, width, height, pid)
+            found.append((hwnd, title, width, height))
+        return True
+
+    win32gui.EnumWindows(callback, None)
+    if not found:
+        return None
+    # Fenster mit Titel bevorzugen, dann nach Größe sortieren
+    found.sort(key=lambda x: (bool(x[1]), x[2] * x[3]), reverse=True)
+    return found[0][0]
+
+
+def wait_for_stable_size(hwnd: int, polls: int = 3, interval: float = 0.5,
+                         timeout: float = 5.0) -> tuple[int, int]:
+    """Wartet bis die Fenstergröße sich stabilisiert hat (kein Resize mehr).
+    Gibt die finale (width, height) zurück."""
+    last_size = (0, 0)
+    stable_count = 0
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        try:
+            rect = win32gui.GetWindowRect(hwnd)
+            size = (rect[2] - rect[0], rect[3] - rect[1])
+        except Exception:
+            break
+        if size == last_size:
+            stable_count += 1
+            if stable_count >= polls:
+                break
+        else:
+            stable_count = 0
+            last_size = size
+        time.sleep(interval)
+    logging.debug("Stable size for hwnd=%s: %dx%d (after %d stable polls)",
+                  hwnd, last_size[0], last_size[1], stable_count)
+    return last_size
+
+
+def is_foreground(hwnd: int) -> bool:
+    """Prüft ob das angegebene Fenster aktuell das Vordergrundfenster ist."""
+    return win32gui.GetForegroundWindow() == hwnd
+
+
+def bring_to_front(hwnd: int) -> bool:
+    """
+    Bringt das Fenster in den Vordergrund. Gibt True zurück wenn erfolgreich.
+    Verwendet Alt-Key + AttachThreadInput als Workaround.
+    """
+    try:
+        # Alt-Taste simulieren — hebt die SetForegroundWindow-Sperre auf
+        win32api.keybd_event(win32con.VK_MENU, 0, 0, 0)
+        time.sleep(0.05)
+
+        fg_hwnd = win32gui.GetForegroundWindow()
+        fg_tid, _ = win32process.GetWindowThreadProcessId(fg_hwnd)
+        tgt_tid, _ = win32process.GetWindowThreadProcessId(hwnd)
+
+        attached = False
+        if fg_tid != tgt_tid:
+            ctypes.windll.user32.AttachThreadInput(tgt_tid, fg_tid, True)
+            attached = True
+
+        win32gui.ShowWindow(hwnd, win32con.SW_SHOW)
+        win32gui.BringWindowToTop(hwnd)
+        win32gui.SetForegroundWindow(hwnd)
+        ctypes.windll.user32.SetFocus(hwnd)
+        ctypes.windll.user32.SetActiveWindow(hwnd)
+
+        if attached:
+            ctypes.windll.user32.AttachThreadInput(tgt_tid, fg_tid, False)
+
+        result = is_foreground(hwnd)
+        logging.debug("bring_to_front result: %s (foreground hwnd=%s, target hwnd=%s)",
+                       result, win32gui.GetForegroundWindow(), hwnd)
+        return result
+    except Exception as e:
+        logging.exception("bring_to_front failed: %s", e)
+        return False
+    finally:
+        win32api.keybd_event(win32con.VK_MENU, 0, win32con.KEYEVENTF_KEYUP, 0)
+
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--timeout", type=int, default=120)
+    parser.add_argument("--process", type=str,
+                        help="Prozessname des Spiels (ohne .exe)")
+    parser.add_argument("command", nargs="*",
+                        help="Steam-Spielbefehl, z.B. %%command%%")
+    args, extra_command_args = parser.parse_known_args()
+
+    process_name = args.process
+    command = args.command + extra_command_args
+
+    if command:
+        if process_name:
+            parser.error("Use either --process or a game command, not both.")
+        try:
+            process_name = derive_process_name(command)
+        except ValueError as exc:
+            parser.error(str(exc))
+        try:
+            launch_game(command)
+        except OSError as exc:
+            logging.exception("Failed to launch game command: %s", exc)
+            sys.exit(1)
+    elif not process_name:
+        parser.error("Either --process or a game command is required.")
+
+    deadline = time.time() + args.timeout
+    logging.info("Monitoring process name: %s", process_name)
+
+    # --- Phase 1: Warten auf den Prozess ---
+    pids: set[int] = set()
+    while time.time() < deadline:
+        pids = find_process_pids(process_name)
+        if pids:
+            break
+        time.sleep(0.5)
+    else:
+        sys.exit(1)
+
+    # --- Phase 2: Warten auf das Hauptfenster ---
+    hwnd: int | None = None
+    while time.time() < deadline:
+        pids = find_process_pids(process_name)
+        hwnd = find_game_window(pids)
+        if hwnd:
+            logging.info("Initial window found: hwnd=%s title=%r", hwnd, win32gui.GetWindowText(hwnd))
+            # Warten bis das Spiel sein Fenster vollständig aufgebaut hat
+            time.sleep(3)
+            break
+        time.sleep(0.5)
+    else:
+        logging.error("Timeout waiting for game window")
+        sys.exit(1)
+
+    # --- Phase 3: Spielfenster fokussieren und auf Fensterwechsel reagieren ---
+    # Beobachtet über die gesamte Retry-Dauer, ob sich das Fenster ändert
+    # (Splash -> Hauptfenster), und fokussiert jedes neue Fenster erneut.
+    focused_hwnd: int | None = None
+    for attempt in range(FOCUS_RETRIES):
+        pids = find_process_pids(process_name)
+        if not pids:
+            logging.warning("Game process gone, stopping")
+            break
+
+        current_hwnd = find_game_window(pids)
+
+        if current_hwnd and current_hwnd != hwnd:
+            new_title = win32gui.GetWindowText(current_hwnd)
+            old_title = win32gui.GetWindowText(hwnd) if hwnd else ""
+            # Nicht von einem Fenster mit Titel auf ein titelloses wechseln
+            if not new_title and old_title:
+                logging.debug("Ignoring titleless window hwnd=%s (keeping %s title=%r)",
+                              current_hwnd, hwnd, old_title)
+            else:
+                logging.info("Window changed: old=%s new=%s title=%r",
+                             hwnd, current_hwnd, new_title)
+                hwnd = current_hwnd
+                focused_hwnd = None  # neues Fenster muss neu fokussiert werden
+                time.sleep(1)
+
+        if not hwnd:
+            time.sleep(FOCUS_RETRY_DELAY)
+            continue
+
+        # Bereits erfolgreich fokussiert — weiter beobachten ob Fenster wechselt
+        if focused_hwnd == hwnd and is_foreground(hwnd):
+            time.sleep(FOCUS_RETRY_DELAY)
+            continue
+
+        # Warten bis Fenstergröße stabil ist (Resize abgeschlossen)
+        wait_for_stable_size(hwnd)
+
+        logging.info("Focus attempt %d/%d for hwnd=%s title=%r",
+                     attempt + 1, FOCUS_RETRIES, hwnd, win32gui.GetWindowText(hwnd))
+        success = bring_to_front(hwnd)
+        if success:
+            logging.info("Focus succeeded on attempt %d", attempt + 1)
+            focused_hwnd = hwnd
+        time.sleep(FOCUS_RETRY_DELAY)
+
+    logging.info("Done. Final focused hwnd=%s", focused_hwnd)
+
+
+if __name__ == "__main__":
+    main()