Die angezeigte Version springt von 4.0 auf 1.5.0 zurueck. Damit Updates weiter ankommen, vergleicht das Programm jetzt eine Zaehlnummer BUILD statt der Anzeige. version.json fuehrt "anzeige" und "build" und fuer Programme bis 4.0 dauerhaft "version": "4.1". Getestet mit dem echten pruefe_update() aus 3.2, 3.3 und 4.0. Der Release-Bau warnt, wenn BUILD nicht hoeher ist als auf dem Server. Die Downloadseite zeigt "anzeige". Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
1559 lines
60 KiB
Python
1559 lines
60 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
|
|
|
|
from theme import ( # noqa: E402
|
|
BG, PANEL, PANEL_HI, LINE, FG, FG_DIM, OLIVE, OLIVE_HI, AMBER,
|
|
AMBER_HELL, AMBER_DUNKEL, RED, GREEN_TX,
|
|
FONT_UI, FONT_BOLD, FONT_TITLE, FONT_MONO, FONT_STATUS,
|
|
apply_tactical_theme, LevelMeter,
|
|
)
|
|
import akte # noqa: E402
|
|
import update_helfer # noqa: E402
|
|
|
|
APP_NAME = "Squad Manager"
|
|
VERSION = "1.5.0"
|
|
# Zaehlnummer fuer den Update-Vergleich, bei jedem Release um eins erhoehen.
|
|
# Seit 1.5.0 getrennt von der angezeigten Version: Die Anzeige sprang von
|
|
# 4.0 auf 1.5.0 zurueck, ein Vergleich der Anzeige haette danach nie wieder
|
|
# ein Update gefunden.
|
|
BUILD = 1
|
|
# Letzte Version aus der Zeit vor den Zaehlnummern
|
|
LETZTE_ALTE_VERSION = "4.0"
|
|
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
|
|
|
|
# "anzeige" und "build" gibt es seit 1.5.0. "version" bleibt fuer die
|
|
# Programme bis 4.0 stehen, die nur dieses Feld kennen.
|
|
ziel = str(angaben.get("anzeige") or angaben.get("version", "")).strip()
|
|
datei = str(angaben.get("datei", "")).strip()
|
|
if not ziel or not datei.lower().startswith("https://"):
|
|
return None
|
|
if "build" in angaben:
|
|
try:
|
|
neuer = int(angaben["build"]) > BUILD
|
|
except (TypeError, ValueError):
|
|
return None
|
|
else:
|
|
neuer = version_tupel(ziel) > version_tupel(LETZTE_ALTE_VERSION)
|
|
if not neuer:
|
|
return None
|
|
installer = str(angaben.get("installer", "")).strip()
|
|
return {
|
|
"version": ziel,
|
|
"datei": datei,
|
|
"sha256": str(angaben.get("sha256", "")).strip().lower(),
|
|
"hinweis": str(angaben.get("hinweis", "")).strip()[:200],
|
|
"installer": installer if installer.lower().startswith("https://") else "",
|
|
}
|
|
|
|
|
|
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, installer_url=""):
|
|
"""
|
|
Entpackt das Paket und startet den Update-Helfer.
|
|
|
|
Das laufende Programm ersetzt seine Dateien nicht selbst. Das erledigt
|
|
update_helfer.py als eigener Prozess, sobald das Programm beendet ist,
|
|
und startet es danach neu. Bevorzugt wird der Helfer aus dem *neuen*
|
|
Paket: Eine Verbesserung am Helfer wirkt so schon bei dem Update, das
|
|
sie ausliefert. Seine Aufrufparameter sind deshalb eine Schnittstelle
|
|
und muessen zwischen den Versionen gleich bleiben.
|
|
"""
|
|
import shutil
|
|
import subprocess
|
|
import tempfile
|
|
import zipfile
|
|
|
|
arbeit = Path(tempfile.mkdtemp(prefix="sm_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
|
|
|
|
kandidaten = (quelle / "update_helfer.py",
|
|
Path(__file__).resolve().parent / "update_helfer.py")
|
|
helfer = next((p for p in kandidaten if p.is_file()), None)
|
|
if helfer is None:
|
|
raise ValueError("Der Update-Helfer fehlt.")
|
|
# Ausserhalb von quelle, damit er beim Kopieren nicht mitten im Lauf liegt
|
|
ausfuehren = arbeit / "update_helfer.py"
|
|
shutil.copy2(helfer, ausfuehren)
|
|
|
|
subprocess.Popen([sys.executable, str(ausfuehren), str(quelle),
|
|
str(programm_ordner), str(os.getpid()), installer_url],
|
|
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)
|
|
|
|
|
|
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("900x830")
|
|
self.root.minsize(780, 520)
|
|
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="Sprachaktivierung und Personalakte fuer Squad.").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()
|
|
|
|
# Hauptreiter je Modul. Die Statusleiste bleibt darunter fuer alle
|
|
# Module sichtbar - die Sprachaktivierung laeuft weiter, waehrend man
|
|
# zum Beispiel an einer Akte schreibt.
|
|
haupt = ttk.Notebook(self.root, style="Haupt.TNotebook")
|
|
self.haupt_nb = haupt
|
|
haupt.pack(fill="both", expand=True, padx=16, pady=(4, 8))
|
|
seite_funk = ttk.Frame(haupt)
|
|
seite_akte = ttk.Frame(haupt)
|
|
haupt.add(seite_funk, text="FUNK")
|
|
haupt.add(seite_akte, text="AKTE")
|
|
|
|
nb = ttk.Notebook(seite_funk)
|
|
self.nb = nb
|
|
nb.pack(fill="both", expand=True, pady=(6, 0))
|
|
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)
|
|
|
|
self.akte = akte.AkteSeite(seite_akte)
|
|
self.akte.pack(fill="both", expand=True)
|
|
|
|
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()),
|
|
"modul": self.haupt_nb.index("current"),
|
|
}
|
|
|
|
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
|
|
ordner = Path(__file__).resolve().parent
|
|
# Liegt das Programm unter C:\Program Files, darf es dort ohne
|
|
# Adminrechte nichts ersetzen. Bis 3.4 scheiterte das Update dann
|
|
# still und startete die alte Fassung neu.
|
|
if not update_helfer.beschreibbar(ordner) and not messagebox.askokcancel(
|
|
APP_NAME,
|
|
"Squad Manager liegt in einem geschuetzten Ordner:\n"
|
|
f"{ordner}\n\n"
|
|
"Zum Einspielen fragt Windows gleich nach Administratorrechten. "
|
|
"Das Programm selbst laeuft danach wieder mit normalen Rechten.\n\n"
|
|
"Dauerhaft beheben laesst sich das mit dem aktuellen Installer: "
|
|
"Er installiert in deinen Benutzerordner.",
|
|
icon="warning"):
|
|
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)
|
|
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,
|
|
self.update_angaben.get("installer", ""))
|
|
except Exception as fehler:
|
|
log_exception(type(fehler), fehler, fehler.__traceback__)
|
|
self.update_fehler(fehler)
|
|
return
|
|
try:
|
|
self.akte.speichern_sofort()
|
|
except Exception as e:
|
|
log_exception(type(e), e, e.__traceback__)
|
|
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
|
|
self.haupt_nb.bind("<<NotebookTabChanged>>", self._on_setting_changed,
|
|
add="+")
|
|
|
|
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)
|
|
|
|
modul = cfg.get("modul")
|
|
if isinstance(modul, int) and 0 <= modul < len(self.haupt_nb.tabs()):
|
|
self.haupt_nb.select(modul)
|
|
|
|
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.akte.speichern_sofort()
|
|
except Exception as e:
|
|
log_exception(type(e), e, e.__traceback__)
|
|
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()
|