- Programm heisst jetzt Squad Manager, Hauptdatei squad_manager.py
- Einstellungen ziehen nach %APPDATA%\SquadManager um; alte werden beim
ersten Start kopiert, nicht verschoben
- Installer: Verknuepfung liegt in {userprograms}, der Deinstallierer
raeumte bisher im falschen Ordner ab; doppelte Verknuepfung entfernt
- Deinstallierer fragt per SuppressibleMsgBox mit Vorgabe Nein, damit
stille Deinstallationen keine Einstellungen loeschen
- HOCHLADEN.txt liegt jetzt in der Quelle und wird beim Bau kopiert
- Plan fuer das Modul Akte (PLAN-AKTE.md)
- Version 3.3
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
1645 lines
63 KiB
Python
1645 lines
63 KiB
Python
"""
|
|
Squad Manager
|
|
Werkzeug fuer Squad. Kernfunktion: haelt die Sprechtaste automatisch
|
|
gedrueckt, solange gesprochen wird.
|
|
|
|
Greift nicht in Squad ein: kein Hook, keine DLL, kein Speicherzugriff.
|
|
Liest nur den Mikrofonpegel und ruft Windows SendInput / GetAsyncKeyState auf.
|
|
"""
|
|
|
|
import ctypes
|
|
import ctypes.wintypes as wintypes
|
|
import json
|
|
import os
|
|
import queue
|
|
import sys
|
|
import threading
|
|
import time
|
|
from pathlib import Path
|
|
|
|
|
|
def _ensure_tcl_paths():
|
|
"""
|
|
Muss vor dem tkinter-Import laufen.
|
|
|
|
Eine virtuelle Umgebung erbt unter Windows die Tcl/Tk-Pfade der
|
|
Basisinstallation nicht. tkinter findet dann init.tcl nicht und
|
|
bricht mit einem TclError ab. Hier werden die Pfade nachgezogen,
|
|
damit das Programm auch per Doppelklick oder Verknuepfung startet.
|
|
"""
|
|
if getattr(sys, "frozen", False):
|
|
return # gepackte EXE bringt Tcl/Tk selbst mit
|
|
tcl_root = Path(getattr(sys, "base_prefix", sys.prefix)) / "tcl"
|
|
if not tcl_root.is_dir():
|
|
return
|
|
for var, prefix, marker in (("TCL_LIBRARY", "tcl8", "init.tcl"),
|
|
("TK_LIBRARY", "tk8", "tk.tcl")):
|
|
if os.environ.get(var):
|
|
continue
|
|
for folder in sorted(tcl_root.glob(prefix + "*")):
|
|
if (folder / marker).is_file():
|
|
os.environ[var] = str(folder)
|
|
break
|
|
|
|
|
|
_ensure_tcl_paths()
|
|
|
|
import tkinter as tk # noqa: E402
|
|
from tkinter import ttk, messagebox # noqa: E402
|
|
|
|
import numpy as np # noqa: E402
|
|
import sounddevice as sd # noqa: E402
|
|
|
|
APP_NAME = "Squad Manager"
|
|
VERSION = "3.3"
|
|
CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "config.json"
|
|
LOG_PATH = CONFIG_PATH.parent / "error.log"
|
|
# Bis Version 3.2 hiess das Programm "Squad Voice Activation"
|
|
ALT_CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadVoiceActivation" / "config.json"
|
|
|
|
|
|
def alte_einstellungen_uebernehmen():
|
|
"""
|
|
Uebernimmt die Einstellungen aus der Zeit vor der Umbenennung.
|
|
|
|
Kopiert statt verschiebt: Eine noch vorhandene alte Installation soll
|
|
ihre Einstellungen behalten.
|
|
"""
|
|
if CONFIG_PATH.exists() or not ALT_CONFIG_PATH.exists():
|
|
return False
|
|
try:
|
|
import shutil
|
|
CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
|
|
shutil.copy2(ALT_CONFIG_PATH, CONFIG_PATH)
|
|
return True
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
UPDATE_URL = "https://sva.tyrveil.com/version.json"
|
|
|
|
|
|
def version_tupel(text):
|
|
"""'3.10' wird zu (3, 10), damit 3.10 groesser ist als 3.9."""
|
|
teile = []
|
|
for stueck in str(text).strip().split("."):
|
|
ziffern = "".join(z for z in stueck if z.isdigit())
|
|
teile.append(int(ziffern) if ziffern else 0)
|
|
return tuple(teile)
|
|
|
|
|
|
def pruefe_update(timeout=6):
|
|
"""
|
|
Fragt die Versionsdatei auf dem Server ab.
|
|
|
|
Gibt die Angaben zurueck, wenn dort eine neuere Fassung steht, sonst
|
|
None. Netzwerkfehler sind kein Grund fuer eine Meldung - ohne
|
|
Internetverbindung laeuft das Programm ganz normal weiter.
|
|
"""
|
|
import json as _json
|
|
import urllib.request
|
|
|
|
if not UPDATE_URL.lower().startswith("https://"):
|
|
return None
|
|
try:
|
|
anfrage = urllib.request.Request(
|
|
UPDATE_URL, headers={"User-Agent": f"{APP_NAME}/{VERSION}"})
|
|
with urllib.request.urlopen(anfrage, timeout=timeout) as antwort:
|
|
angaben = _json.loads(antwort.read(65536).decode("utf-8"))
|
|
except Exception:
|
|
return None
|
|
|
|
ziel = str(angaben.get("version", "")).strip()
|
|
datei = str(angaben.get("datei", "")).strip()
|
|
if not ziel or not datei.lower().startswith("https://"):
|
|
return None
|
|
if version_tupel(ziel) <= version_tupel(VERSION):
|
|
return None
|
|
return {
|
|
"version": ziel,
|
|
"datei": datei,
|
|
"sha256": str(angaben.get("sha256", "")).strip().lower(),
|
|
"hinweis": str(angaben.get("hinweis", "")).strip()[:200],
|
|
}
|
|
|
|
|
|
def lade_update(angaben, ziel_pfad, fortschritt=None):
|
|
"""Laedt das Paket und prueft die Pruefsumme."""
|
|
import hashlib
|
|
import urllib.request
|
|
|
|
anfrage = urllib.request.Request(
|
|
angaben["datei"], headers={"User-Agent": f"{APP_NAME}/{VERSION}"})
|
|
hasher = hashlib.sha256()
|
|
geladen = 0
|
|
with urllib.request.urlopen(anfrage, timeout=30) as antwort:
|
|
gesamt = int(antwort.headers.get("Content-Length") or 0)
|
|
with open(ziel_pfad, "wb") as datei:
|
|
while True:
|
|
brocken = antwort.read(65536)
|
|
if not brocken:
|
|
break
|
|
datei.write(brocken)
|
|
hasher.update(brocken)
|
|
geladen += len(brocken)
|
|
if fortschritt and gesamt:
|
|
fortschritt(geladen, gesamt)
|
|
|
|
erwartet = angaben.get("sha256", "")
|
|
if erwartet and hasher.hexdigest() != erwartet:
|
|
raise ValueError(
|
|
"Die heruntergeladene Datei stimmt nicht mit der angegebenen "
|
|
"Pruefsumme ueberein und wurde verworfen.")
|
|
return ziel_pfad
|
|
|
|
|
|
def spiele_update_ein(zip_pfad, programm_ordner):
|
|
"""
|
|
Entpackt das Paket und startet einen Helfer, der die Dateien ersetzt.
|
|
|
|
Das laufende Programm kann seine eigenen Dateien nicht ueberschreiben.
|
|
Deshalb uebernimmt ein kleines Skript das Kopieren, nachdem sich das
|
|
Programm beendet hat, und startet es anschliessend neu.
|
|
"""
|
|
import subprocess
|
|
import tempfile
|
|
import zipfile
|
|
|
|
arbeit = Path(tempfile.mkdtemp(prefix="sva_update_"))
|
|
with zipfile.ZipFile(zip_pfad) as archiv:
|
|
archiv.extractall(arbeit)
|
|
|
|
quelle = arbeit / "Programm"
|
|
if not quelle.is_dir():
|
|
treffer = list(arbeit.rglob("squad_manager.py"))
|
|
if not treffer:
|
|
raise ValueError("Im Paket wurde kein Programmordner gefunden.")
|
|
quelle = treffer[0].parent
|
|
|
|
helfer = arbeit / "einspielen.bat"
|
|
helfer.write_text(
|
|
"@echo off\r\n"
|
|
"ping -n 4 127.0.0.1 >nul\r\n"
|
|
f'xcopy /e /y /i /q "{quelle}\\*" "{programm_ordner}\\" >nul\r\n'
|
|
f'start "" "{sys.executable}" "{programm_ordner}\\start.pyw"\r\n'
|
|
"ping -n 2 127.0.0.1 >nul\r\n"
|
|
f'rmdir /s /q "{arbeit}"\r\n',
|
|
encoding="ascii")
|
|
|
|
subprocess.Popen(["cmd", "/c", str(helfer)],
|
|
creationflags=0x08000000) # kein Konsolenfenster
|
|
return True
|
|
|
|
|
|
def log_exception(exc_type, exc, tb):
|
|
"""Schreibt einen Fehler ins Log. Ohne Konsolenfenster geht er sonst verloren."""
|
|
import traceback
|
|
text = "".join(traceback.format_exception(exc_type, exc, tb))
|
|
try:
|
|
LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
|
|
with open(LOG_PATH, "a", encoding="utf-8") as fh:
|
|
fh.write(f"\n--- {time.strftime('%Y-%m-%d %H:%M:%S')} ---\n{text}")
|
|
except Exception:
|
|
pass
|
|
return text
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Win32
|
|
# ---------------------------------------------------------------------------
|
|
user32 = ctypes.WinDLL("user32", use_last_error=True)
|
|
kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
|
|
|
|
PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
|
|
# Der laufende Prozess heisst SquadGame-Win64-Shipping.exe, der Launcher
|
|
# SquadGame.exe. Verglichen wird per Praefix, damit beide passen - und
|
|
# damit dieses Programm selbst nicht versehentlich als Squad zaehlt.
|
|
SQUAD_PROCESS_DEFAULT = "SquadGame"
|
|
|
|
INPUT_MOUSE = 0
|
|
INPUT_KEYBOARD = 1
|
|
KEYEVENTF_KEYUP = 0x0002
|
|
|
|
MOUSEEVENTF_MIDDLEDOWN = 0x0020
|
|
MOUSEEVENTF_MIDDLEUP = 0x0040
|
|
MOUSEEVENTF_XDOWN = 0x0080
|
|
MOUSEEVENTF_XUP = 0x0100
|
|
|
|
CURSOR_SHOWING = 0x0001
|
|
|
|
# ULONG_PTR ist zeigergross: 64 Bit auf 64-Bit-Windows
|
|
ULONG_PTR = wintypes.WPARAM
|
|
|
|
|
|
class KEYBDINPUT(ctypes.Structure):
|
|
_fields_ = [
|
|
("wVk", wintypes.WORD),
|
|
("wScan", wintypes.WORD),
|
|
("dwFlags", wintypes.DWORD),
|
|
("time", wintypes.DWORD),
|
|
("dwExtraInfo", ULONG_PTR),
|
|
]
|
|
|
|
|
|
class MOUSEINPUT(ctypes.Structure):
|
|
_fields_ = [
|
|
("dx", wintypes.LONG),
|
|
("dy", wintypes.LONG),
|
|
("mouseData", wintypes.DWORD),
|
|
("dwFlags", wintypes.DWORD),
|
|
("time", wintypes.DWORD),
|
|
("dwExtraInfo", ULONG_PTR),
|
|
]
|
|
|
|
|
|
class HARDWAREINPUT(ctypes.Structure):
|
|
_fields_ = [
|
|
("uMsg", wintypes.DWORD),
|
|
("wParamL", wintypes.WORD),
|
|
("wParamH", wintypes.WORD),
|
|
]
|
|
|
|
|
|
class _INPUTUNION(ctypes.Union):
|
|
_fields_ = [("ki", KEYBDINPUT), ("mi", MOUSEINPUT), ("hi", HARDWAREINPUT)]
|
|
|
|
|
|
class INPUT(ctypes.Structure):
|
|
_anonymous_ = ("u",)
|
|
_fields_ = [("type", wintypes.DWORD), ("u", _INPUTUNION)]
|
|
|
|
|
|
class POINT(ctypes.Structure):
|
|
_fields_ = [("x", wintypes.LONG), ("y", wintypes.LONG)]
|
|
|
|
|
|
class CURSORINFO(ctypes.Structure):
|
|
_fields_ = [
|
|
("cbSize", wintypes.DWORD),
|
|
("flags", wintypes.DWORD),
|
|
("hCursor", wintypes.HANDLE),
|
|
("ptScreenPos", POINT),
|
|
]
|
|
|
|
|
|
user32.SendInput.argtypes = (wintypes.UINT, ctypes.POINTER(INPUT), ctypes.c_int)
|
|
user32.SendInput.restype = wintypes.UINT
|
|
user32.GetAsyncKeyState.argtypes = (ctypes.c_int,)
|
|
user32.GetAsyncKeyState.restype = ctypes.c_short
|
|
user32.GetCursorInfo.argtypes = (ctypes.POINTER(CURSORINFO),)
|
|
user32.GetCursorInfo.restype = wintypes.BOOL
|
|
user32.GetWindowThreadProcessId.argtypes = (wintypes.HWND, ctypes.POINTER(wintypes.DWORD))
|
|
user32.GetWindowThreadProcessId.restype = wintypes.DWORD
|
|
|
|
kernel32.OpenProcess.argtypes = (wintypes.DWORD, wintypes.BOOL, wintypes.DWORD)
|
|
kernel32.OpenProcess.restype = wintypes.HANDLE
|
|
kernel32.QueryFullProcessImageNameW.argtypes = (
|
|
wintypes.HANDLE, wintypes.DWORD, wintypes.LPWSTR, ctypes.POINTER(wintypes.DWORD))
|
|
kernel32.QueryFullProcessImageNameW.restype = wintypes.BOOL
|
|
kernel32.CloseHandle.argtypes = (wintypes.HANDLE,)
|
|
kernel32.CloseHandle.restype = wintypes.BOOL
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tastentabelle: Anzeigename -> (art, code)
|
|
# art "key" -> code ist ein Virtual-Key-Code
|
|
# art "mouse" -> code ist die XBUTTON-Nummer (3 = mittlere Maustaste)
|
|
# ---------------------------------------------------------------------------
|
|
VK_MBUTTON, VK_XBUTTON1, VK_XBUTTON2 = 0x04, 0x05, 0x06
|
|
|
|
KEYS = {}
|
|
for _c in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
|
|
KEYS[_c] = ("key", ord(_c))
|
|
for _n in range(10):
|
|
KEYS[str(_n)] = ("key", 0x30 + _n)
|
|
for _i in range(1, 13):
|
|
KEYS[f"F{_i}"] = ("key", 0x6F + _i)
|
|
KEYS.update({
|
|
"Maus mitte": ("mouse", 3),
|
|
"Maus 4": ("mouse", 1),
|
|
"Maus 5": ("mouse", 2),
|
|
"Pause": ("key", 0x13),
|
|
"Rollen": ("key", 0x91),
|
|
"Einfg": ("key", 0x2D),
|
|
"Entf": ("key", 0x2E),
|
|
"Pos1": ("key", 0x24),
|
|
"Ende": ("key", 0x23),
|
|
"Bild auf": ("key", 0x21),
|
|
"Bild ab": ("key", 0x22),
|
|
})
|
|
|
|
KEY_NAMES = list(KEYS.keys())
|
|
NONE_LABEL = "(keine)"
|
|
NO_MOD_LABEL = "(kein)"
|
|
|
|
# Zusatztasten fuer Kombinationen wie Strg+V (Squad "Direct Voice" o. ae.)
|
|
MODIFIERS = {
|
|
NO_MOD_LABEL: None,
|
|
"Strg": 0x11, # VK_CONTROL
|
|
"Alt": 0x12, # VK_MENU
|
|
"Shift": 0x10, # VK_SHIFT
|
|
}
|
|
MOD_NAMES = list(MODIFIERS.keys())
|
|
|
|
|
|
def _async_vk(name):
|
|
"""Virtual-Key-Code, mit dem GetAsyncKeyState diese Taste abgefragt wird."""
|
|
kind, code = KEYS[name]
|
|
if kind == "key":
|
|
return code
|
|
return {1: VK_XBUTTON1, 2: VK_XBUTTON2, 3: VK_MBUTTON}[code]
|
|
|
|
|
|
def is_physically_down(name):
|
|
"""True, wenn die Taste gerade gedrueckt ist (egal ob echt oder simuliert)."""
|
|
if name not in KEYS:
|
|
return False
|
|
return bool(user32.GetAsyncKeyState(_async_vk(name)) & 0x8000)
|
|
|
|
|
|
def is_binding_down(mod, name):
|
|
"""True, wenn Taste und ggf. zugehoerige Zusatztaste gleichzeitig gehalten werden."""
|
|
if name not in KEYS:
|
|
return False
|
|
mod_vk = MODIFIERS.get(mod)
|
|
if mod_vk is not None and not (user32.GetAsyncKeyState(mod_vk) & 0x8000):
|
|
return False
|
|
return is_physically_down(name)
|
|
|
|
|
|
def _send(kind, **fields):
|
|
if kind == "key":
|
|
inp = INPUT(type=INPUT_KEYBOARD, ki=KEYBDINPUT(**fields))
|
|
else:
|
|
inp = INPUT(type=INPUT_MOUSE, mi=MOUSEINPUT(**fields))
|
|
sent = user32.SendInput(1, ctypes.byref(inp), ctypes.sizeof(INPUT))
|
|
if sent != 1:
|
|
err = ctypes.get_last_error()
|
|
raise OSError(err, f"SendInput fehlgeschlagen (sent={sent}, error={err})")
|
|
|
|
|
|
def send_input_key(name, down):
|
|
"""Drueckt bzw. loesst die benannte Taste."""
|
|
kind, code = KEYS[name]
|
|
if kind == "key":
|
|
_send("key", wVk=code, wScan=0,
|
|
dwFlags=0 if down else KEYEVENTF_KEYUP, time=0, dwExtraInfo=0)
|
|
elif code == 3:
|
|
_send("mouse", dx=0, dy=0, mouseData=0,
|
|
dwFlags=MOUSEEVENTF_MIDDLEDOWN if down else MOUSEEVENTF_MIDDLEUP,
|
|
time=0, dwExtraInfo=0)
|
|
else:
|
|
_send("mouse", dx=0, dy=0, mouseData=code,
|
|
dwFlags=MOUSEEVENTF_XDOWN if down else MOUSEEVENTF_XUP,
|
|
time=0, dwExtraInfo=0)
|
|
|
|
|
|
def send_modifier(mod, down):
|
|
vk = MODIFIERS.get(mod)
|
|
if vk is None:
|
|
return
|
|
_send("key", wVk=vk, wScan=0,
|
|
dwFlags=0 if down else KEYEVENTF_KEYUP, time=0, dwExtraInfo=0)
|
|
|
|
|
|
def send_binding(mod, name, down):
|
|
"""Drueckt bzw. loesst eine Kombination. Zusatztaste zuerst rein, zuletzt raus."""
|
|
if down:
|
|
send_modifier(mod, True)
|
|
send_input_key(name, True)
|
|
else:
|
|
send_input_key(name, False)
|
|
send_modifier(mod, False)
|
|
|
|
|
|
def get_foreground_process_name():
|
|
"""Dateiname des Prozesses, dem das aktive Fenster gehoert (z. B. SquadGame.exe)."""
|
|
hwnd = user32.GetForegroundWindow()
|
|
if not hwnd:
|
|
return ""
|
|
pid = wintypes.DWORD()
|
|
user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
|
|
if not pid.value:
|
|
return ""
|
|
handle = kernel32.OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, False, pid.value)
|
|
if not handle:
|
|
return ""
|
|
try:
|
|
size = wintypes.DWORD(1024)
|
|
buf = ctypes.create_unicode_buffer(size.value)
|
|
if kernel32.QueryFullProcessImageNameW(handle, 0, buf, ctypes.byref(size)):
|
|
return os.path.basename(buf.value)
|
|
return ""
|
|
finally:
|
|
kernel32.CloseHandle(handle)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Erscheinungsbild - gedeckte Militaerfarben, dunkler Untergrund
|
|
# ---------------------------------------------------------------------------
|
|
BG = "#151814" # Fensterhintergrund, fast schwarz mit Gruenstich
|
|
PANEL = "#1e231b" # Flaechen, Eingabefelder
|
|
PANEL_HI = "#2a3125" # Hover, ausgewaehlter Reiter
|
|
LINE = "#3d4634" # Rahmen und Trennlinien
|
|
FG = "#c9cec0" # Standardtext, helles Khaki
|
|
FG_DIM = "#7f8874" # Nebentext
|
|
OLIVE = "#6e8b3d" # Akzent, Fortschritt
|
|
OLIVE_HI = "#8cb04d" # heller Akzent
|
|
AMBER = "#d9a441" # Hinweise, Schwellenmarke
|
|
AMBER_HELL = "#e8bb63" # Mauskontakt auf der Hinweisleiste
|
|
AMBER_DUNKEL = "#2b2416" # Untergrund der Hinweisleiste
|
|
RED = "#b4472f" # Sperre, Fehler
|
|
GREEN_TX = "#9ed23f" # Sendebereit
|
|
|
|
FONT_UI = ("Segoe UI", 9)
|
|
FONT_BOLD = ("Segoe UI Semibold", 9)
|
|
FONT_TITLE = ("Segoe UI", 17, "bold")
|
|
FONT_MONO = ("Consolas", 9)
|
|
FONT_STATUS = ("Consolas", 13, "bold")
|
|
|
|
|
|
def apply_tactical_theme(root):
|
|
"""Dunkles, gedecktes Farbschema im Stil der Spieloberflaeche."""
|
|
root.configure(bg=BG)
|
|
style = ttk.Style(root)
|
|
# "clam" ist das einzige mitgelieferte Thema, das sich durchgaengig
|
|
# umfaerben laesst - "vista" ignoriert die meisten Farbangaben.
|
|
style.theme_use("clam")
|
|
|
|
style.configure(".", background=BG, foreground=FG, font=FONT_UI,
|
|
bordercolor=LINE, darkcolor=PANEL, lightcolor=PANEL,
|
|
troughcolor=PANEL, focuscolor=OLIVE)
|
|
style.configure("TFrame", background=BG)
|
|
style.configure("TLabel", background=BG, foreground=FG)
|
|
style.configure("Dim.TLabel", foreground=FG_DIM)
|
|
style.configure("Mono.TLabel", font=FONT_MONO, foreground=FG)
|
|
style.configure("Title.TLabel", font=FONT_TITLE, foreground=FG)
|
|
style.configure("Sub.TLabel", foreground=FG_DIM)
|
|
|
|
style.configure("TLabelframe", background=BG, bordercolor=LINE,
|
|
relief="solid", borderwidth=1)
|
|
style.configure("TLabelframe.Label", background=BG, foreground=OLIVE_HI,
|
|
font=FONT_BOLD)
|
|
|
|
style.configure("TButton", background=PANEL, foreground=FG,
|
|
bordercolor=LINE, relief="solid", borderwidth=1,
|
|
padding=(12, 6), font=FONT_UI)
|
|
style.map("TButton",
|
|
background=[("pressed", OLIVE), ("active", PANEL_HI),
|
|
("disabled", PANEL)],
|
|
foreground=[("disabled", FG_DIM)],
|
|
bordercolor=[("active", OLIVE)])
|
|
|
|
style.configure("Accent.TButton", background=OLIVE, foreground="#12150f",
|
|
font=FONT_BOLD, bordercolor=OLIVE_HI)
|
|
style.map("Accent.TButton",
|
|
background=[("pressed", OLIVE), ("active", OLIVE_HI),
|
|
("disabled", PANEL)],
|
|
foreground=[("disabled", FG_DIM)])
|
|
|
|
for widget in ("TCombobox", "TSpinbox", "TEntry"):
|
|
style.configure(widget, fieldbackground=PANEL, background=PANEL,
|
|
foreground=FG, bordercolor=LINE, arrowcolor=OLIVE_HI,
|
|
insertcolor=FG, selectbackground=OLIVE,
|
|
selectforeground="#12150f", padding=4)
|
|
style.map(widget,
|
|
fieldbackground=[("readonly", PANEL), ("disabled", BG)],
|
|
foreground=[("disabled", FG_DIM)],
|
|
bordercolor=[("focus", OLIVE)])
|
|
# Die aufklappende Liste einer Combobox ist ein klassisches Tk-Widget
|
|
# und muss ueber die Optionsdatenbank eingefaerbt werden.
|
|
root.option_add("*TCombobox*Listbox.background", PANEL)
|
|
root.option_add("*TCombobox*Listbox.foreground", FG)
|
|
root.option_add("*TCombobox*Listbox.selectBackground", OLIVE)
|
|
root.option_add("*TCombobox*Listbox.selectForeground", "#12150f")
|
|
root.option_add("*TCombobox*Listbox.font", FONT_UI)
|
|
|
|
style.configure("TCheckbutton", background=BG, foreground=FG,
|
|
indicatorcolor=PANEL, indicatorrelief="solid")
|
|
style.map("TCheckbutton",
|
|
background=[("active", BG)],
|
|
indicatorcolor=[("selected", OLIVE_HI), ("active", PANEL_HI)],
|
|
foreground=[("disabled", FG_DIM)])
|
|
|
|
style.configure("TNotebook", background=BG, bordercolor=LINE,
|
|
tabmargins=(2, 4, 2, 0))
|
|
style.configure("TNotebook.Tab", background="#10120f", foreground=FG_DIM,
|
|
bordercolor=LINE, lightcolor="#10120f",
|
|
darkcolor="#10120f", padding=(20, 9), font=FONT_BOLD)
|
|
style.map("TNotebook.Tab",
|
|
background=[("selected", PANEL_HI), ("active", PANEL)],
|
|
lightcolor=[("selected", PANEL_HI)],
|
|
darkcolor=[("selected", PANEL_HI)],
|
|
foreground=[("selected", OLIVE_HI), ("active", FG)],
|
|
expand=[("selected", (0, 0, 0, 0))])
|
|
|
|
# Der Schieberegler von clam ist standardmaessig hell und wuerde aus
|
|
# dem Schema fallen.
|
|
style.configure("Horizontal.TScale", background=BG, troughcolor="#10120f",
|
|
bordercolor=LINE, lightcolor=OLIVE, darkcolor=OLIVE)
|
|
style.map("Horizontal.TScale",
|
|
background=[("active", BG)],
|
|
lightcolor=[("active", OLIVE_HI)],
|
|
darkcolor=[("active", OLIVE_HI)])
|
|
style.configure("TSeparator", background=LINE)
|
|
return style
|
|
|
|
|
|
class LevelMeter(tk.Canvas):
|
|
"""
|
|
Segmentierte Pegelanzeige mit Schwellenmarke.
|
|
|
|
Zeigt anders als eine gewoehnliche Fortschrittsleiste, wo die
|
|
Ausloeseschwelle relativ zum Pegel liegt - genau die Information,
|
|
die man zum Einstellen braucht.
|
|
"""
|
|
SEGMENTS = 40
|
|
MAXIMUM = 0.10
|
|
|
|
def __init__(self, master, width=320, height=26):
|
|
super().__init__(master, width=width, height=height, bg=PANEL,
|
|
highlightthickness=1, highlightbackground=LINE,
|
|
bd=0)
|
|
self._level = 0.0
|
|
self._threshold = 0.025
|
|
self._active = False
|
|
self.bind("<Configure>", lambda e: self._redraw())
|
|
|
|
def update_values(self, level, threshold, active):
|
|
self._level, self._threshold, self._active = level, threshold, active
|
|
self._redraw()
|
|
|
|
def _redraw(self):
|
|
self.delete("all")
|
|
w = self.winfo_width() or int(self["width"])
|
|
h = self.winfo_height() or int(self["height"])
|
|
pad = 3
|
|
seg_w = (w - 2 * pad) / self.SEGMENTS
|
|
filled = int(min(1.0, self._level / self.MAXIMUM) * self.SEGMENTS)
|
|
thr_seg = int(min(1.0, self._threshold / self.MAXIMUM) * self.SEGMENTS)
|
|
|
|
for i in range(self.SEGMENTS):
|
|
x0 = pad + i * seg_w
|
|
x1 = x0 + seg_w - 1.5
|
|
if i < filled:
|
|
colour = OLIVE_HI if self._active else OLIVE
|
|
if i >= thr_seg and not self._active:
|
|
colour = OLIVE_HI
|
|
else:
|
|
colour = "#252b1f"
|
|
self.create_rectangle(x0, pad, x1, h - pad, fill=colour, width=0)
|
|
|
|
# Schwellenmarke
|
|
x = pad + thr_seg * seg_w
|
|
self.create_line(x, 0, x, h, fill=AMBER, width=2)
|
|
|
|
|
|
def set_dark_titlebar(root):
|
|
"""
|
|
Faerbt die Fenstertitelleiste dunkel.
|
|
|
|
Windows zeichnet die Titelleiste sonst hell, was ueber der dunklen
|
|
Oberflaeche wie ein weisser Balken wirkt. Das Attribut heisst auf
|
|
aktuellen Windows-Versionen 20, auf aelteren 19.
|
|
"""
|
|
try:
|
|
root.update_idletasks()
|
|
hwnd = user32.GetParent(root.winfo_id()) or root.winfo_id()
|
|
dwm = ctypes.WinDLL("dwmapi")
|
|
an = ctypes.c_int(1)
|
|
for attribut in (20, 19):
|
|
if dwm.DwmSetWindowAttribute(
|
|
wintypes.HWND(hwnd), ctypes.c_uint(attribut),
|
|
ctypes.byref(an), ctypes.sizeof(an)) == 0:
|
|
# Neu zeichnen erzwingen, sonst bleibt die alte Farbe stehen
|
|
root.withdraw()
|
|
root.deiconify()
|
|
return True
|
|
except Exception:
|
|
pass
|
|
return False
|
|
|
|
|
|
def set_window_icon(root):
|
|
"""
|
|
Setzt das Programmsymbol fuer Fenster und Taskleiste.
|
|
|
|
Verwendet icon.ico neben dem Programm. Fehlt sie, bleibt das
|
|
Standardsymbol - ein fehlendes Symbol ist kein Grund abzubrechen.
|
|
"""
|
|
ordner = Path(__file__).resolve().parent
|
|
ico = ordner / "icon.ico"
|
|
if ico.exists():
|
|
try:
|
|
root.iconbitmap(default=str(ico))
|
|
return True
|
|
except Exception:
|
|
pass
|
|
png = ordner / "icon.png"
|
|
if png.exists():
|
|
try:
|
|
bild = tk.PhotoImage(file=str(png))
|
|
root.iconphoto(True, bild)
|
|
root._icon_ref = bild # Verweis halten, sonst weggeraeumt
|
|
return True
|
|
except Exception:
|
|
pass
|
|
return False
|
|
|
|
|
|
def clean_device_name(name):
|
|
"""
|
|
Macht Windows-Geraetenamen lesbar.
|
|
|
|
Manche Treiber liefern einen unaufgeloesten Ressourcenverweis wie
|
|
"@System32\\drivers\\bthhfenum.sys,#4;%1 Hands-Free HF Audio%0 ;(iPhone)".
|
|
Daraus wird "Hands-Free HF Audio (iPhone)".
|
|
"""
|
|
name = name.replace("\r", " ").replace("\n", " ")
|
|
if name.lstrip().startswith("@") or ".sys," in name or ".dll," in name:
|
|
pieces = []
|
|
for piece in name.split(";")[1:]:
|
|
piece = piece.strip()
|
|
if piece.startswith("%1"):
|
|
piece = piece[2:].strip()
|
|
if piece.endswith("%0"):
|
|
piece = piece[:-2].strip()
|
|
piece = piece.strip(" ()")
|
|
if piece:
|
|
pieces.append(piece)
|
|
if pieces:
|
|
name = f"{pieces[0]} ({', '.join(pieces[1:])})" if len(pieces) > 1 else pieces[0]
|
|
return " ".join(name.split())
|
|
|
|
|
|
API_RANG = {"WASAPI": 0, "DirectSound": 1, "MME": 2, "WDM-KS": 3}
|
|
|
|
# Platzhalter fuer "Windows-Standardgeraet" - kein echtes Mikrofon
|
|
ALIAS_GERAETE = ("microsoft soundmapper", "primärer soundaufnahmetreiber",
|
|
"primarer soundaufnahmetreiber", "primary sound capture")
|
|
|
|
|
|
def _vergleichsname(name):
|
|
return "".join(z for z in name.lower() if z.isalnum())
|
|
|
|
|
|
def gleiches_geraet(a, b):
|
|
"""
|
|
Zwei Eintraege gehoeren zum selben Mikrofon.
|
|
|
|
Die MME-Schnittstelle kuerzt Geraetenamen auf 31 Zeichen, deshalb wird
|
|
geprueft, ob der kuerzere Name Anfang des laengeren ist.
|
|
"""
|
|
x, y = _vergleichsname(a), _vergleichsname(b)
|
|
if x == y:
|
|
return True
|
|
kurz, lang = (x, y) if len(x) <= len(y) else (y, x)
|
|
return len(kurz) >= 8 and lang.startswith(kurz)
|
|
|
|
|
|
def zusammenfassen(geraete):
|
|
"""Pro Mikrofon nur den Eintrag mit der besten Schnittstelle behalten."""
|
|
gruppen = []
|
|
for geraet in sorted(geraete, key=lambda g: len(_vergleichsname(g["name"]))):
|
|
for gruppe in gruppen:
|
|
if gleiches_geraet(gruppe[0]["name"], geraet["name"]):
|
|
gruppe.append(geraet)
|
|
break
|
|
else:
|
|
gruppen.append([geraet])
|
|
return [min(g, key=lambda d: API_RANG.get(d["api"], 9)) for g in gruppen]
|
|
|
|
|
|
def enumerate_inputs(rescan=False, alle=False):
|
|
"""
|
|
Alle Eingabegeraete mit Host-API und nativer Abtastrate.
|
|
|
|
Die Geraeteindizes von PortAudio sind nicht stabil - sie verschieben
|
|
sich, sobald ein Treiber dazukommt oder verschwindet. Deshalb wird
|
|
ueberall mit dem Label gearbeitet und der Index erst unmittelbar vor
|
|
dem Oeffnen aufgeloest.
|
|
"""
|
|
if rescan:
|
|
try:
|
|
sd._terminate()
|
|
sd._initialize()
|
|
except Exception:
|
|
pass
|
|
apis = sd.query_hostapis()
|
|
result = []
|
|
for index, dev in enumerate(sd.query_devices()):
|
|
if dev["max_input_channels"] < 1:
|
|
continue
|
|
api = apis[dev["hostapi"]]["name"].replace("Windows ", "")
|
|
name = clean_device_name(dev["name"])
|
|
result.append({
|
|
"index": index,
|
|
"name": name,
|
|
"api": api,
|
|
"samplerate": int(dev["default_samplerate"]),
|
|
"label": f"[{api}] {name}",
|
|
})
|
|
|
|
if alle:
|
|
return result
|
|
|
|
gefiltert = [d for d in result
|
|
if not any(a in d["name"].lower() for a in ALIAS_GERAETE)]
|
|
|
|
# WDM-KS ist der Kernel-Zugang. Dort taucht zusaetzlich zu jedem echten
|
|
# Mikrofon ein Eintrag unter abweichendem Treibernamen auf, dazu Geraete,
|
|
# die in Windows gar nicht aktiv sind. Sobald WASAPI etwas liefert, ist
|
|
# das die massgebliche Liste - sie entspricht den Windows-Soundeinstellungen.
|
|
ohne_kernel = [d for d in gefiltert if d["api"] != "WDM-KS"]
|
|
if any(d["api"] == "WASAPI" for d in ohne_kernel):
|
|
gefiltert = ohne_kernel
|
|
|
|
return zusammenfassen(gefiltert or result)
|
|
|
|
|
|
def pick_samplerate(index, preferred):
|
|
"""Erste Abtastrate, die das Geraet tatsaechlich akzeptiert."""
|
|
seen = []
|
|
for rate in (preferred, 48000, 44100, 16000):
|
|
if rate in seen:
|
|
continue
|
|
seen.append(rate)
|
|
try:
|
|
sd.check_input_settings(device=index, channels=1,
|
|
samplerate=rate, dtype="float32")
|
|
return rate
|
|
except Exception:
|
|
continue
|
|
return None
|
|
|
|
|
|
def audio_service_running():
|
|
"""
|
|
Laeuft der Windows-Audiodienst? Stuerzt er ab, scheitert jede Aufnahme.
|
|
Nur lesender Zugriff auf den Dienststatus.
|
|
"""
|
|
SC_MANAGER_CONNECT, SERVICE_QUERY_STATUS, SERVICE_RUNNING = 0x0001, 0x0004, 0x0004
|
|
advapi = ctypes.WinDLL("advapi32", use_last_error=True)
|
|
|
|
class SERVICE_STATUS(ctypes.Structure):
|
|
_fields_ = [("dwServiceType", wintypes.DWORD),
|
|
("dwCurrentState", wintypes.DWORD),
|
|
("dwControlsAccepted", wintypes.DWORD),
|
|
("dwWin32ExitCode", wintypes.DWORD),
|
|
("dwServiceSpecificExitCode", wintypes.DWORD),
|
|
("dwCheckPoint", wintypes.DWORD),
|
|
("dwWaitHint", wintypes.DWORD)]
|
|
|
|
manager = advapi.OpenSCManagerW(None, None, SC_MANAGER_CONNECT)
|
|
if not manager:
|
|
return True # Status nicht ermittelbar - nicht faelschlich warnen
|
|
try:
|
|
service = advapi.OpenServiceW(manager, "Audiosrv", SERVICE_QUERY_STATUS)
|
|
if not service:
|
|
return True
|
|
try:
|
|
status = SERVICE_STATUS()
|
|
if not advapi.QueryServiceStatus(service, ctypes.byref(status)):
|
|
return True
|
|
return status.dwCurrentState == SERVICE_RUNNING
|
|
finally:
|
|
advapi.CloseServiceHandle(service)
|
|
finally:
|
|
advapi.CloseServiceHandle(manager)
|
|
|
|
|
|
def beep(enabled):
|
|
"""Kurze Rueckmeldung zum Hotkey - im Vollbild ist das Fenster nicht sichtbar."""
|
|
def run():
|
|
try:
|
|
import winsound
|
|
winsound.Beep(880 if enabled else 440, 90)
|
|
except Exception:
|
|
pass
|
|
threading.Thread(target=run, daemon=True).start()
|
|
|
|
|
|
def cursor_is_visible():
|
|
"""
|
|
True, wenn Windows gerade einen Mauszeiger zeichnet.
|
|
|
|
Squad blendet den Zeiger im Spiel aus und im Deploy-/Menuebildschirm ein.
|
|
Damit laesst sich der Respawn-Screen erkennen, ohne das Spiel anzufassen.
|
|
"""
|
|
info = CURSORINFO()
|
|
info.cbSize = ctypes.sizeof(CURSORINFO)
|
|
if not user32.GetCursorInfo(ctypes.byref(info)):
|
|
return True
|
|
return bool(info.flags & CURSOR_SHOWING)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Anwendung
|
|
# ---------------------------------------------------------------------------
|
|
class VoiceActivationApp:
|
|
POLL_SECONDS = 0.02
|
|
|
|
def __init__(self, root):
|
|
self.root = root
|
|
self.root.title(f"{APP_NAME} {VERSION}")
|
|
self.root.geometry("700x780")
|
|
self.root.minsize(660, 480)
|
|
set_window_icon(self.root)
|
|
set_dark_titlebar(self.root)
|
|
|
|
self.audio_queue = queue.Queue(maxsize=10)
|
|
self.running = False
|
|
self.stream = None
|
|
self.ptt_down = False
|
|
self.active_binding = None
|
|
self.last_voice_time = 0.0
|
|
self.current_level = 0.0
|
|
self.hold_reason = ""
|
|
self.hotkey_was_down = False
|
|
|
|
self.device_var = tk.StringVar()
|
|
self.threshold_var = tk.DoubleVar(value=0.025)
|
|
self.release_ms_var = tk.IntVar(value=450)
|
|
self.ptt_key_var = tk.StringVar(value="V")
|
|
self.ptt_mod_var = tk.StringVar(value=NO_MOD_LABEL)
|
|
self.radio1_var = tk.StringVar(value="B")
|
|
self.radio1_mod_var = tk.StringVar(value=NO_MOD_LABEL)
|
|
self.radio2_var = tk.StringVar(value="G")
|
|
self.radio2_mod_var = tk.StringVar(value=NO_MOD_LABEL)
|
|
self.radio3_var = tk.StringVar(value=NONE_LABEL)
|
|
self.radio3_mod_var = tk.StringVar(value=NO_MOD_LABEL)
|
|
self.hotkey_var = tk.StringVar(value="Pause")
|
|
self.squad_process_var = tk.StringVar(value=SQUAD_PROCESS_DEFAULT)
|
|
self.squad_only_var = tk.BooleanVar(value=True)
|
|
self.pause_on_cursor_var = tk.BooleanVar(value=False)
|
|
self.beep_var = tk.BooleanVar(value=True)
|
|
self.alle_geraete_var = tk.BooleanVar(value=False)
|
|
self.enabled_var = tk.BooleanVar(value=True)
|
|
self.status_var = tk.StringVar(value="Gestoppt")
|
|
self.detail_var = tk.StringVar(value="")
|
|
self.device_info_var = tk.StringVar(value="")
|
|
self.diag_var = tk.StringVar(value="")
|
|
self.inputs = []
|
|
self.worker = None
|
|
self.update_angaben = None
|
|
|
|
self.build_ui()
|
|
self.refresh_devices()
|
|
self.load_config()
|
|
self.arm_autosave()
|
|
self.root.protocol("WM_DELETE_WINDOW", self.on_close)
|
|
self.root.report_callback_exception = self.on_tk_error
|
|
self.root.after(80, self.ui_tick)
|
|
self.root.after(1500, self.suche_update)
|
|
|
|
def on_tk_error(self, exc_type, exc, tb):
|
|
"""Fehler aus Tk-Callbacks sichtbar machen statt still verschlucken."""
|
|
log_exception(exc_type, exc, tb)
|
|
try:
|
|
messagebox.showerror(
|
|
APP_NAME,
|
|
f"Unerwarteter Fehler:\n\n{exc_type.__name__}: {exc}\n\n"
|
|
f"Einzelheiten stehen in:\n{LOG_PATH}")
|
|
except Exception:
|
|
pass
|
|
|
|
# -- UI -----------------------------------------------------------------
|
|
def build_ui(self):
|
|
header = ttk.Frame(self.root)
|
|
header.pack(fill="x", padx=18, pady=(16, 4))
|
|
ttk.Label(header, text="SQUAD MANAGER",
|
|
style="Title.TLabel").pack(anchor="w")
|
|
ttk.Label(header, style="Sub.TLabel",
|
|
text="Haelt die Sprechtaste, solange du redest.").pack(anchor="w")
|
|
ttk.Separator(self.root, orient="horizontal").pack(
|
|
fill="x", padx=18, pady=(10, 0))
|
|
|
|
# Die Leiste mit Starten/Stoppen wird VOR dem Notebook gepackt und am
|
|
# unteren Rand verankert. Sonst frisst das Notebook (expand=True) den
|
|
# Platz und die Knoepfe fallen aus dem Fenster.
|
|
self._build_statusbar()
|
|
self._build_update_banner()
|
|
|
|
nb = ttk.Notebook(self.root)
|
|
self.nb = nb
|
|
nb.pack(fill="both", expand=True, padx=16, pady=8)
|
|
tab_main = ttk.Frame(nb)
|
|
tab_keys = ttk.Frame(nb)
|
|
nb.add(tab_main, text=" Mikrofon ")
|
|
nb.add(tab_keys, text=" Tasten und Verhalten ")
|
|
|
|
self._build_main_tab(tab_main)
|
|
self._build_keys_tab(tab_keys)
|
|
|
|
def _build_main_tab(self, parent):
|
|
f = ttk.Frame(parent)
|
|
f.pack(fill="both", expand=True, padx=12, pady=12)
|
|
f.columnconfigure(1, weight=1)
|
|
|
|
ttk.Label(f, text="Mikrofon").grid(row=0, column=0, sticky="w", pady=8)
|
|
self.device_combo = ttk.Combobox(f, textvariable=self.device_var,
|
|
state="readonly", width=44)
|
|
self.device_combo.grid(row=0, column=1, sticky="ew", padx=8, pady=8)
|
|
ttk.Button(f, text="Neu laden",
|
|
command=lambda: self.refresh_devices(rescan=True)).grid(
|
|
row=0, column=2, pady=8)
|
|
|
|
ttk.Checkbutton(
|
|
f, variable=self.alle_geraete_var,
|
|
text="Jede Windows-Schnittstelle einzeln auflisten",
|
|
command=lambda: self.refresh_devices(rescan=False),
|
|
).grid(row=1, column=1, sticky="w", padx=8, pady=(0, 6))
|
|
|
|
ttk.Label(f, text="Schwelle").grid(row=2, column=0, sticky="w", pady=8)
|
|
ttk.Scale(f, from_=0.002, to=0.100, variable=self.threshold_var,
|
|
orient="horizontal").grid(row=2, column=1, sticky="ew", padx=8, pady=8)
|
|
self.threshold_label = ttk.Label(f, text="0.025", width=8)
|
|
self.threshold_label.grid(row=2, column=2, sticky="w", pady=8)
|
|
|
|
ttk.Label(f, text="Pegel").grid(row=3, column=0, sticky="w", pady=8)
|
|
self.level_bar = LevelMeter(f)
|
|
self.level_bar.grid(row=3, column=1, sticky="ew", padx=8, pady=8)
|
|
self.level_label = ttk.Label(f, text="0.000", width=8, style="Mono.TLabel")
|
|
self.level_label.grid(row=3, column=2, sticky="w", pady=8)
|
|
|
|
ttk.Label(f, text="Nachlaufzeit").grid(row=4, column=0, sticky="w", pady=8)
|
|
row3 = ttk.Frame(f)
|
|
row3.grid(row=4, column=1, sticky="w", padx=8, pady=8)
|
|
ttk.Spinbox(row3, from_=100, to=2000, increment=50,
|
|
textvariable=self.release_ms_var, width=8).pack(side="left")
|
|
ttk.Label(row3, text="ms nach dem letzten Wort").pack(side="left", padx=8)
|
|
|
|
diag = ttk.LabelFrame(f, text="Warum sendet es (nicht)?")
|
|
diag.grid(row=5, column=0, columnspan=3, sticky="ew", pady=(16, 8))
|
|
ttk.Label(diag, textvariable=self.diag_var, justify="left",
|
|
font=("Consolas", 9)).pack(anchor="w", padx=10, pady=8)
|
|
ttk.Label(diag, textvariable=self.device_info_var,
|
|
foreground="#666").pack(anchor="w", padx=10, pady=(0, 8))
|
|
|
|
box = ttk.LabelFrame(f, text="Eingabetest")
|
|
box.grid(row=6, column=0, columnspan=3, sticky="ew", pady=(8, 8))
|
|
ttk.Button(box, text="PTT-Taste testen (1 Sekunde halten)",
|
|
command=self.test_ptt).pack(side="left", padx=10, pady=10)
|
|
self.test_result = ttk.Label(box, text="Vor dem Start von Squad ausprobieren.")
|
|
self.test_result.pack(side="left", padx=10, pady=10)
|
|
|
|
ttk.Label(f, justify="left", text=(
|
|
"Notepad oeffnen, hineinklicken, zurueck zu diesem Fenster wechseln\n"
|
|
"und den Test starten. Erscheint die Taste in Notepad, funktioniert\n"
|
|
"die Eingabesimulation. Laeuft Squad als Administrator, muss auch\n"
|
|
"dieses Programm als Administrator laufen.")
|
|
).grid(row=7, column=0, columnspan=3, sticky="w", pady=(4, 0))
|
|
|
|
def _build_keys_tab(self, parent):
|
|
f = ttk.Frame(parent)
|
|
f.pack(fill="both", expand=True, padx=12, pady=12)
|
|
f.columnconfigure(2, weight=1)
|
|
|
|
ttk.Label(f, text="Sprechtaste (wird automatisch gehalten)").grid(
|
|
row=0, column=0, sticky="w", pady=8)
|
|
ptt_row = ttk.Frame(f)
|
|
ptt_row.grid(row=0, column=1, columnspan=2, sticky="w", padx=8, pady=8)
|
|
ttk.Combobox(ptt_row, textvariable=self.ptt_mod_var, values=MOD_NAMES,
|
|
state="readonly", width=8).pack(side="left")
|
|
ttk.Label(ptt_row, text="+").pack(side="left", padx=6)
|
|
ttk.Combobox(ptt_row, textvariable=self.ptt_key_var, values=KEY_NAMES,
|
|
state="readonly", width=12).pack(side="left")
|
|
ttk.Label(ptt_row, text=" z. B. Local V oder Fireteam-Kanal",
|
|
foreground="#666").pack(side="left", padx=6)
|
|
|
|
box = ttk.LabelFrame(
|
|
f, text="Andere Sprechtasten - Automatik pausiert, solange eine gehalten wird")
|
|
box.grid(row=1, column=0, columnspan=3, sticky="ew", pady=(16, 8))
|
|
for i, (label, mod_var, key_var, hint) in enumerate([
|
|
("Squad Radio", self.radio1_mod_var, self.radio1_var, "meist B"),
|
|
("Command Radio", self.radio2_mod_var, self.radio2_var, "meist G"),
|
|
("Weitere Taste", self.radio3_mod_var, self.radio3_var, "optional"),
|
|
]):
|
|
ttk.Label(box, text=label).grid(row=i, column=0, sticky="w", padx=10, pady=6)
|
|
ttk.Combobox(box, textvariable=mod_var, values=MOD_NAMES,
|
|
state="readonly", width=8).grid(row=i, column=1, padx=(10, 2), pady=6)
|
|
ttk.Label(box, text="+").grid(row=i, column=2)
|
|
ttk.Combobox(box, textvariable=key_var, values=[NONE_LABEL] + KEY_NAMES,
|
|
state="readonly", width=12).grid(row=i, column=3, padx=(2, 10), pady=6)
|
|
ttk.Label(box, text=hint, foreground="#666").grid(row=i, column=4,
|
|
sticky="w", padx=6)
|
|
|
|
ttk.Label(f, justify="left", text=(
|
|
"Drueckst du selbst eine dieser Tasten, laesst das Programm die\n"
|
|
"Local-Taste sofort los und haelt sich raus, bis du sie wieder\n"
|
|
"loslaesst. Dein Funkspruch wird dadurch nicht mehr ueberschrieben.")
|
|
).grid(row=2, column=0, columnspan=3, sticky="w", pady=(0, 12))
|
|
|
|
box2 = ttk.LabelFrame(f, text="Verhalten")
|
|
box2.grid(row=3, column=0, columnspan=3, sticky="ew", pady=8)
|
|
|
|
ttk.Checkbutton(
|
|
box2, variable=self.squad_only_var,
|
|
text="Alles nur aktiv, solange dieses Programm im Vordergrund ist:",
|
|
).pack(anchor="w", padx=10, pady=(8, 2))
|
|
|
|
proc_row = ttk.Frame(box2)
|
|
proc_row.pack(anchor="w", padx=32, pady=(0, 4))
|
|
ttk.Entry(proc_row, textvariable=self.squad_process_var, width=22).pack(side="left")
|
|
self.proc_hint = ttk.Label(proc_row, foreground="#666", text="")
|
|
self.proc_hint.pack(side="left", padx=10)
|
|
|
|
ttk.Checkbutton(
|
|
box2, variable=self.pause_on_cursor_var,
|
|
text="Pausieren, solange ein Mauszeiger sichtbar ist (Deploy-Screen, Menue, Karte)",
|
|
).pack(anchor="w", padx=10, pady=4)
|
|
|
|
self.cursor_hint = ttk.Label(box2, foreground="#666", text="")
|
|
self.cursor_hint.pack(anchor="w", padx=32, pady=(0, 8))
|
|
|
|
row = ttk.Frame(box2)
|
|
row.pack(anchor="w", padx=10, pady=(4, 2))
|
|
ttk.Label(row, text="Stummschalt-Hotkey (nur im Spiel)").pack(side="left")
|
|
ttk.Combobox(row, textvariable=self.hotkey_var, values=[NONE_LABEL] + KEY_NAMES,
|
|
state="readonly", width=14).pack(side="left", padx=10)
|
|
|
|
ttk.Checkbutton(
|
|
box2, variable=self.beep_var,
|
|
text="Signalton beim Umschalten (hoch = aktiv, tief = stumm)",
|
|
).pack(anchor="w", padx=32, pady=(0, 10))
|
|
|
|
ttk.Label(f, text="Alle Aenderungen werden sofort gespeichert.",
|
|
style="Dim.TLabel").grid(row=4, column=0, columnspan=2,
|
|
sticky="w", pady=(16, 0))
|
|
self.save_hint = ttk.Label(f, style="Dim.TLabel", text="")
|
|
self.save_hint.grid(row=5, column=0, columnspan=3, sticky="w", pady=(2, 0))
|
|
|
|
def _build_update_banner(self):
|
|
"""Hinweisleiste auf eine neue Fassung. Bleibt verborgen, bis es eine gibt."""
|
|
self.update_banner = tk.Frame(self.root, bg=AMBER_DUNKEL,
|
|
highlightthickness=1,
|
|
highlightbackground=AMBER)
|
|
innen = tk.Frame(self.update_banner, bg=AMBER_DUNKEL)
|
|
innen.pack(fill="x", padx=14, pady=9)
|
|
|
|
self.update_text_var = tk.StringVar(value="")
|
|
tk.Label(innen, textvariable=self.update_text_var, bg=AMBER_DUNKEL,
|
|
fg=AMBER, font=FONT_BOLD, anchor="w",
|
|
justify="left").pack(side="left", fill="x", expand=True)
|
|
|
|
tk.Button(innen, text="Später", command=self.update_verbergen,
|
|
bg=AMBER_DUNKEL, fg=FG_DIM, activebackground=PANEL_HI,
|
|
activeforeground=FG, relief="flat", bd=0, padx=12, pady=4,
|
|
font=FONT_UI, cursor="hand2").pack(side="right", padx=(8, 0))
|
|
|
|
self.update_btn = tk.Button(
|
|
innen, text="Jetzt aktualisieren", command=self.update_starten,
|
|
bg=AMBER, fg="#1a1508", activebackground=AMBER_HELL,
|
|
activeforeground="#1a1508", relief="flat", bd=0, padx=16, pady=4,
|
|
font=FONT_BOLD, cursor="hand2")
|
|
self.update_btn.pack(side="right")
|
|
|
|
def _build_statusbar(self):
|
|
self.status_trenner = ttk.Separator(self.root, orient="horizontal")
|
|
self.status_trenner.pack(side="bottom", fill="x", padx=0, pady=(0, 0))
|
|
bar = ttk.Frame(self.root)
|
|
bar.pack(side="bottom", fill="x", padx=16, pady=12)
|
|
|
|
self.start_btn = ttk.Button(bar, text="STARTEN", style="Accent.TButton",
|
|
command=self.start)
|
|
self.start_btn.pack(side="left")
|
|
self.stop_btn = ttk.Button(bar, text="STOPPEN", command=self.stop,
|
|
state="disabled")
|
|
self.stop_btn.pack(side="left", padx=8)
|
|
|
|
right = ttk.Frame(bar)
|
|
right.pack(side="right")
|
|
ttk.Label(right, textvariable=self.detail_var,
|
|
style="Dim.TLabel").pack(side="left", padx=10)
|
|
self.status_label = ttk.Label(right, textvariable=self.status_var,
|
|
font=FONT_STATUS, foreground=FG_DIM)
|
|
self.status_label.pack(side="left")
|
|
|
|
# -- Konfiguration ------------------------------------------------------
|
|
def config_dict(self):
|
|
return {
|
|
"device": self.device_var.get(),
|
|
"threshold": round(float(self.threshold_var.get()), 4),
|
|
"release_ms": int(self.release_ms_var.get()),
|
|
"ptt_key": self.ptt_key_var.get(),
|
|
"ptt_mod": self.ptt_mod_var.get(),
|
|
"radio_keys": [self.radio1_var.get(), self.radio2_var.get(),
|
|
self.radio3_var.get()],
|
|
"radio_mods": [self.radio1_mod_var.get(), self.radio2_mod_var.get(),
|
|
self.radio3_mod_var.get()],
|
|
"hotkey": self.hotkey_var.get(),
|
|
"squad_process": self.squad_process_var.get(),
|
|
"squad_only": bool(self.squad_only_var.get()),
|
|
"pause_on_cursor": bool(self.pause_on_cursor_var.get()),
|
|
"beep": bool(self.beep_var.get()),
|
|
}
|
|
|
|
def suche_update(self):
|
|
"""Fragt im Hintergrund nach einer neueren Fassung."""
|
|
def arbeit():
|
|
angaben = pruefe_update()
|
|
if angaben:
|
|
self.root.after(0, lambda: self.update_anbieten(angaben))
|
|
threading.Thread(target=arbeit, daemon=True).start()
|
|
|
|
def update_anbieten(self, angaben):
|
|
self.update_angaben = angaben
|
|
text = f"Version {angaben['version']} ist verfügbar."
|
|
if angaben.get("hinweis"):
|
|
text += f" {angaben['hinweis']}"
|
|
self.update_text_var.set(text)
|
|
self.update_banner.pack(side="bottom", fill="x", padx=0, pady=0,
|
|
before=self.status_trenner)
|
|
|
|
def update_verbergen(self):
|
|
self.update_banner.pack_forget()
|
|
|
|
def update_starten(self):
|
|
if not getattr(self, "update_angaben", None):
|
|
return
|
|
self.update_btn.config(state="disabled", text="Lädt ...")
|
|
|
|
def arbeit():
|
|
import tempfile
|
|
try:
|
|
ziel = Path(tempfile.gettempdir()) / "SquadManager_Update.zip"
|
|
|
|
def melden(geladen, gesamt):
|
|
anteil = int(geladen * 100 / gesamt)
|
|
self.root.after(0, lambda: self.update_btn.config(
|
|
text=f"Lädt ... {anteil} %"))
|
|
|
|
lade_update(self.update_angaben, ziel, melden)
|
|
ordner = Path(__file__).resolve().parent
|
|
self.root.after(0, lambda: self.update_abschliessen(ziel, ordner))
|
|
except Exception as fehler:
|
|
log_exception(type(fehler), fehler, fehler.__traceback__)
|
|
self.root.after(0, lambda f=fehler: self.update_fehler(f))
|
|
|
|
threading.Thread(target=arbeit, daemon=True).start()
|
|
|
|
def update_fehler(self, fehler):
|
|
self.update_btn.config(state="normal", text="Jetzt aktualisieren")
|
|
messagebox.showerror(
|
|
APP_NAME,
|
|
f"Das Update konnte nicht geladen werden:\n\n{fehler}\n\n"
|
|
"Das Programm läuft unverändert weiter.")
|
|
|
|
def update_abschliessen(self, zip_pfad, ordner):
|
|
self.update_btn.config(text="Wird eingespielt ...")
|
|
try:
|
|
spiele_update_ein(zip_pfad, ordner)
|
|
except Exception as fehler:
|
|
log_exception(type(fehler), fehler, fehler.__traceback__)
|
|
self.update_fehler(fehler)
|
|
return
|
|
self.stop()
|
|
self.root.after(400, self.root.destroy)
|
|
|
|
def arm_autosave(self):
|
|
"""
|
|
Jede Aenderung wird gespeichert, nicht erst beim Schliessen.
|
|
|
|
Wird das Programm abgeschossen oder faellt der Rechner aus, waeren
|
|
sonst alle Einstellungen der Sitzung verloren. Geschrieben wird
|
|
verzoegert, damit das Ziehen am Schieberegler nicht hunderte
|
|
Schreibvorgaenge ausloest.
|
|
"""
|
|
for var in (self.device_var, self.threshold_var, self.release_ms_var,
|
|
self.ptt_key_var, self.ptt_mod_var,
|
|
self.radio1_var, self.radio1_mod_var,
|
|
self.radio2_var, self.radio2_mod_var,
|
|
self.radio3_var, self.radio3_mod_var,
|
|
self.hotkey_var, self.squad_process_var,
|
|
self.squad_only_var, self.pause_on_cursor_var,
|
|
self.beep_var):
|
|
var.trace_add("write", self._on_setting_changed)
|
|
self._autosave_job = None
|
|
|
|
def _on_setting_changed(self, *_):
|
|
if getattr(self, "_autosave_job", None) is not None:
|
|
try:
|
|
self.root.after_cancel(self._autosave_job)
|
|
except Exception:
|
|
pass
|
|
self._autosave_job = self.root.after(600, self._autosave_now)
|
|
|
|
def _autosave_now(self):
|
|
self._autosave_job = None
|
|
self.save_config(quiet=True)
|
|
|
|
def save_config(self, quiet=False):
|
|
try:
|
|
CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
|
|
CONFIG_PATH.write_text(json.dumps(self.config_dict(), indent=2),
|
|
encoding="utf-8")
|
|
self.save_hint.config(
|
|
text=f"Automatisch gespeichert {time.strftime('%H:%M:%S')}")
|
|
except Exception as e:
|
|
log_exception(type(e), e, e.__traceback__)
|
|
if not quiet:
|
|
messagebox.showerror(
|
|
APP_NAME, f"Einstellungen konnten nicht gespeichert werden:\n{e}")
|
|
else:
|
|
self.save_hint.config(text="Speichern fehlgeschlagen - siehe error.log")
|
|
|
|
def load_config(self):
|
|
alte_einstellungen_uebernehmen()
|
|
if not CONFIG_PATH.exists():
|
|
return
|
|
try:
|
|
cfg = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
|
|
except Exception:
|
|
return
|
|
|
|
# Toleranter Vergleich: Geraetenamen enthalten oft ueberzaehlige
|
|
# Leerzeichen, und die Namensbereinigung kann sie veraendert haben.
|
|
saved = " ".join((cfg.get("device") or "").split())
|
|
if saved:
|
|
match = next((label for label in self.device_combo["values"]
|
|
if " ".join(label.split()) == saved), None)
|
|
if match:
|
|
self.device_var.set(match)
|
|
|
|
try:
|
|
self.threshold_var.set(float(cfg.get("threshold", 0.025)))
|
|
self.release_ms_var.set(int(cfg.get("release_ms", 450)))
|
|
except Exception:
|
|
pass
|
|
self.squad_only_var.set(bool(cfg.get("squad_only", True)))
|
|
self.pause_on_cursor_var.set(bool(cfg.get("pause_on_cursor", False)))
|
|
self.beep_var.set(bool(cfg.get("beep", True)))
|
|
|
|
if cfg.get("ptt_key") in KEYS:
|
|
self.ptt_key_var.set(cfg["ptt_key"])
|
|
if cfg.get("ptt_mod") in MODIFIERS:
|
|
self.ptt_mod_var.set(cfg["ptt_mod"])
|
|
if cfg.get("hotkey") in KEYS or cfg.get("hotkey") == NONE_LABEL:
|
|
self.hotkey_var.set(cfg["hotkey"])
|
|
if cfg.get("squad_process"):
|
|
self.squad_process_var.set(cfg["squad_process"])
|
|
|
|
for var, value in zip((self.radio1_var, self.radio2_var, self.radio3_var),
|
|
cfg.get("radio_keys") or []):
|
|
if value in KEYS or value == NONE_LABEL:
|
|
var.set(value)
|
|
for var, value in zip((self.radio1_mod_var, self.radio2_mod_var,
|
|
self.radio3_mod_var), cfg.get("radio_mods") or []):
|
|
if value in MODIFIERS:
|
|
var.set(value)
|
|
|
|
self.save_hint.config(text="Einstellungen geladen.")
|
|
|
|
# -- Audio --------------------------------------------------------------
|
|
def refresh_devices(self, rescan=False):
|
|
try:
|
|
self.inputs = enumerate_inputs(rescan=rescan,
|
|
alle=bool(self.alle_geraete_var.get()))
|
|
except Exception as e:
|
|
messagebox.showerror(APP_NAME, f"Mikrofone konnten nicht gelesen werden:\n{e}")
|
|
return
|
|
|
|
labels = [d["label"] for d in self.inputs]
|
|
self.device_combo["values"] = labels
|
|
|
|
if self.device_var.get() not in labels:
|
|
# WASAPI zuerst - moderner und stabiler als MME/DirectSound
|
|
preferred = next((d["label"] for d in self.inputs if d["api"] == "WASAPI"),
|
|
labels[0] if labels else "")
|
|
self.device_var.set(preferred)
|
|
|
|
def selected_device(self):
|
|
"""Loest das gewaehlte Label frisch auf, weil Indizes wandern koennen."""
|
|
label = self.device_var.get()
|
|
if not label:
|
|
return None
|
|
for device in enumerate_inputs():
|
|
if device["label"] == label:
|
|
return device
|
|
return None
|
|
|
|
def audio_callback(self, indata, frames, time_info, status):
|
|
rms = float(np.sqrt(np.mean(np.square(indata.astype(np.float32)))))
|
|
self.current_level = rms
|
|
try:
|
|
self.audio_queue.put_nowait(rms)
|
|
except queue.Full:
|
|
try:
|
|
self.audio_queue.get_nowait()
|
|
self.audio_queue.put_nowait(rms)
|
|
except Exception:
|
|
pass
|
|
|
|
# -- PTT ----------------------------------------------------------------
|
|
def test_ptt(self):
|
|
if self.ptt_down:
|
|
return
|
|
key = self.ptt_key_var.get()
|
|
mod = self.ptt_mod_var.get()
|
|
if key not in KEYS:
|
|
messagebox.showwarning(APP_NAME, "Bitte eine gueltige Taste waehlen.")
|
|
return
|
|
|
|
label = key if MODIFIERS.get(mod) is None else f"{mod}+{key}"
|
|
self.test_result.config(text=f"Teste {label} ...")
|
|
|
|
def do_test():
|
|
try:
|
|
send_binding(mod, key, True)
|
|
time.sleep(1.0)
|
|
send_binding(mod, key, False)
|
|
self.root.after(0, lambda: self.test_result.config(
|
|
text=f"{label} wurde erfolgreich gesendet."))
|
|
except Exception as e:
|
|
self.root.after(0, lambda: messagebox.showerror(
|
|
APP_NAME, f"Test fehlgeschlagen:\n{e}"))
|
|
self.root.after(0, lambda: self.test_result.config(
|
|
text="Test fehlgeschlagen."))
|
|
|
|
threading.Thread(target=do_test, daemon=True).start()
|
|
|
|
def press_ptt(self):
|
|
if self.ptt_down:
|
|
return
|
|
key = self.ptt_key_var.get()
|
|
if key not in KEYS:
|
|
return
|
|
# Kombination merken, damit ein spaeteres Umstellen im UI die
|
|
# gehaltene Taste nicht haengen laesst.
|
|
self.active_binding = (self.ptt_mod_var.get(), key)
|
|
send_binding(*self.active_binding, True)
|
|
self.ptt_down = True
|
|
|
|
def release_ptt(self):
|
|
if not self.ptt_down:
|
|
return
|
|
try:
|
|
if self.active_binding:
|
|
send_binding(*self.active_binding, False)
|
|
finally:
|
|
self.active_binding = None
|
|
self.ptt_down = False
|
|
|
|
# -- Sperrgruende -------------------------------------------------------
|
|
def radio_bindings(self):
|
|
pairs = ((self.radio1_mod_var, self.radio1_var),
|
|
(self.radio2_mod_var, self.radio2_var),
|
|
(self.radio3_mod_var, self.radio3_var))
|
|
return [(m.get(), k.get()) for m, k in pairs if k.get() in KEYS]
|
|
|
|
def squad_focused(self):
|
|
"""Ist das Spiel gerade das aktive Fenster?"""
|
|
if not self.squad_only_var.get():
|
|
return True
|
|
wanted = self.squad_process_var.get().strip().lower()
|
|
if not wanted:
|
|
return True
|
|
return get_foreground_process_name().lower().startswith(wanted)
|
|
|
|
def blocking_reason(self):
|
|
"""Grund, warum gerade nicht gesendet werden darf. Leerer String = frei."""
|
|
if not self.squad_focused():
|
|
return "Squad nicht im Vordergrund"
|
|
|
|
if not self.enabled_var.get():
|
|
return "Pausiert (Hotkey)"
|
|
|
|
for mod, key in self.radio_bindings():
|
|
if is_binding_down(mod, key):
|
|
label = key if MODIFIERS.get(mod) is None else f"{mod}+{key}"
|
|
return f"Funk aktiv ({label})"
|
|
|
|
# Haelt der Spieler die Local-Taste selbst, mischen wir uns nicht ein.
|
|
if not self.ptt_down and is_binding_down(self.ptt_mod_var.get(),
|
|
self.ptt_key_var.get()):
|
|
return "Manuell gedrueckt"
|
|
|
|
if self.pause_on_cursor_var.get() and cursor_is_visible():
|
|
return "Menue / Deploy-Screen"
|
|
|
|
return ""
|
|
|
|
def poll_hotkey(self):
|
|
"""
|
|
Flankenerkennung fuer den Stummschalt-Hotkey.
|
|
|
|
Wird nur ausgewertet, solange das Spiel im Vordergrund ist. Sonst
|
|
wuerde dieselbe Taste auch beim Schreiben im Browser oder in Discord
|
|
die Automatik umschalten.
|
|
"""
|
|
key = self.hotkey_var.get()
|
|
if key not in KEYS or not self.squad_focused():
|
|
self.hotkey_was_down = False
|
|
return
|
|
down = is_physically_down(key)
|
|
if down and not self.hotkey_was_down:
|
|
now_enabled = not self.enabled_var.get()
|
|
self.enabled_var.set(now_enabled)
|
|
if not now_enabled:
|
|
self.release_ptt()
|
|
if self.beep_var.get():
|
|
beep(now_enabled)
|
|
self.hotkey_was_down = down
|
|
|
|
# -- Steuerung ----------------------------------------------------------
|
|
def start(self):
|
|
if self.running:
|
|
return
|
|
|
|
if not audio_service_running():
|
|
messagebox.showerror(
|
|
APP_NAME,
|
|
"Der Windows-Audiodienst laeuft nicht.\n\n"
|
|
"Ohne ihn kann kein Programm aufnehmen. In einer\n"
|
|
"Eingabeaufforderung als Administrator starten:\n\n"
|
|
" net start Audiosrv")
|
|
return
|
|
|
|
device = self.selected_device()
|
|
if device is None:
|
|
messagebox.showwarning(
|
|
APP_NAME,
|
|
"Das gewaehlte Mikrofon ist nicht mehr vorhanden.\n"
|
|
"Bitte auf 'Neu laden' klicken und erneut waehlen.")
|
|
return
|
|
|
|
rate = pick_samplerate(device["index"], device["samplerate"])
|
|
if rate is None:
|
|
messagebox.showerror(
|
|
APP_NAME,
|
|
f"{device['name']} akzeptiert keine der ueblichen Abtastraten.\n"
|
|
"Bitte ein anderes Geraet waehlen - moeglichst eines mit [WASAPI].")
|
|
return
|
|
|
|
try:
|
|
self.audio_queue = queue.Queue(maxsize=10)
|
|
self.running = True
|
|
self.enabled_var.set(True)
|
|
self.last_voice_time = 0.0
|
|
|
|
self.stream = sd.InputStream(
|
|
device=device["index"], channels=1, samplerate=rate,
|
|
blocksize=max(64, rate // 50), # rund 20 ms
|
|
dtype="float32", callback=self.audio_callback,
|
|
)
|
|
self.stream.start()
|
|
self.worker = threading.Thread(target=self.worker_loop, daemon=True)
|
|
self.worker.start()
|
|
|
|
self.start_btn.config(state="disabled")
|
|
self.stop_btn.config(state="normal")
|
|
self.device_combo.config(state="disabled")
|
|
self.device_info_var.set(f"{device['api']} @ {rate} Hz")
|
|
except Exception as e:
|
|
self.running = False
|
|
self.stream = None
|
|
log_exception(type(e), e, e.__traceback__)
|
|
messagebox.showerror(
|
|
APP_NAME,
|
|
f"Mikrofon konnte nicht geoeffnet werden:\n\n{e}\n\n"
|
|
"Haeufige Ursachen:\n"
|
|
"- Windows-Audiodienst abgestuerzt (net start Audiosrv)\n"
|
|
"- Geraet von einem anderen Programm exklusiv belegt\n"
|
|
"- Virtueller Treiber (z. B. SteelSeries Sonar) haengt\n\n"
|
|
"Ein Geraet mit [WASAPI] ist meist am stabilsten.")
|
|
|
|
def stop(self):
|
|
self.running = False
|
|
|
|
# Erst den Worker auslaufen lassen, sonst greift er noch auf den
|
|
# Stream zu, waehrend dieser geschlossen wird - das kann PortAudio
|
|
# hart abstuerzen lassen.
|
|
worker, self.worker = self.worker, None
|
|
if worker is not None and worker.is_alive():
|
|
worker.join(timeout=1.0)
|
|
|
|
try:
|
|
self.release_ptt()
|
|
except Exception as e:
|
|
log_exception(type(e), e, e.__traceback__)
|
|
self.ptt_down = False
|
|
self.active_binding = None
|
|
|
|
stream, self.stream = self.stream, None
|
|
if stream is not None:
|
|
try:
|
|
stream.abort(ignore_errors=True)
|
|
except Exception:
|
|
pass
|
|
try:
|
|
stream.close(ignore_errors=True)
|
|
except Exception as e:
|
|
log_exception(type(e), e, e.__traceback__)
|
|
self.current_level = 0.0
|
|
self.hold_reason = ""
|
|
self.start_btn.config(state="normal")
|
|
self.stop_btn.config(state="disabled")
|
|
self.device_combo.config(state="readonly")
|
|
|
|
def worker_loop(self):
|
|
while self.running:
|
|
try:
|
|
rms = self.audio_queue.get(timeout=self.POLL_SECONDS)
|
|
except queue.Empty:
|
|
rms = 0.0
|
|
|
|
now = time.monotonic()
|
|
try:
|
|
threshold = float(self.threshold_var.get())
|
|
release_delay = max(0.05, int(self.release_ms_var.get()) / 1000.0)
|
|
except Exception:
|
|
threshold, release_delay = 0.025, 0.45
|
|
|
|
try:
|
|
self.poll_hotkey()
|
|
reason = self.blocking_reason()
|
|
self.hold_reason = reason
|
|
|
|
if reason:
|
|
self.release_ptt()
|
|
elif rms >= threshold:
|
|
self.last_voice_time = now
|
|
self.press_ptt()
|
|
elif self.ptt_down and now - self.last_voice_time >= release_delay:
|
|
self.release_ptt()
|
|
except Exception as e:
|
|
self.running = False
|
|
self.root.after(0, lambda err=e: messagebox.showerror(
|
|
APP_NAME,
|
|
f"Tastatureingabe fehlgeschlagen:\n{err}\n\n"
|
|
"Zuerst den PTT-Test ausserhalb von Squad probieren.\n"
|
|
"Laeuft Squad als Administrator, muss auch dieses "
|
|
"Programm als Administrator laufen."))
|
|
break
|
|
|
|
try:
|
|
self.release_ptt()
|
|
except Exception:
|
|
pass
|
|
|
|
# -- Anzeige ------------------------------------------------------------
|
|
def ui_tick(self):
|
|
try:
|
|
val = float(self.current_level)
|
|
self.level_bar.update_values(val, float(self.threshold_var.get()),
|
|
self.ptt_down)
|
|
self.level_label.config(text=f"{val:.3f}")
|
|
self.threshold_label.config(text=f"{self.threshold_var.get():.3f}")
|
|
|
|
self.cursor_hint.config(
|
|
text="Mauszeiger gerade sichtbar" if cursor_is_visible()
|
|
else "Mauszeiger gerade ausgeblendet")
|
|
self.proc_hint.config(
|
|
text=f"gerade im Vordergrund: {get_foreground_process_name() or '?'}")
|
|
|
|
threshold = float(self.threshold_var.get())
|
|
if not self.running:
|
|
self.status_var.set("● BEREITSCHAFT")
|
|
self.status_label.config(foreground=FG_DIM)
|
|
self.detail_var.set("")
|
|
self.diag_var.set("Nicht gestartet - unten auf STARTEN klicken.")
|
|
else:
|
|
laut = "ueber Schwelle" if val >= threshold else "ZU LEISE"
|
|
zeilen = [f"Pegel {val:.4f} / Schwelle {threshold:.4f} -> {laut}"]
|
|
if self.ptt_down:
|
|
self.status_var.set("● SENDET")
|
|
self.status_label.config(foreground=GREEN_TX)
|
|
self.detail_var.set("")
|
|
zeilen.append("Taste wird gehalten.")
|
|
elif self.hold_reason:
|
|
self.status_var.set("● GESPERRT")
|
|
self.status_label.config(foreground=RED)
|
|
self.detail_var.set(self.hold_reason)
|
|
zeilen.append(f"Blockiert: {self.hold_reason}")
|
|
if self.hold_reason == "Squad nicht im Vordergrund":
|
|
zeilen.append(" -> Squad anklicken, oder den Haken im")
|
|
zeilen.append(" Reiter 'Tasten und Verhalten' entfernen.")
|
|
else:
|
|
self.status_var.set("● HORCHT")
|
|
self.status_label.config(foreground=AMBER)
|
|
self.detail_var.set("")
|
|
zeilen.append("Nichts blockiert - es fehlt nur lautes Sprechen.")
|
|
self.diag_var.set("\n".join(zeilen))
|
|
except Exception:
|
|
pass
|
|
self.root.after(80, self.ui_tick)
|
|
|
|
def on_close(self):
|
|
try:
|
|
self.save_config()
|
|
except Exception:
|
|
pass
|
|
self.stop()
|
|
self.root.destroy()
|
|
|
|
|
|
def main():
|
|
root = tk.Tk()
|
|
try:
|
|
apply_tactical_theme(root)
|
|
except Exception as e:
|
|
log_exception(type(e), e, e.__traceback__)
|
|
VoiceActivationApp(root)
|
|
root.mainloop()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|