1843 lines
71 KiB
Python
1843 lines
71 KiB
Python
|
"""
|
|||
|
|
Surovy's Music Recorder – Records music from Spotify, Apple Music,
|
|||
|
|
Tidal, Amazon Music, Deezer, YouTube Music, TuneIn, SoundCloud, or
|
|||
|
|
any system audio source. Desktop apps are embedded directly.
|
|||
|
|
Each song is saved as a numbered MP3 in a playlist folder.
|
|||
|
|
"""
|
|||
|
|
|
|||
|
|
import customtkinter as ctk
|
|||
|
|
import tkinter as tk
|
|||
|
|
from tkinter import filedialog
|
|||
|
|
import ctypes
|
|||
|
|
from ctypes import wintypes
|
|||
|
|
import psutil
|
|||
|
|
import subprocess
|
|||
|
|
import threading
|
|||
|
|
import time
|
|||
|
|
import os
|
|||
|
|
import sys
|
|||
|
|
import traceback
|
|||
|
|
import datetime
|
|||
|
|
import re
|
|||
|
|
from PIL import Image
|
|||
|
|
import mutagen
|
|||
|
|
from audio import AudioRecorder
|
|||
|
|
|
|||
|
|
# ── Win32 constants ────────────────────────────────────────────
|
|||
|
|
user32 = ctypes.windll.user32
|
|||
|
|
kernel32 = ctypes.windll.kernel32
|
|||
|
|
GWL_STYLE = -16
|
|||
|
|
WS_CHILD = 0x40000000
|
|||
|
|
WS_CAPTION = 0x00C00000
|
|||
|
|
WS_THICKFRAME = 0x00040000
|
|||
|
|
WS_POPUP = 0x80000000
|
|||
|
|
SWP_FRAMECHANGED = 0x0020
|
|||
|
|
SWP_NOMOVE = 0x0002
|
|||
|
|
SWP_NOSIZE = 0x0001
|
|||
|
|
SWP_NOZORDER = 0x0004
|
|||
|
|
|
|||
|
|
ES_CONTINUOUS = 0x80000000
|
|||
|
|
ES_SYSTEM_REQUIRED = 0x00000001
|
|||
|
|
ES_AWAYMODE_REQUIRED = 0x00000040
|
|||
|
|
|
|||
|
|
# ── Colors ─────────────────────────────────────────────────────
|
|||
|
|
BG = "#0b0b0b"
|
|||
|
|
CARD = "#151515"
|
|||
|
|
BORDER = "#1e1e1e"
|
|||
|
|
GREEN = "#7C9A3C"
|
|||
|
|
GREEN_H = "#90AE4A"
|
|||
|
|
RED = "#e74c3c"
|
|||
|
|
RED_H = "#ff6b6b"
|
|||
|
|
ORANGE = "#f59e0b"
|
|||
|
|
TXT = "#ffffff"
|
|||
|
|
TXT2 = "#b3b3b3"
|
|||
|
|
DIM = "#555555"
|
|||
|
|
|
|||
|
|
PANEL_W = 330
|
|||
|
|
|
|||
|
|
FILENAME_FORMATS = [
|
|||
|
|
("{nr} - {artist} - {titel}", "Nr - Artist - Titel"),
|
|||
|
|
("{nr} - {titel} - {artist}", "Nr - Titel - Artist"),
|
|||
|
|
("{nr} - {titel}", "Nr - Titel"),
|
|||
|
|
("{artist} - {titel}", "Artist - Titel"),
|
|||
|
|
("{titel} - {artist}", "Titel - Artist"),
|
|||
|
|
("{titel}", "Nur Titel"),
|
|||
|
|
]
|
|||
|
|
FILENAME_LABELS = [label for _, label in FILENAME_FORMATS]
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ═══════════════════════════════════════════════════════════════
|
|||
|
|
# Platform definitions
|
|||
|
|
# ═══════════════════════════════════════════════════════════════
|
|||
|
|
|
|||
|
|
PLATFORMS = {
|
|||
|
|
"Spotify": {
|
|||
|
|
"process": "spotify.exe",
|
|||
|
|
"sep": " - ",
|
|||
|
|
"pause": {"spotify", "spotify premium", "spotify free"},
|
|||
|
|
"launch_dirs": [
|
|||
|
|
("{APPDATA}", "Spotify", "Spotify.exe"),
|
|||
|
|
("{LOCALAPPDATA}", "Microsoft", "WindowsApps", "Spotify.exe"),
|
|||
|
|
],
|
|||
|
|
"cmd": "spotify",
|
|||
|
|
},
|
|||
|
|
"Apple Music": {
|
|||
|
|
"process": "AppleMusic.exe",
|
|||
|
|
"sep": " \u2014 ",
|
|||
|
|
"pause": {"apple music", "itunes", "apple music preview"},
|
|||
|
|
"launch_dirs": [
|
|||
|
|
("{LOCALAPPDATA}", "Microsoft", "WindowsApps",
|
|||
|
|
"AppleMusic.exe"),
|
|||
|
|
],
|
|||
|
|
"cmd": None,
|
|||
|
|
},
|
|||
|
|
"Amazon Music": {
|
|||
|
|
"process": "Amazon Music.exe",
|
|||
|
|
"sep": " - ",
|
|||
|
|
"pause": {"amazon music"},
|
|||
|
|
"launch_dirs": [
|
|||
|
|
("{LOCALAPPDATA}", "Amazon Music", "Amazon Music.exe"),
|
|||
|
|
],
|
|||
|
|
"cmd": None,
|
|||
|
|
},
|
|||
|
|
"Tidal": {
|
|||
|
|
"process": "TIDAL.exe",
|
|||
|
|
"sep": " - ",
|
|||
|
|
"pause": {"tidal"},
|
|||
|
|
"launch_dirs": [
|
|||
|
|
("{LOCALAPPDATA}", "TIDAL", "TIDAL.exe"),
|
|||
|
|
],
|
|||
|
|
"cmd": None,
|
|||
|
|
},
|
|||
|
|
"Deezer": {
|
|||
|
|
"process": "Deezer.exe",
|
|||
|
|
"sep": " - ",
|
|||
|
|
"pause": {"deezer"},
|
|||
|
|
"launch_dirs": [
|
|||
|
|
("{LOCALAPPDATA}", "Deezer", "Deezer.exe"),
|
|||
|
|
],
|
|||
|
|
"cmd": None,
|
|||
|
|
},
|
|||
|
|
"YouTube Music": {
|
|||
|
|
"process": None, "sep": None, "pause": set(),
|
|||
|
|
"launch_dirs": [], "cmd": None,
|
|||
|
|
},
|
|||
|
|
"TuneIn / Radio": {
|
|||
|
|
"process": None, "sep": None, "pause": set(),
|
|||
|
|
"launch_dirs": [], "cmd": None,
|
|||
|
|
},
|
|||
|
|
"SoundCloud": {
|
|||
|
|
"process": None, "sep": None, "pause": set(),
|
|||
|
|
"launch_dirs": [], "cmd": None,
|
|||
|
|
},
|
|||
|
|
"System Audio": {
|
|||
|
|
"process": None, "sep": None, "pause": set(),
|
|||
|
|
"launch_dirs": [], "cmd": None,
|
|||
|
|
},
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
PLATFORM_NAMES = list(PLATFORMS.keys())
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ═══════════════════════════════════════════════════════════════
|
|||
|
|
# Window helper functions (platform-generic)
|
|||
|
|
# ═══════════════════════════════════════════════════════════════
|
|||
|
|
|
|||
|
|
def get_app_pids(process_name):
|
|||
|
|
pids = set()
|
|||
|
|
if not process_name:
|
|||
|
|
return pids
|
|||
|
|
target = process_name.lower()
|
|||
|
|
for proc in psutil.process_iter(["pid", "name"]):
|
|||
|
|
try:
|
|||
|
|
if (proc.info["name"] or "").lower() == target:
|
|||
|
|
pids.add(proc.info["pid"])
|
|||
|
|
except (psutil.NoSuchProcess, psutil.AccessDenied):
|
|||
|
|
pass
|
|||
|
|
return pids
|
|||
|
|
|
|||
|
|
|
|||
|
|
def find_app_window(process_name):
|
|||
|
|
pids = get_app_pids(process_name)
|
|||
|
|
if not pids:
|
|||
|
|
return None
|
|||
|
|
best = [None]
|
|||
|
|
best_area = [0]
|
|||
|
|
|
|||
|
|
@ctypes.WINFUNCTYPE(wintypes.BOOL, wintypes.HWND, wintypes.LPARAM)
|
|||
|
|
def cb(hwnd, _lp):
|
|||
|
|
if user32.IsWindowVisible(hwnd):
|
|||
|
|
pid = wintypes.DWORD()
|
|||
|
|
user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
|
|||
|
|
if pid.value in pids:
|
|||
|
|
rect = wintypes.RECT()
|
|||
|
|
user32.GetWindowRect(hwnd, ctypes.byref(rect))
|
|||
|
|
w = rect.right - rect.left
|
|||
|
|
h = rect.bottom - rect.top
|
|||
|
|
area = w * h
|
|||
|
|
if area > best_area[0] and w > 300 and h > 200:
|
|||
|
|
best_area[0] = area
|
|||
|
|
best[0] = hwnd
|
|||
|
|
return True
|
|||
|
|
|
|||
|
|
user32.EnumWindows(cb, 0)
|
|||
|
|
return best[0]
|
|||
|
|
|
|||
|
|
|
|||
|
|
def get_window_title(hwnd):
|
|||
|
|
length = user32.GetWindowTextLengthW(hwnd)
|
|||
|
|
if length > 0:
|
|||
|
|
buf = ctypes.create_unicode_buffer(length + 1)
|
|||
|
|
user32.GetWindowTextW(hwnd, buf, length + 1)
|
|||
|
|
return buf.value
|
|||
|
|
return ""
|
|||
|
|
|
|||
|
|
|
|||
|
|
def launch_app(platform_cfg):
|
|||
|
|
env_map = {
|
|||
|
|
"{APPDATA}": os.getenv("APPDATA", ""),
|
|||
|
|
"{LOCALAPPDATA}": os.getenv("LOCALAPPDATA", ""),
|
|||
|
|
"{PROGRAMFILES}": os.getenv("PROGRAMFILES", ""),
|
|||
|
|
}
|
|||
|
|
for parts in platform_cfg.get("launch_dirs", []):
|
|||
|
|
resolved = []
|
|||
|
|
for p in parts:
|
|||
|
|
resolved.append(env_map.get(p, p))
|
|||
|
|
path = os.path.join(*resolved)
|
|||
|
|
if os.path.exists(path):
|
|||
|
|
subprocess.Popen([path])
|
|||
|
|
return True
|
|||
|
|
cmd = platform_cfg.get("cmd")
|
|||
|
|
if cmd:
|
|||
|
|
try:
|
|||
|
|
subprocess.Popen([cmd])
|
|||
|
|
return True
|
|||
|
|
except FileNotFoundError:
|
|||
|
|
pass
|
|||
|
|
return False
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ═══════════════════════════════════════════════════════════════
|
|||
|
|
# Main application
|
|||
|
|
# ═══════════════════════════════════════════════════════════════
|
|||
|
|
|
|||
|
|
class SpotifyRecorderApp:
|
|||
|
|
|
|||
|
|
def __init__(self):
|
|||
|
|
try:
|
|||
|
|
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
|
|||
|
|
"surovy.music.recorder")
|
|||
|
|
except Exception:
|
|||
|
|
pass
|
|||
|
|
try:
|
|||
|
|
ctypes.windll.shcore.SetProcessDpiAwareness(1)
|
|||
|
|
except Exception:
|
|||
|
|
pass
|
|||
|
|
|
|||
|
|
ctk.set_appearance_mode("dark")
|
|||
|
|
ctk.set_default_color_theme("green")
|
|||
|
|
|
|||
|
|
self.root = ctk.CTk()
|
|||
|
|
self.root.title("Surovy's Music Recorder")
|
|||
|
|
self.root.configure(fg_color=BG)
|
|||
|
|
|
|||
|
|
ico = os.path.join(os.path.dirname(os.path.abspath(__file__)),
|
|||
|
|
"app.ico")
|
|||
|
|
if os.path.exists(ico):
|
|||
|
|
self.root.iconbitmap(ico)
|
|||
|
|
self.root.after(200, lambda: self.root.iconbitmap(ico))
|
|||
|
|
self.root.protocol("WM_DELETE_WINDOW", self._on_close)
|
|||
|
|
|
|||
|
|
self._app_initialized = False
|
|||
|
|
self._show_selector()
|
|||
|
|
|
|||
|
|
# ── platform selector ─────────────────────────────────────
|
|||
|
|
|
|||
|
|
_PLATFORM_ICONS = {
|
|||
|
|
"Spotify": "\u266a",
|
|||
|
|
"Apple Music": "\u266a",
|
|||
|
|
"Amazon Music": "\u266a",
|
|||
|
|
"Tidal": "\u266a",
|
|||
|
|
"Deezer": "\u266a",
|
|||
|
|
"YouTube Music": "\u25b6",
|
|||
|
|
"TuneIn / Radio": "\U0001f4fb",
|
|||
|
|
"SoundCloud": "\u2601",
|
|||
|
|
"System Audio": "\U0001f50a",
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
def _show_selector(self):
|
|||
|
|
self.root.geometry("680x530")
|
|||
|
|
self.root.minsize(680, 530)
|
|||
|
|
self.root.resizable(False, False)
|
|||
|
|
|
|||
|
|
self._sel = ctk.CTkFrame(self.root, fg_color=BG)
|
|||
|
|
self._sel.pack(fill="both", expand=True)
|
|||
|
|
|
|||
|
|
hdr = ctk.CTkFrame(self._sel, fg_color="transparent")
|
|||
|
|
hdr.pack(pady=(38, 0))
|
|||
|
|
|
|||
|
|
logo_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
|
|||
|
|
"logo.png")
|
|||
|
|
if os.path.exists(logo_path):
|
|||
|
|
sel_logo = ctk.CTkImage(
|
|||
|
|
light_image=Image.open(logo_path),
|
|||
|
|
dark_image=Image.open(logo_path),
|
|||
|
|
size=(64, 64))
|
|||
|
|
ctk.CTkLabel(hdr, image=sel_logo, text="").pack()
|
|||
|
|
else:
|
|||
|
|
icon_box = ctk.CTkFrame(hdr, width=54, height=54, fg_color=GREEN,
|
|||
|
|
corner_radius=15)
|
|||
|
|
icon_box.pack()
|
|||
|
|
icon_box.pack_propagate(False)
|
|||
|
|
ctk.CTkLabel(icon_box, text="\u266a",
|
|||
|
|
font=ctk.CTkFont(size=24, weight="bold"),
|
|||
|
|
text_color="white").pack(expand=True)
|
|||
|
|
|
|||
|
|
ctk.CTkLabel(hdr, text="Surovy's Music Recorder",
|
|||
|
|
font=ctk.CTkFont(size=22, weight="bold"),
|
|||
|
|
text_color=TXT).pack(pady=(14, 4))
|
|||
|
|
ctk.CTkLabel(hdr, text="Dienst auswaehlen",
|
|||
|
|
font=ctk.CTkFont(size=13), text_color=TXT2).pack()
|
|||
|
|
|
|||
|
|
grid = ctk.CTkFrame(self._sel, fg_color="transparent")
|
|||
|
|
grid.pack(pady=(28, 0))
|
|||
|
|
|
|||
|
|
for i, name in enumerate(PLATFORM_NAMES):
|
|||
|
|
row, col = divmod(i, 3)
|
|||
|
|
ic = self._PLATFORM_ICONS.get(name, "\u266a")
|
|||
|
|
btn = ctk.CTkButton(
|
|||
|
|
grid, text=f"{ic} {name}",
|
|||
|
|
width=195, height=64, corner_radius=14,
|
|||
|
|
font=ctk.CTkFont(size=13, weight="bold"),
|
|||
|
|
fg_color=CARD, hover_color="#252525",
|
|||
|
|
border_width=1, border_color=BORDER,
|
|||
|
|
text_color=TXT,
|
|||
|
|
command=lambda n=name: self._on_platform_selected(n),
|
|||
|
|
)
|
|||
|
|
btn.grid(row=row, column=col, padx=8, pady=8)
|
|||
|
|
|
|||
|
|
ctk.CTkLabel(self._sel,
|
|||
|
|
text="Du kannst den Dienst spaeter jederzeit wechseln.",
|
|||
|
|
font=ctk.CTkFont(size=10), text_color=DIM
|
|||
|
|
).pack(pady=(22, 0))
|
|||
|
|
|
|||
|
|
def _on_platform_selected(self, name):
|
|||
|
|
cfg = PLATFORMS[name]
|
|||
|
|
proc = cfg.get("process")
|
|||
|
|
if proc and not get_app_pids(proc):
|
|||
|
|
launch_app(cfg)
|
|||
|
|
|
|||
|
|
self._sel.destroy()
|
|||
|
|
self.root.resizable(True, True)
|
|||
|
|
self.root.geometry("1400x880")
|
|||
|
|
self.root.minsize(1000, 620)
|
|||
|
|
|
|||
|
|
self.platform_name = name
|
|||
|
|
self.platform_cfg = cfg
|
|||
|
|
self.recorder = AudioRecorder()
|
|||
|
|
self.spotify_hwnd = None
|
|||
|
|
self.original_style = None
|
|||
|
|
self.original_parent = None
|
|||
|
|
self.active = False
|
|||
|
|
self.is_playing = False
|
|||
|
|
self.playlist_name = ""
|
|||
|
|
self.session_dir = ""
|
|||
|
|
self.track_number = 0
|
|||
|
|
self.current_track = None
|
|||
|
|
self.songs = []
|
|||
|
|
self.recorded_songs = set()
|
|||
|
|
self.rec_start = None
|
|||
|
|
self.last_title = ""
|
|||
|
|
self.output_base = os.path.join(
|
|||
|
|
os.path.expanduser("~"), "Music", "SpotifyRecordings"
|
|||
|
|
)
|
|||
|
|
os.makedirs(self.output_base, exist_ok=True)
|
|||
|
|
self.bitrate = 320
|
|||
|
|
self.auto_stop_secs = 60
|
|||
|
|
self.pause_since = None
|
|||
|
|
self._pulse_on = True
|
|||
|
|
self._alive_fails = 0
|
|||
|
|
self.ad_playing = False
|
|||
|
|
self._auto_record_ready = False
|
|||
|
|
self.playlist_total = 0
|
|||
|
|
self._user_stopped = False
|
|||
|
|
self._restart_after_id = None
|
|||
|
|
self._restart_fails = 0
|
|||
|
|
self._lock = threading.Lock()
|
|||
|
|
self._silence_start = None
|
|||
|
|
self._silence_threshold = 0.012
|
|||
|
|
self._min_silence_secs = 2.0
|
|||
|
|
self._folder_mode = "auto"
|
|||
|
|
self._custom_folder = ""
|
|||
|
|
self._detecting = False
|
|||
|
|
self._last_suggestion = ""
|
|||
|
|
self._fn_format = FILENAME_FORMATS[0][0]
|
|||
|
|
|
|||
|
|
self._app_initialized = True
|
|||
|
|
|
|||
|
|
self._build_controls()
|
|||
|
|
self._build_embed_area()
|
|||
|
|
|
|||
|
|
threading.Thread(target=self._attach_app, daemon=True).start()
|
|||
|
|
self._tick_monitor()
|
|||
|
|
self._tick_timer()
|
|||
|
|
self._tick_level()
|
|||
|
|
self._tick_pulse()
|
|||
|
|
self._tick_alive()
|
|||
|
|
self._tick_suggest()
|
|||
|
|
|
|||
|
|
# ── build left panel ───────────────────────────────────────
|
|||
|
|
|
|||
|
|
def _build_controls(self):
|
|||
|
|
panel = ctk.CTkFrame(self.root, width=PANEL_W, fg_color=CARD,
|
|||
|
|
corner_radius=0, border_width=0)
|
|||
|
|
panel.pack(side="left", fill="y")
|
|||
|
|
panel.pack_propagate(False)
|
|||
|
|
|
|||
|
|
pad = {"padx": 20}
|
|||
|
|
|
|||
|
|
# header
|
|||
|
|
hdr = ctk.CTkFrame(panel, fg_color="transparent")
|
|||
|
|
hdr.pack(fill="x", **pad, pady=(22, 0))
|
|||
|
|
logo_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
|
|||
|
|
"logo.png")
|
|||
|
|
if os.path.exists(logo_path):
|
|||
|
|
logo_img = ctk.CTkImage(
|
|||
|
|
light_image=Image.open(logo_path),
|
|||
|
|
dark_image=Image.open(logo_path),
|
|||
|
|
size=(42, 42))
|
|||
|
|
ctk.CTkLabel(hdr, image=logo_img, text="").pack(side="left")
|
|||
|
|
else:
|
|||
|
|
icon = ctk.CTkFrame(hdr, width=42, height=42, fg_color=GREEN,
|
|||
|
|
corner_radius=12)
|
|||
|
|
icon.pack(side="left")
|
|||
|
|
icon.pack_propagate(False)
|
|||
|
|
ctk.CTkLabel(icon, text="\u266a",
|
|||
|
|
font=ctk.CTkFont(size=20, weight="bold"),
|
|||
|
|
text_color="white").pack(expand=True)
|
|||
|
|
hcol = ctk.CTkFrame(hdr, fg_color="transparent")
|
|||
|
|
hcol.pack(side="left", padx=10)
|
|||
|
|
ctk.CTkLabel(hcol, text="Surovy's",
|
|||
|
|
font=ctk.CTkFont(size=10), text_color=TXT).pack(anchor="w")
|
|||
|
|
ctk.CTkLabel(hcol, text="Music Recorder",
|
|||
|
|
font=ctk.CTkFont(size=16, weight="bold"),
|
|||
|
|
text_color=TXT).pack(anchor="w")
|
|||
|
|
|
|||
|
|
# platform selector
|
|||
|
|
src_row = ctk.CTkFrame(panel, fg_color="transparent")
|
|||
|
|
src_row.pack(fill="x", **pad, pady=(14, 0))
|
|||
|
|
ctk.CTkLabel(src_row, text="QUELLE",
|
|||
|
|
font=ctk.CTkFont(size=9, weight="bold"),
|
|||
|
|
text_color=DIM).pack(side="left")
|
|||
|
|
self.platform_var = ctk.StringVar(value=self.platform_name)
|
|||
|
|
ctk.CTkOptionMenu(
|
|||
|
|
src_row, values=PLATFORM_NAMES,
|
|||
|
|
variable=self.platform_var, width=170, height=28,
|
|||
|
|
font=ctk.CTkFont(size=11),
|
|||
|
|
fg_color="#2a2a2a", button_color="#333",
|
|||
|
|
button_hover_color="#444",
|
|||
|
|
command=self._change_platform
|
|||
|
|
).pack(side="right")
|
|||
|
|
|
|||
|
|
# connection status
|
|||
|
|
self.sp_label = ctk.CTkLabel(
|
|||
|
|
panel, text="\u25cf Spotify wird gesucht\u2026",
|
|||
|
|
font=ctk.CTkFont(size=11), text_color=DIM)
|
|||
|
|
self.sp_label.pack(**pad, pady=(8, 0), anchor="w")
|
|||
|
|
|
|||
|
|
# separator
|
|||
|
|
ctk.CTkFrame(panel, height=1, fg_color=BORDER).pack(fill="x", **pad, pady=10)
|
|||
|
|
|
|||
|
|
# playlist input
|
|||
|
|
ctk.CTkLabel(panel, text="ORDNER / PLAYLIST",
|
|||
|
|
font=ctk.CTkFont(size=9, weight="bold"),
|
|||
|
|
text_color=DIM).pack(**pad, anchor="w")
|
|||
|
|
self.pl_entry = ctk.CTkEntry(
|
|||
|
|
panel, placeholder_text="Optional - wird auto-generiert",
|
|||
|
|
font=ctk.CTkFont(size=13), height=38, corner_radius=10,
|
|||
|
|
fg_color="#1a1a1a", border_color=BORDER)
|
|||
|
|
self.pl_entry.pack(fill="x", **pad, pady=(6, 0))
|
|||
|
|
self.pl_hint_lbl = ctk.CTkLabel(
|
|||
|
|
panel, text="Leer lassen = automatisch (Datum/Uhrzeit)",
|
|||
|
|
font=ctk.CTkFont(size=9), text_color="#444")
|
|||
|
|
self.pl_hint_lbl.pack(**pad, anchor="w", pady=(2, 0))
|
|||
|
|
|
|||
|
|
self.top_folder_lbl = ctk.CTkLabel(
|
|||
|
|
panel, text=self.output_base,
|
|||
|
|
font=ctk.CTkFont(size=11), text_color=GREEN,
|
|||
|
|
wraplength=PANEL_W - 50, anchor="w")
|
|||
|
|
self.top_folder_lbl.pack(**pad, anchor="w", pady=(4, 0))
|
|||
|
|
|
|||
|
|
ar_chk_row = ctk.CTkFrame(panel, fg_color="transparent")
|
|||
|
|
ar_chk_row.pack(fill="x", **pad, pady=(8, 0))
|
|||
|
|
self.auto_rec_var = ctk.BooleanVar(value=True)
|
|||
|
|
self.auto_rec_chk = ctk.CTkCheckBox(
|
|||
|
|
ar_chk_row, text="Auto-Aufnahme bei Play",
|
|||
|
|
variable=self.auto_rec_var,
|
|||
|
|
font=ctk.CTkFont(size=12), text_color=TXT2,
|
|||
|
|
fg_color="#333", hover_color="#444",
|
|||
|
|
checkmark_color="white", border_color=BORDER,
|
|||
|
|
corner_radius=4)
|
|||
|
|
self.auto_rec_chk.pack(side="left")
|
|||
|
|
|
|||
|
|
# track card
|
|||
|
|
tcard = ctk.CTkFrame(panel, fg_color="#111111", corner_radius=14,
|
|||
|
|
border_width=1, border_color=BORDER)
|
|||
|
|
tcard.pack(fill="x", **pad, pady=(14, 0))
|
|||
|
|
|
|||
|
|
srow = ctk.CTkFrame(tcard, fg_color="transparent")
|
|||
|
|
srow.pack(fill="x", padx=14, pady=(12, 0))
|
|||
|
|
self.dot_lbl = ctk.CTkLabel(srow, text="\u25cf", width=14,
|
|||
|
|
font=ctk.CTkFont(size=10), text_color=DIM)
|
|||
|
|
self.dot_lbl.pack(side="left")
|
|||
|
|
self.stat_lbl = ctk.CTkLabel(srow, text="BEREIT",
|
|||
|
|
font=ctk.CTkFont(size=10, weight="bold"),
|
|||
|
|
text_color=DIM)
|
|||
|
|
self.stat_lbl.pack(side="left", padx=(5, 0))
|
|||
|
|
self.time_lbl = ctk.CTkLabel(srow, text="",
|
|||
|
|
font=ctk.CTkFont(size=12, weight="bold"),
|
|||
|
|
text_color=DIM)
|
|||
|
|
self.time_lbl.pack(side="right")
|
|||
|
|
|
|||
|
|
ctk.CTkFrame(tcard, height=1, fg_color=BORDER).pack(fill="x", padx=14, pady=8)
|
|||
|
|
|
|||
|
|
self.tnum_lbl = ctk.CTkLabel(tcard, text="",
|
|||
|
|
font=ctk.CTkFont(size=10, weight="bold"),
|
|||
|
|
text_color=GREEN)
|
|||
|
|
self.tnum_lbl.pack(padx=14, anchor="w")
|
|||
|
|
self.artist_lbl = ctk.CTkLabel(tcard, text="\u2014",
|
|||
|
|
font=ctk.CTkFont(size=15, weight="bold"),
|
|||
|
|
text_color=TXT)
|
|||
|
|
self.artist_lbl.pack(padx=14, anchor="w")
|
|||
|
|
self.title_lbl = ctk.CTkLabel(tcard, text="",
|
|||
|
|
font=ctk.CTkFont(size=12), text_color=TXT2)
|
|||
|
|
self.title_lbl.pack(padx=14, anchor="w", pady=(1, 0))
|
|||
|
|
|
|||
|
|
lvl_row = ctk.CTkFrame(tcard, fg_color="transparent")
|
|||
|
|
lvl_row.pack(fill="x", padx=14, pady=(12, 14))
|
|||
|
|
ctk.CTkLabel(lvl_row, text="PEGEL",
|
|||
|
|
font=ctk.CTkFont(size=8, weight="bold"),
|
|||
|
|
text_color="#444").pack(side="left", padx=(0, 8))
|
|||
|
|
self.level_bar = ctk.CTkProgressBar(
|
|||
|
|
lvl_row, height=5, corner_radius=3,
|
|||
|
|
fg_color="#222", progress_color=GREEN)
|
|||
|
|
self.level_bar.pack(side="left", fill="x", expand=True)
|
|||
|
|
self.level_bar.set(0)
|
|||
|
|
|
|||
|
|
# record button
|
|||
|
|
self.rec_btn = ctk.CTkButton(
|
|||
|
|
panel, text="\u23fa AUFNAHME STARTEN",
|
|||
|
|
font=ctk.CTkFont(size=14, weight="bold"), height=48,
|
|||
|
|
corner_radius=24, fg_color=GREEN, hover_color=GREEN_H,
|
|||
|
|
command=self._toggle)
|
|||
|
|
self.rec_btn.pack(fill="x", **pad, pady=(14, 0))
|
|||
|
|
|
|||
|
|
# song list
|
|||
|
|
ctk.CTkFrame(panel, height=1, fg_color=BORDER).pack(fill="x", **pad, pady=12)
|
|||
|
|
sl_hdr = ctk.CTkFrame(panel, fg_color="transparent")
|
|||
|
|
sl_hdr.pack(fill="x", **pad)
|
|||
|
|
ctk.CTkLabel(sl_hdr, text="AUFGENOMMEN",
|
|||
|
|
font=ctk.CTkFont(size=9, weight="bold"),
|
|||
|
|
text_color=DIM).pack(side="left")
|
|||
|
|
self.cnt_lbl = ctk.CTkLabel(sl_hdr, text="0 Songs",
|
|||
|
|
font=ctk.CTkFont(size=9, weight="bold"),
|
|||
|
|
text_color=DIM)
|
|||
|
|
self.cnt_lbl.pack(side="right")
|
|||
|
|
|
|||
|
|
self.song_box = ctk.CTkTextbox(
|
|||
|
|
panel, font=ctk.CTkFont(size=11), fg_color=CARD,
|
|||
|
|
text_color=TXT2, border_width=0, corner_radius=0,
|
|||
|
|
state="disabled", height=120, activate_scrollbars=True)
|
|||
|
|
self.song_box.pack(fill="both", expand=True, **pad, pady=(6, 0))
|
|||
|
|
|
|||
|
|
# settings gear button + total stats
|
|||
|
|
ctk.CTkFrame(panel, height=1, fg_color=BORDER).pack(fill="x", **pad, pady=(10, 0))
|
|||
|
|
|
|||
|
|
bottom_row = ctk.CTkFrame(panel, fg_color="transparent")
|
|||
|
|
bottom_row.pack(fill="x", **pad, pady=(6, 0))
|
|||
|
|
self.total_lbl = ctk.CTkLabel(
|
|||
|
|
bottom_row, text="",
|
|||
|
|
font=ctk.CTkFont(size=10), text_color=DIM)
|
|||
|
|
self.total_lbl.pack(side="left")
|
|||
|
|
ctk.CTkButton(
|
|||
|
|
bottom_row, text="\u2699 Einstellungen",
|
|||
|
|
width=130, height=30, corner_radius=10,
|
|||
|
|
font=ctk.CTkFont(size=12, weight="bold"),
|
|||
|
|
fg_color="#2a2a2a", hover_color="#383838",
|
|||
|
|
text_color=TXT2,
|
|||
|
|
command=self._open_settings
|
|||
|
|
).pack(side="right")
|
|||
|
|
|
|||
|
|
self.fm_var = ctk.StringVar(value="Automatisch")
|
|||
|
|
self.br_var = ctk.StringVar(value="320 kbps")
|
|||
|
|
self.as_var = ctk.StringVar(value="60 Sek.")
|
|||
|
|
self._fn_label_var = ctk.StringVar(value=FILENAME_LABELS[0])
|
|||
|
|
self.folder_lbl = None
|
|||
|
|
self.folder_hint_lbl = None
|
|||
|
|
self._refresh_total_stats()
|
|||
|
|
|
|||
|
|
# ── build right embed area ─────────────────────────────────
|
|||
|
|
|
|||
|
|
def _build_embed_area(self):
|
|||
|
|
self.embed_outer = ctk.CTkFrame(self.root, fg_color="#000000",
|
|||
|
|
corner_radius=0)
|
|||
|
|
self.embed_outer.pack(side="right", fill="both", expand=True)
|
|||
|
|
|
|||
|
|
self.embed_frame = tk.Frame(self.embed_outer, bg="#000000")
|
|||
|
|
self.embed_frame.pack(fill="both", expand=True)
|
|||
|
|
|
|||
|
|
self.embed_msg = ctk.CTkLabel(
|
|||
|
|
self.embed_outer,
|
|||
|
|
text="",
|
|||
|
|
font=ctk.CTkFont(size=15), text_color="#444",
|
|||
|
|
justify="center")
|
|||
|
|
self.embed_msg.place(relx=0.5, rely=0.5, anchor="center")
|
|||
|
|
self._update_embed_msg()
|
|||
|
|
|
|||
|
|
self.embed_frame.bind("<Configure>", self._on_embed_resize)
|
|||
|
|
|
|||
|
|
# ── app embedding (generic) ────────────────────────────────
|
|||
|
|
|
|||
|
|
def _update_embed_msg(self):
|
|||
|
|
cfg = self.platform_cfg
|
|||
|
|
name = self.platform_name
|
|||
|
|
if cfg.get("process"):
|
|||
|
|
self.embed_msg.configure(
|
|||
|
|
text=f"\u23f3 {name} wird gesucht\u2026\n\n"
|
|||
|
|
f"Stelle sicher, dass die {name} Desktop-App\n"
|
|||
|
|
"geoeffnet ist (bereits eingeloggt).")
|
|||
|
|
else:
|
|||
|
|
self.embed_msg.configure(
|
|||
|
|
text=f"\U0001f50a {name}\n\n"
|
|||
|
|
f"Spiele Musik in deinem Browser oder einer\n"
|
|||
|
|
"beliebigen App ab. Die Aufnahme erfasst\n"
|
|||
|
|
"den gesamten System-Audio-Ausgang.\n\n"
|
|||
|
|
"\u25b6 Druecke REC, wenn du bereit bist.")
|
|||
|
|
|
|||
|
|
def _attach_app(self):
|
|||
|
|
cfg = self.platform_cfg
|
|||
|
|
name = self.platform_name
|
|||
|
|
proc = cfg.get("process")
|
|||
|
|
if not proc:
|
|||
|
|
self.root.after(0, lambda: self._update_sp_status(False, system_audio=True))
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
for _ in range(30):
|
|||
|
|
hwnd = find_app_window(proc)
|
|||
|
|
if hwnd:
|
|||
|
|
self.root.after(100, lambda h=hwnd: self._embed(h))
|
|||
|
|
return
|
|||
|
|
time.sleep(1)
|
|||
|
|
|
|||
|
|
if not get_app_pids(proc):
|
|||
|
|
self.root.after(0, lambda: self.embed_msg.configure(
|
|||
|
|
text=f"\u26a0 {name} nicht gefunden.\n\n"
|
|||
|
|
f"Starte die {name} Desktop-App\n"
|
|||
|
|
"und klicke dann hier.",
|
|||
|
|
))
|
|||
|
|
launched = launch_app(cfg)
|
|||
|
|
if launched:
|
|||
|
|
for _ in range(20):
|
|||
|
|
hwnd = find_app_window(proc)
|
|||
|
|
if hwnd:
|
|||
|
|
self.root.after(100, lambda h=hwnd: self._embed(h))
|
|||
|
|
return
|
|||
|
|
time.sleep(1)
|
|||
|
|
|
|||
|
|
self.root.after(0, lambda: self._update_sp_status(False))
|
|||
|
|
|
|||
|
|
def _embed(self, hwnd):
|
|||
|
|
self.embed_frame.update_idletasks()
|
|||
|
|
container = self.embed_frame.winfo_id()
|
|||
|
|
|
|||
|
|
self.original_style = user32.GetWindowLongW(hwnd, GWL_STYLE)
|
|||
|
|
self.original_parent = user32.GetParent(hwnd)
|
|||
|
|
self.spotify_hwnd = hwnd
|
|||
|
|
|
|||
|
|
user32.SetParent(hwnd, container)
|
|||
|
|
|
|||
|
|
style = self.original_style
|
|||
|
|
style &= ~WS_CAPTION
|
|||
|
|
style &= ~WS_THICKFRAME
|
|||
|
|
style &= ~WS_POPUP
|
|||
|
|
style |= WS_CHILD
|
|||
|
|
user32.SetWindowLongW(hwnd, GWL_STYLE, style)
|
|||
|
|
|
|||
|
|
user32.SetWindowPos(hwnd, 0, 0, 0, 0, 0,
|
|||
|
|
SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER)
|
|||
|
|
|
|||
|
|
w = self.embed_frame.winfo_width()
|
|||
|
|
h = self.embed_frame.winfo_height()
|
|||
|
|
user32.MoveWindow(hwnd, 0, 0, max(w, 400), max(h, 300), True)
|
|||
|
|
|
|||
|
|
self.embed_msg.place_forget()
|
|||
|
|
self._update_sp_status(True)
|
|||
|
|
|
|||
|
|
def _on_embed_resize(self, event):
|
|||
|
|
if self.spotify_hwnd and user32.IsWindow(self.spotify_hwnd):
|
|||
|
|
user32.MoveWindow(self.spotify_hwnd, 0, 0,
|
|||
|
|
event.width, event.height, True)
|
|||
|
|
|
|||
|
|
def _restore_spotify(self):
|
|||
|
|
if self.spotify_hwnd and self.original_style is not None:
|
|||
|
|
try:
|
|||
|
|
if user32.IsWindow(self.spotify_hwnd):
|
|||
|
|
user32.SetParent(self.spotify_hwnd, self.original_parent or 0)
|
|||
|
|
user32.SetWindowLongW(self.spotify_hwnd, GWL_STYLE,
|
|||
|
|
self.original_style)
|
|||
|
|
user32.SetWindowPos(self.spotify_hwnd, 0, 0, 0, 0, 0,
|
|||
|
|
SWP_FRAMECHANGED | SWP_NOMOVE |
|
|||
|
|
SWP_NOSIZE | SWP_NOZORDER)
|
|||
|
|
user32.ShowWindow(self.spotify_hwnd, 5)
|
|||
|
|
except Exception:
|
|||
|
|
pass
|
|||
|
|
self.spotify_hwnd = None
|
|||
|
|
|
|||
|
|
def _update_sp_status(self, connected, system_audio=False):
|
|||
|
|
name = self.platform_name
|
|||
|
|
if system_audio:
|
|||
|
|
self.sp_label.configure(
|
|||
|
|
text=f"\u25cf {name} \u2013 System Audio Modus",
|
|||
|
|
text_color="#888")
|
|||
|
|
elif connected:
|
|||
|
|
self.sp_label.configure(
|
|||
|
|
text=f"\u25cf {name} verbunden", text_color=GREEN)
|
|||
|
|
else:
|
|||
|
|
self.sp_label.configure(
|
|||
|
|
text=f"\u25cf {name} nicht verbunden", text_color=RED)
|
|||
|
|
|
|||
|
|
# ── live playlist suggestion ────────────────────────────────
|
|||
|
|
|
|||
|
|
def _tick_suggest(self):
|
|||
|
|
if (not self.active
|
|||
|
|
and self.platform_cfg.get("process")
|
|||
|
|
and self.spotify_hwnd
|
|||
|
|
and user32.IsWindow(self.spotify_hwnd)
|
|||
|
|
and not self._detecting):
|
|||
|
|
self._detecting = True
|
|||
|
|
threading.Thread(target=self._suggest_async, daemon=True).start()
|
|||
|
|
self.root.after(4000, self._tick_suggest)
|
|||
|
|
|
|||
|
|
def _suggest_async(self):
|
|||
|
|
try:
|
|||
|
|
name, _ = self._detect_playlist_info()
|
|||
|
|
if name:
|
|||
|
|
self.root.after(0, lambda n=name: self._show_suggestion(n))
|
|||
|
|
except Exception:
|
|||
|
|
pass
|
|||
|
|
finally:
|
|||
|
|
self._detecting = False
|
|||
|
|
|
|||
|
|
def _show_suggestion(self, name):
|
|||
|
|
if self.active:
|
|||
|
|
return
|
|||
|
|
current = self.pl_entry.get().strip()
|
|||
|
|
if not current or current == self._last_suggestion:
|
|||
|
|
self.pl_entry.delete(0, "end")
|
|||
|
|
self.pl_entry.insert(0, name)
|
|||
|
|
self._last_suggestion = name
|
|||
|
|
if self._folder_mode == "auto" and name:
|
|||
|
|
target = os.path.join(self.output_base, name)
|
|||
|
|
self._lbl_set(self.top_folder_lbl, target)
|
|||
|
|
self._lbl_set(self.folder_lbl, target)
|
|||
|
|
|
|||
|
|
def _change_platform(self, new_name):
|
|||
|
|
if self.active:
|
|||
|
|
self.platform_var.set(self.platform_name)
|
|||
|
|
return
|
|||
|
|
if new_name == self.platform_name:
|
|||
|
|
return
|
|||
|
|
self._restore_spotify()
|
|||
|
|
self.platform_name = new_name
|
|||
|
|
self.platform_cfg = PLATFORMS[new_name]
|
|||
|
|
self._auto_record_ready = False
|
|||
|
|
self.is_playing = False
|
|||
|
|
self.last_title = ""
|
|||
|
|
self._alive_fails = 0
|
|||
|
|
self._update_embed_msg()
|
|||
|
|
if self.platform_cfg.get("process"):
|
|||
|
|
self.embed_msg.place(relx=0.5, rely=0.5, anchor="center")
|
|||
|
|
else:
|
|||
|
|
self.embed_msg.place(relx=0.5, rely=0.5, anchor="center")
|
|||
|
|
threading.Thread(target=self._attach_app, daemon=True).start()
|
|||
|
|
|
|||
|
|
# ── folder mode ────────────────────────────────────────────
|
|||
|
|
|
|||
|
|
def _lbl_set(self, lbl, text):
|
|||
|
|
if lbl and lbl.winfo_exists():
|
|||
|
|
lbl.configure(text=text)
|
|||
|
|
|
|||
|
|
def _change_folder_mode(self, val):
|
|||
|
|
if val == "Eigener Ordner":
|
|||
|
|
if not self._custom_folder:
|
|||
|
|
p = filedialog.askdirectory(initialdir=self.output_base)
|
|||
|
|
if p:
|
|||
|
|
self._custom_folder = p
|
|||
|
|
else:
|
|||
|
|
self.fm_var.set("Automatisch")
|
|||
|
|
return
|
|||
|
|
self._folder_mode = "custom"
|
|||
|
|
self._lbl_set(self.folder_lbl, self._custom_folder)
|
|||
|
|
self._lbl_set(self.top_folder_lbl, self._custom_folder)
|
|||
|
|
self._lbl_set(self.folder_hint_lbl,
|
|||
|
|
"Songs direkt in diesen Ordner (kein Unterordner)")
|
|||
|
|
self._lbl_set(self.pl_hint_lbl,
|
|||
|
|
"Optional \u2013 fuer Album-Tag in MP3")
|
|||
|
|
else:
|
|||
|
|
self._folder_mode = "auto"
|
|||
|
|
self._lbl_set(self.folder_lbl, self.output_base)
|
|||
|
|
self._lbl_set(self.top_folder_lbl, self.output_base)
|
|||
|
|
self._lbl_set(self.folder_hint_lbl,
|
|||
|
|
"Erstellt Unterordner pro Playlist")
|
|||
|
|
self._lbl_set(self.pl_hint_lbl,
|
|||
|
|
"Leer lassen = automatisch (Datum/Uhrzeit)")
|
|||
|
|
self._refresh_total_stats()
|
|||
|
|
|
|||
|
|
def _set_filename_format(self, label):
|
|||
|
|
for fmt, lbl in FILENAME_FORMATS:
|
|||
|
|
if lbl == label:
|
|||
|
|
self._fn_format = fmt
|
|||
|
|
break
|
|||
|
|
self._update_fn_preview()
|
|||
|
|
|
|||
|
|
# ── settings dialog ──────────────────────────────────────────
|
|||
|
|
|
|||
|
|
def _open_settings(self):
|
|||
|
|
if hasattr(self, "_settings_win") and self._settings_win and self._settings_win.winfo_exists():
|
|||
|
|
self._settings_win.focus()
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
win = ctk.CTkToplevel(self.root)
|
|||
|
|
self._settings_win = win
|
|||
|
|
win.title("Einstellungen")
|
|||
|
|
win.geometry("420x520")
|
|||
|
|
win.resizable(False, False)
|
|||
|
|
win.configure(fg_color=BG)
|
|||
|
|
win.transient(self.root)
|
|||
|
|
win.grab_set()
|
|||
|
|
|
|||
|
|
pad = {"padx": 20}
|
|||
|
|
|
|||
|
|
ctk.CTkLabel(win, text="\u2699 Einstellungen",
|
|||
|
|
font=ctk.CTkFont(size=18, weight="bold"),
|
|||
|
|
text_color=TXT).pack(**pad, pady=(20, 18), anchor="w")
|
|||
|
|
|
|||
|
|
# -- Zielordner --
|
|||
|
|
ctk.CTkLabel(win, text="ZIELORDNER",
|
|||
|
|
font=ctk.CTkFont(size=9, weight="bold"),
|
|||
|
|
text_color=DIM).pack(**pad, anchor="w")
|
|||
|
|
|
|||
|
|
fm_row = ctk.CTkFrame(win, fg_color="transparent")
|
|||
|
|
fm_row.pack(fill="x", **pad, pady=(6, 0))
|
|||
|
|
ctk.CTkLabel(fm_row, text="Modus",
|
|||
|
|
font=ctk.CTkFont(size=12), text_color=TXT2).pack(side="left")
|
|||
|
|
ctk.CTkOptionMenu(
|
|||
|
|
fm_row, values=["Automatisch", "Eigener Ordner"],
|
|||
|
|
variable=self.fm_var, width=160, height=28,
|
|||
|
|
font=ctk.CTkFont(size=11),
|
|||
|
|
fg_color="#2a2a2a", button_color="#333",
|
|||
|
|
button_hover_color="#444",
|
|||
|
|
command=self._change_folder_mode
|
|||
|
|
).pack(side="right")
|
|||
|
|
|
|||
|
|
fr = ctk.CTkFrame(win, fg_color="transparent")
|
|||
|
|
fr.pack(fill="x", **pad, pady=(8, 0))
|
|||
|
|
ctk.CTkButton(fr, text="Aendern", width=70, height=28,
|
|||
|
|
corner_radius=8, font=ctk.CTkFont(size=11),
|
|||
|
|
fg_color="#2a2a2a", hover_color="#383838",
|
|||
|
|
command=self._choose_folder).pack(side="right")
|
|||
|
|
ctk.CTkButton(fr, text="\U0001f4c2 Oeffnen", width=85, height=28,
|
|||
|
|
corner_radius=8, font=ctk.CTkFont(size=11),
|
|||
|
|
fg_color="#2a2a2a", hover_color="#383838",
|
|||
|
|
command=self._open_folder).pack(side="right", padx=(0, 6))
|
|||
|
|
self.folder_lbl = ctk.CTkLabel(
|
|||
|
|
win, text=(self._custom_folder if self._folder_mode == "custom"
|
|||
|
|
else self.output_base),
|
|||
|
|
font=ctk.CTkFont(size=11),
|
|||
|
|
text_color=GREEN, wraplength=370, anchor="w")
|
|||
|
|
self.folder_lbl.pack(**pad, anchor="w", pady=(4, 0))
|
|||
|
|
self.folder_hint_lbl = ctk.CTkLabel(
|
|||
|
|
win,
|
|||
|
|
text=("Songs direkt in diesen Ordner (kein Unterordner)"
|
|||
|
|
if self._folder_mode == "custom"
|
|||
|
|
else "Erstellt Unterordner pro Playlist"),
|
|||
|
|
font=ctk.CTkFont(size=9), text_color="#444")
|
|||
|
|
self.folder_hint_lbl.pack(**pad, anchor="w")
|
|||
|
|
|
|||
|
|
ctk.CTkFrame(win, height=1, fg_color=BORDER).pack(fill="x", **pad, pady=(12, 12))
|
|||
|
|
|
|||
|
|
# -- Dateiname --
|
|||
|
|
ctk.CTkLabel(win, text="DATEINAME",
|
|||
|
|
font=ctk.CTkFont(size=9, weight="bold"),
|
|||
|
|
text_color=DIM).pack(**pad, anchor="w")
|
|||
|
|
|
|||
|
|
fn_row = ctk.CTkFrame(win, fg_color="transparent")
|
|||
|
|
fn_row.pack(fill="x", **pad, pady=(6, 0))
|
|||
|
|
ctk.CTkLabel(fn_row, text="Format",
|
|||
|
|
font=ctk.CTkFont(size=12), text_color=TXT2).pack(side="left")
|
|||
|
|
ctk.CTkOptionMenu(
|
|||
|
|
fn_row, values=FILENAME_LABELS,
|
|||
|
|
variable=self._fn_label_var, width=190, height=28,
|
|||
|
|
font=ctk.CTkFont(size=11),
|
|||
|
|
fg_color="#2a2a2a", button_color="#333",
|
|||
|
|
button_hover_color="#444",
|
|||
|
|
command=self._set_filename_format
|
|||
|
|
).pack(side="right")
|
|||
|
|
|
|||
|
|
self._fn_preview_lbl = ctk.CTkLabel(
|
|||
|
|
win, text="", font=ctk.CTkFont(size=10), text_color="#666")
|
|||
|
|
self._fn_preview_lbl.pack(**pad, anchor="w", pady=(4, 0))
|
|||
|
|
self._update_fn_preview()
|
|||
|
|
|
|||
|
|
ctk.CTkFrame(win, height=1, fg_color=BORDER).pack(fill="x", **pad, pady=(12, 12))
|
|||
|
|
|
|||
|
|
# -- Qualitaet --
|
|||
|
|
ctk.CTkLabel(win, text="AUFNAHME",
|
|||
|
|
font=ctk.CTkFont(size=9, weight="bold"),
|
|||
|
|
text_color=DIM).pack(**pad, anchor="w")
|
|||
|
|
|
|||
|
|
br_row = ctk.CTkFrame(win, fg_color="transparent")
|
|||
|
|
br_row.pack(fill="x", **pad, pady=(6, 0))
|
|||
|
|
ctk.CTkLabel(br_row, text="Qualitaet",
|
|||
|
|
font=ctk.CTkFont(size=12), text_color=TXT2).pack(side="left")
|
|||
|
|
ctk.CTkOptionMenu(
|
|||
|
|
br_row, values=["128 kbps", "192 kbps", "256 kbps", "320 kbps"],
|
|||
|
|
variable=self.br_var, width=130, height=28,
|
|||
|
|
font=ctk.CTkFont(size=11),
|
|||
|
|
fg_color="#2a2a2a", button_color="#333", button_hover_color="#444",
|
|||
|
|
command=self._set_bitrate
|
|||
|
|
).pack(side="right")
|
|||
|
|
|
|||
|
|
as_row = ctk.CTkFrame(win, fg_color="transparent")
|
|||
|
|
as_row.pack(fill="x", **pad, pady=(10, 0))
|
|||
|
|
ctk.CTkLabel(as_row, text="Auto-Stop",
|
|||
|
|
font=ctk.CTkFont(size=12), text_color=TXT2).pack(side="left")
|
|||
|
|
ctk.CTkOptionMenu(
|
|||
|
|
as_row, values=["15 Sek.", "30 Sek.", "60 Sek.", "120 Sek.", "Aus"],
|
|||
|
|
variable=self.as_var, width=130, height=28,
|
|||
|
|
font=ctk.CTkFont(size=11),
|
|||
|
|
fg_color="#2a2a2a", button_color="#333", button_hover_color="#444",
|
|||
|
|
command=self._set_auto_stop
|
|||
|
|
).pack(side="right")
|
|||
|
|
ctk.CTkLabel(win, text="Stoppt Aufnahme wenn Playlist endet",
|
|||
|
|
font=ctk.CTkFont(size=9), text_color="#444"
|
|||
|
|
).pack(**pad, anchor="w", pady=(2, 0))
|
|||
|
|
|
|||
|
|
ctk.CTkButton(
|
|||
|
|
win, text="Schliessen", width=120, height=34,
|
|||
|
|
corner_radius=12, font=ctk.CTkFont(size=13, weight="bold"),
|
|||
|
|
fg_color=GREEN, hover_color=GREEN_H,
|
|||
|
|
command=win.destroy
|
|||
|
|
).pack(pady=(20, 16))
|
|||
|
|
|
|||
|
|
def _update_fn_preview(self):
|
|||
|
|
preview = self._fn_format.format(
|
|||
|
|
nr="01", artist="Kuenstler", titel="Songname")
|
|||
|
|
if hasattr(self, "_fn_preview_lbl") and self._fn_preview_lbl.winfo_exists():
|
|||
|
|
self._fn_preview_lbl.configure(text=f"Vorschau: {preview}.mp3")
|
|||
|
|
|
|||
|
|
# ── recording control ──────────────────────────────────────
|
|||
|
|
|
|||
|
|
def _toggle(self):
|
|||
|
|
if self.active:
|
|||
|
|
self._user_stopped = True
|
|||
|
|
self._stop()
|
|||
|
|
else:
|
|||
|
|
self._start()
|
|||
|
|
|
|||
|
|
def _start(self):
|
|||
|
|
if self._restart_after_id:
|
|||
|
|
self.root.after_cancel(self._restart_after_id)
|
|||
|
|
self._restart_after_id = None
|
|||
|
|
|
|||
|
|
if self._folder_mode == "custom" and not self._custom_folder:
|
|||
|
|
self._set_status("ORDNER WAEHLEN!", RED)
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
has_app = self.platform_cfg.get("process")
|
|||
|
|
if has_app and (not self.spotify_hwnd
|
|||
|
|
or not user32.IsWindow(self.spotify_hwnd)):
|
|||
|
|
self._set_status(f"{self.platform_name} FEHLT", RED)
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
self._user_stopped = False
|
|||
|
|
user_name = self.pl_entry.get().strip()
|
|||
|
|
self.rec_btn.configure(state="disabled")
|
|||
|
|
self._set_status("WIRD GESTARTET\u2026", GREEN)
|
|||
|
|
threading.Thread(
|
|||
|
|
target=self._start_async, args=(user_name,), daemon=True
|
|||
|
|
).start()
|
|||
|
|
|
|||
|
|
def _start_async(self, user_name):
|
|||
|
|
has_app = self.platform_cfg.get("process")
|
|||
|
|
sep = self.platform_cfg.get("sep")
|
|||
|
|
|
|||
|
|
if has_app and self.spotify_hwnd:
|
|||
|
|
detected_name, total = self._detect_playlist_info()
|
|||
|
|
else:
|
|||
|
|
detected_name, total = None, 0
|
|||
|
|
|
|||
|
|
if self._folder_mode == "custom":
|
|||
|
|
name = (user_name
|
|||
|
|
or detected_name
|
|||
|
|
or os.path.basename(self._custom_folder))
|
|||
|
|
if has_app and self.spotify_hwnd:
|
|||
|
|
title = get_window_title(self.spotify_hwnd)
|
|||
|
|
if not title or (sep and sep not in title):
|
|||
|
|
self._send_play()
|
|||
|
|
time.sleep(2)
|
|||
|
|
self.root.after(
|
|||
|
|
0, lambda n=name, t=total: self._start_finish(n, t))
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
if not user_name and not detected_name:
|
|||
|
|
prefix = self.platform_name.replace(" ", "")
|
|||
|
|
suggestion = datetime.datetime.now().strftime(
|
|||
|
|
f"{prefix}_%Y-%m-%d_%H-%M")
|
|||
|
|
self.root.after(
|
|||
|
|
0, lambda s=suggestion, t=total:
|
|||
|
|
self._ask_folder_name(s, t))
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
name = user_name or detected_name
|
|||
|
|
|
|||
|
|
if has_app and self.spotify_hwnd:
|
|||
|
|
title = get_window_title(self.spotify_hwnd)
|
|||
|
|
if not title or (sep and sep not in title):
|
|||
|
|
self._send_play()
|
|||
|
|
time.sleep(2)
|
|||
|
|
|
|||
|
|
self.root.after(0, lambda n=name, t=total: self._start_finish(n, t))
|
|||
|
|
|
|||
|
|
def _ask_folder_name(self, suggestion, total):
|
|||
|
|
"""Show dialog to ask user for a folder name."""
|
|||
|
|
dialog = ctk.CTkInputDialog(
|
|||
|
|
text="Kein Playlist-Name erkannt.\n\n"
|
|||
|
|
f"Vorschlag: {suggestion}\n\n"
|
|||
|
|
"Ordnername eingeben\n"
|
|||
|
|
"(leer = Vorschlag uebernehmen):",
|
|||
|
|
title="Surovy's Music Recorder \u2013 Ordnername",
|
|||
|
|
fg_color=CARD, button_fg_color=GREEN,
|
|||
|
|
button_hover_color=GREEN_H)
|
|||
|
|
result = dialog.get_input()
|
|||
|
|
if result is None:
|
|||
|
|
self.rec_btn.configure(state="normal")
|
|||
|
|
self._set_status("BEREIT", DIM)
|
|||
|
|
return
|
|||
|
|
name = result.strip() or suggestion
|
|||
|
|
has_app = self.platform_cfg.get("process")
|
|||
|
|
if has_app and self.spotify_hwnd:
|
|||
|
|
try:
|
|||
|
|
title = get_window_title(self.spotify_hwnd)
|
|||
|
|
except Exception:
|
|||
|
|
title = ""
|
|||
|
|
sep = self.platform_cfg.get("sep")
|
|||
|
|
if not title or (sep and sep not in title):
|
|||
|
|
self._send_play()
|
|||
|
|
self.root.after(
|
|||
|
|
2000, lambda: self._start_finish(name, total))
|
|||
|
|
return
|
|||
|
|
self._start_finish(name, total)
|
|||
|
|
|
|||
|
|
def _start_finish(self, name, total=0):
|
|||
|
|
has_app = self.platform_cfg.get("process")
|
|||
|
|
if has_app and (not self.spotify_hwnd
|
|||
|
|
or not user32.IsWindow(self.spotify_hwnd)):
|
|||
|
|
self._set_status(f"{self.platform_name} FEHLT", RED)
|
|||
|
|
self.rec_btn.configure(state="normal")
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
self.pl_entry.configure(state="normal")
|
|||
|
|
self.pl_entry.delete(0, "end")
|
|||
|
|
self.pl_entry.insert(0, name)
|
|||
|
|
|
|||
|
|
if self._folder_mode == "custom" and self._custom_folder:
|
|||
|
|
self.playlist_name = name
|
|||
|
|
self.session_dir = self._custom_folder
|
|||
|
|
else:
|
|||
|
|
safe = name
|
|||
|
|
for ch in '<>:"/\\|?*':
|
|||
|
|
safe = safe.replace(ch, "_")
|
|||
|
|
self.playlist_name = name
|
|||
|
|
self.session_dir = os.path.join(self.output_base, safe)
|
|||
|
|
os.makedirs(self.session_dir, exist_ok=True)
|
|||
|
|
|
|||
|
|
self._lbl_set(self.top_folder_lbl, self.session_dir)
|
|||
|
|
self._lbl_set(self.folder_lbl, self.session_dir)
|
|||
|
|
|
|||
|
|
try:
|
|||
|
|
self.recorder.start()
|
|||
|
|
except RuntimeError as e:
|
|||
|
|
self._set_status(str(e)[:40], RED)
|
|||
|
|
self.rec_btn.configure(state="normal")
|
|||
|
|
return
|
|||
|
|
self._prevent_sleep()
|
|||
|
|
|
|||
|
|
self.recorded_songs = self._scan_existing_songs()
|
|||
|
|
existing = len(self.recorded_songs)
|
|||
|
|
max_num = self._get_max_track_num()
|
|||
|
|
|
|||
|
|
if total > 0 and existing >= total:
|
|||
|
|
self.recorder.stop()
|
|||
|
|
self._allow_sleep()
|
|||
|
|
self.rec_btn.configure(
|
|||
|
|
text="\u23fa AUFNAHME STARTEN",
|
|||
|
|
fg_color=GREEN, hover_color=GREEN_H, state="normal")
|
|||
|
|
self.pl_entry.configure(state="normal")
|
|||
|
|
self._set_status(
|
|||
|
|
f"ALLE {total} SONGS VORHANDEN", GREEN)
|
|||
|
|
self.cnt_lbl.configure(
|
|||
|
|
text=f"{existing} / {total} Songs")
|
|||
|
|
self.tnum_lbl.configure(text=f"\u2714 {total} SONGS")
|
|||
|
|
self.artist_lbl.configure(text="Playlist vollstaendig")
|
|||
|
|
self.title_lbl.configure(
|
|||
|
|
text="Alle Songs bereits aufgenommen")
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
self.active = True
|
|||
|
|
if total > 0:
|
|||
|
|
self.playlist_total = total
|
|||
|
|
self.track_number = max(existing, max_num)
|
|||
|
|
self.current_track = None
|
|||
|
|
self.songs = []
|
|||
|
|
self.last_title = ""
|
|||
|
|
self.pause_since = None
|
|||
|
|
|
|||
|
|
skipping = False
|
|||
|
|
sep = self.platform_cfg.get("sep")
|
|||
|
|
has_app = self.platform_cfg.get("process")
|
|||
|
|
title = (get_window_title(self.spotify_hwnd)
|
|||
|
|
if self.spotify_hwnd else "")
|
|||
|
|
|
|||
|
|
if title and sep and sep in title:
|
|||
|
|
parts = title.split(sep, 1)
|
|||
|
|
artist, song = parts[0].strip(), parts[1].strip()
|
|||
|
|
self.last_title = title
|
|||
|
|
self.is_playing = True
|
|||
|
|
|
|||
|
|
if self._song_key(artist, song) in self.recorded_songs:
|
|||
|
|
skipping = True
|
|||
|
|
self.artist_lbl.configure(text=artist)
|
|||
|
|
self.title_lbl.configure(
|
|||
|
|
text=f"\u2714 {song}")
|
|||
|
|
self.tnum_lbl.configure(text="BEREITS AUFGENOMMEN")
|
|||
|
|
else:
|
|||
|
|
self.track_number += 1
|
|||
|
|
self.current_track = {"artist": artist, "title": song}
|
|||
|
|
self._update_track_ui()
|
|||
|
|
elif not has_app:
|
|||
|
|
self.track_number = 1
|
|||
|
|
ts = datetime.datetime.now().strftime("%H-%M-%S")
|
|||
|
|
self.current_track = {
|
|||
|
|
"artist": self.platform_name,
|
|||
|
|
"title": f"Recording {ts}",
|
|||
|
|
}
|
|||
|
|
self.is_playing = True
|
|||
|
|
self.artist_lbl.configure(text=self.platform_name)
|
|||
|
|
self.title_lbl.configure(text="System Audio Aufnahme")
|
|||
|
|
self.tnum_lbl.configure(text="AUFNAHME LAEUFT")
|
|||
|
|
|
|||
|
|
self.rec_start = time.time()
|
|||
|
|
|
|||
|
|
if self.playlist_total > 0:
|
|||
|
|
self.cnt_lbl.configure(
|
|||
|
|
text=f"{existing} / {self.playlist_total} Songs")
|
|||
|
|
elif existing > 0:
|
|||
|
|
self.cnt_lbl.configure(text=f"{existing} bereits vorhanden")
|
|||
|
|
|
|||
|
|
self.rec_btn.configure(
|
|||
|
|
text="\u23f9 AUFNAHME STOPPEN",
|
|||
|
|
fg_color=RED, hover_color=RED_H, state="normal")
|
|||
|
|
self.pl_entry.configure(state="disabled")
|
|||
|
|
if skipping:
|
|||
|
|
self._set_status("\u23ed WARTE AUF NEUEN SONG", ORANGE)
|
|||
|
|
else:
|
|||
|
|
self._set_status("AUFNAHME", GREEN)
|
|||
|
|
|
|||
|
|
def _send_play(self):
|
|||
|
|
"""Send media play/pause key to start Spotify playback."""
|
|||
|
|
user32.keybd_event(0xB3, 0, 0, 0)
|
|||
|
|
time.sleep(0.05)
|
|||
|
|
user32.keybd_event(0xB3, 0, 2, 0)
|
|||
|
|
|
|||
|
|
def _detect_playlist_info(self):
|
|||
|
|
"""Detect playlist name AND track count in a single call."""
|
|||
|
|
if not self.spotify_hwnd:
|
|||
|
|
return None, 0
|
|||
|
|
try:
|
|||
|
|
hwnd_val = int(self.spotify_hwnd)
|
|||
|
|
except (TypeError, ValueError):
|
|||
|
|
return None, 0
|
|||
|
|
|
|||
|
|
ps = (
|
|||
|
|
"$ErrorActionPreference='SilentlyContinue';"
|
|||
|
|
"Add-Type -AssemblyName UIAutomationClient;"
|
|||
|
|
"Add-Type -AssemblyName UIAutomationTypes;"
|
|||
|
|
"$r=[System.Windows.Automation.AutomationElement]"
|
|||
|
|
f"::FromHandle([IntPtr]::new({hwnd_val}));"
|
|||
|
|
"if($r){"
|
|||
|
|
"$h=[System.Windows.Automation.PropertyCondition]::new("
|
|||
|
|
"[System.Windows.Automation.AutomationElement]"
|
|||
|
|
"::ControlTypeProperty,"
|
|||
|
|
"[System.Windows.Automation.ControlType]::Hyperlink);"
|
|||
|
|
"$t=[System.Windows.Automation.PropertyCondition]::new("
|
|||
|
|
"[System.Windows.Automation.AutomationElement]"
|
|||
|
|
"::ControlTypeProperty,"
|
|||
|
|
"[System.Windows.Automation.ControlType]::Text);"
|
|||
|
|
"$g=[System.Windows.Automation.PropertyCondition]::new("
|
|||
|
|
"[System.Windows.Automation.AutomationElement]"
|
|||
|
|
"::ControlTypeProperty,"
|
|||
|
|
"[System.Windows.Automation.ControlType]::Button);"
|
|||
|
|
"$c=[System.Windows.Automation.OrCondition]::new($h,$t,$g);"
|
|||
|
|
"$ls=$r.FindAll("
|
|||
|
|
"[System.Windows.Automation.TreeScope]::Descendants,$c);"
|
|||
|
|
"foreach($l in $ls){"
|
|||
|
|
"$n=$l.Current.Name;"
|
|||
|
|
"$b=$l.Current.BoundingRectangle;"
|
|||
|
|
"if($n -and $n.Length -ge 2 -and $b.Width -gt 0){"
|
|||
|
|
"'{0}|{1}|{2}' -f [int]$b.Height,[int]$b.Bottom,$n"
|
|||
|
|
"}}}"
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
try:
|
|||
|
|
r = subprocess.run(
|
|||
|
|
["powershell", "-NoProfile", "-ExecutionPolicy", "Bypass",
|
|||
|
|
"-Command", ps],
|
|||
|
|
capture_output=True, text=True, timeout=12,
|
|||
|
|
creationflags=0x08000000,
|
|||
|
|
)
|
|||
|
|
raw = [ln.strip() for ln in r.stdout.split("\n")
|
|||
|
|
if ln.strip() and "|" in ln]
|
|||
|
|
except Exception:
|
|||
|
|
return None, 0
|
|||
|
|
|
|||
|
|
if not raw:
|
|||
|
|
return None, 0
|
|||
|
|
|
|||
|
|
entries = []
|
|||
|
|
track_count = 0
|
|||
|
|
count_re = re.compile(
|
|||
|
|
r'(\d+)\s*(songs?|titel|tracks?|titres?|morceaux'
|
|||
|
|
r'|canciones|brani)', re.I)
|
|||
|
|
time_re = re.compile(r'^\d{1,2}:\d{2}$')
|
|||
|
|
|
|||
|
|
for line in raw:
|
|||
|
|
parts_raw = line.split("|", 2)
|
|||
|
|
if len(parts_raw) == 3:
|
|||
|
|
try:
|
|||
|
|
height = int(parts_raw[0])
|
|||
|
|
pos_int = int(parts_raw[1])
|
|||
|
|
except ValueError:
|
|||
|
|
continue
|
|||
|
|
nm = parts_raw[2]
|
|||
|
|
elif len(parts_raw) == 2:
|
|||
|
|
try:
|
|||
|
|
pos_int = int(parts_raw[0])
|
|||
|
|
except ValueError:
|
|||
|
|
continue
|
|||
|
|
nm = parts_raw[1]
|
|||
|
|
height = 0
|
|||
|
|
else:
|
|||
|
|
continue
|
|||
|
|
|
|||
|
|
m = count_re.search(nm)
|
|||
|
|
if m:
|
|||
|
|
track_count = int(m.group(1))
|
|||
|
|
continue
|
|||
|
|
|
|||
|
|
entries.append((height, pos_int, nm))
|
|||
|
|
|
|||
|
|
title = get_window_title(self.spotify_hwnd)
|
|||
|
|
sep = self.platform_cfg.get("sep", " - ")
|
|||
|
|
skip = {
|
|||
|
|
"spotify", "home", "search", "your library", "library",
|
|||
|
|
"play", "pause", "next", "previous", "shuffle", "repeat",
|
|||
|
|
"queue", "volume", "connect to a device", "lyrics",
|
|||
|
|
"settings", "profile", "close", "minimize", "maximize",
|
|||
|
|
"now playing view", "premium", "free", "install app",
|
|||
|
|
"create playlist", "liked songs", "your episodes",
|
|||
|
|
"what's new", "open in desktop app", "download",
|
|||
|
|
"go back", "go forward", "resize", "explicit",
|
|||
|
|
"now playing", "connect", "what\u2019s new",
|
|||
|
|
"tidal", "apple music", "amazon music", "deezer",
|
|||
|
|
}
|
|||
|
|
skip.update(self.platform_cfg.get("pause", set()))
|
|||
|
|
if title and sep and sep in title:
|
|||
|
|
parts = title.split(sep, 1)
|
|||
|
|
skip.add(parts[0].strip().lower())
|
|||
|
|
skip.add(parts[1].strip().lower())
|
|||
|
|
|
|||
|
|
entries.sort(key=lambda x: x[0], reverse=True)
|
|||
|
|
|
|||
|
|
playlist_name = None
|
|||
|
|
for _h, _p, nm in entries:
|
|||
|
|
lower = nm.lower().strip()
|
|||
|
|
if lower in skip:
|
|||
|
|
continue
|
|||
|
|
if len(nm) < 2:
|
|||
|
|
continue
|
|||
|
|
if time_re.match(nm):
|
|||
|
|
continue
|
|||
|
|
if nm.isdigit():
|
|||
|
|
continue
|
|||
|
|
if len(nm) > 120:
|
|||
|
|
continue
|
|||
|
|
playlist_name = nm
|
|||
|
|
break
|
|||
|
|
|
|||
|
|
return playlist_name, track_count
|
|||
|
|
|
|||
|
|
def _stop(self, finished=False):
|
|||
|
|
self.active = False
|
|||
|
|
self.pause_since = None
|
|||
|
|
self._allow_sleep()
|
|||
|
|
with self._lock:
|
|||
|
|
frames = self.recorder.harvest_frames()
|
|||
|
|
if frames and self.current_track and self.track_number > 0:
|
|||
|
|
self._save(frames, self.current_track, self.track_number)
|
|||
|
|
self.recorder.stop()
|
|||
|
|
self.current_track = None
|
|||
|
|
self.rec_start = None
|
|||
|
|
|
|||
|
|
self.rec_btn.configure(text="\u23fa AUFNAHME STARTEN",
|
|||
|
|
fg_color=GREEN, hover_color=GREEN_H)
|
|||
|
|
self.pl_entry.configure(state="normal")
|
|||
|
|
n = len(self.songs)
|
|||
|
|
if self.playlist_total > 0:
|
|||
|
|
info = f"{self.track_number}/{self.playlist_total} Songs"
|
|||
|
|
else:
|
|||
|
|
info = f"{n} Songs aufgenommen"
|
|||
|
|
|
|||
|
|
not_complete = (self.playlist_total > 0
|
|||
|
|
and self.track_number < self.playlist_total)
|
|||
|
|
should_restart = not_complete and not self._user_stopped
|
|||
|
|
|
|||
|
|
if should_restart and self._restart_fails < 5:
|
|||
|
|
self._set_status(f"{info} \u2013 NEUSTART\u2026", ORANGE)
|
|||
|
|
self._restart_countdown(5)
|
|||
|
|
elif finished:
|
|||
|
|
self._set_status(f"FERTIG \u2013 {info}", GREEN)
|
|||
|
|
else:
|
|||
|
|
self._set_status(
|
|||
|
|
f"GESTOPPT \u2013 {info}" if n else "BEREIT",
|
|||
|
|
GREEN if n else DIM)
|
|||
|
|
self._user_stopped = False
|
|||
|
|
self.level_bar.set(0)
|
|||
|
|
|
|||
|
|
def _restart_countdown(self, secs):
|
|||
|
|
"""Count down and then auto-restart recording."""
|
|||
|
|
if secs <= 0:
|
|||
|
|
self._auto_restart()
|
|||
|
|
return
|
|||
|
|
if self._user_stopped or self.active:
|
|||
|
|
self._restart_after_id = None
|
|||
|
|
return
|
|||
|
|
info = f"{self.track_number}/{self.playlist_total}"
|
|||
|
|
self._set_status(
|
|||
|
|
f"{info} \u2013 NEUSTART IN {secs}s\u2026", ORANGE)
|
|||
|
|
self._restart_after_id = self.root.after(
|
|||
|
|
1000, lambda: self._restart_countdown(secs - 1))
|
|||
|
|
|
|||
|
|
def _auto_restart(self):
|
|||
|
|
"""Automatically restart recording to continue the playlist."""
|
|||
|
|
self._restart_after_id = None
|
|||
|
|
if self.active or self._user_stopped:
|
|||
|
|
return
|
|||
|
|
if (self.playlist_total > 0
|
|||
|
|
and self.track_number < self.playlist_total):
|
|||
|
|
prev_count = self.track_number
|
|||
|
|
self._start()
|
|||
|
|
self.root.after(
|
|||
|
|
15000, lambda p=prev_count: self._check_restart_progress(p))
|
|||
|
|
|
|||
|
|
def _check_restart_progress(self, prev_count):
|
|||
|
|
"""Increment fail counter if no new songs were recorded."""
|
|||
|
|
if self.track_number <= prev_count and self.active:
|
|||
|
|
self._restart_fails += 1
|
|||
|
|
else:
|
|||
|
|
self._restart_fails = 0
|
|||
|
|
|
|||
|
|
# ── track monitoring ───────────────────────────────────────
|
|||
|
|
|
|||
|
|
def _tick_monitor(self):
|
|||
|
|
try:
|
|||
|
|
self._tick_monitor_inner()
|
|||
|
|
except Exception:
|
|||
|
|
pass
|
|||
|
|
self.root.after(500, self._tick_monitor)
|
|||
|
|
|
|||
|
|
def _tick_monitor_inner(self):
|
|||
|
|
sep = self.platform_cfg.get("sep")
|
|||
|
|
pause_titles = self.platform_cfg.get("pause", set())
|
|||
|
|
|
|||
|
|
if self.spotify_hwnd and user32.IsWindow(self.spotify_hwnd):
|
|||
|
|
try:
|
|||
|
|
title = get_window_title(self.spotify_hwnd)
|
|||
|
|
except Exception:
|
|||
|
|
title = ""
|
|||
|
|
|
|||
|
|
if not title:
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
if sep and sep in title:
|
|||
|
|
self.ad_playing = False
|
|||
|
|
if not self.is_playing:
|
|||
|
|
self.is_playing = True
|
|||
|
|
self.pause_since = None
|
|||
|
|
if self.active:
|
|||
|
|
self.recorder.resume()
|
|||
|
|
if self.current_track is not None:
|
|||
|
|
self._set_status("AUFNAHME", GREEN)
|
|||
|
|
elif (self._auto_record_ready
|
|||
|
|
and self.auto_rec_var.get()):
|
|||
|
|
self._start()
|
|||
|
|
if not self._auto_record_ready:
|
|||
|
|
self._auto_record_ready = True
|
|||
|
|
|
|||
|
|
if title != self.last_title and self.active:
|
|||
|
|
self._handle_track_change(title)
|
|||
|
|
elif title != self.last_title:
|
|||
|
|
parts = title.split(sep, 1)
|
|||
|
|
self.artist_lbl.configure(text=parts[0].strip())
|
|||
|
|
self.title_lbl.configure(text=parts[1].strip())
|
|||
|
|
elif (self.active and self.current_track is None
|
|||
|
|
and title == self.last_title):
|
|||
|
|
parts = title.split(sep, 1)
|
|||
|
|
artist = parts[0].strip()
|
|||
|
|
song = parts[1].strip()
|
|||
|
|
key = self._song_key(artist, song)
|
|||
|
|
if key not in self.recorded_songs:
|
|||
|
|
self.track_number += 1
|
|||
|
|
self.current_track = {
|
|||
|
|
"artist": artist, "title": song}
|
|||
|
|
self._update_track_ui()
|
|||
|
|
self._set_status("AUFNAHME", GREEN)
|
|||
|
|
else:
|
|||
|
|
self.recorder.harvest_frames()
|
|||
|
|
self.last_title = title
|
|||
|
|
|
|||
|
|
else:
|
|||
|
|
if not self._auto_record_ready:
|
|||
|
|
self._auto_record_ready = True
|
|||
|
|
if title.lower().strip() in pause_titles:
|
|||
|
|
self.ad_playing = False
|
|||
|
|
if self.is_playing:
|
|||
|
|
self.is_playing = False
|
|||
|
|
if self.active:
|
|||
|
|
self.recorder.pause()
|
|||
|
|
if self.current_track is not None:
|
|||
|
|
self.pause_since = time.time()
|
|||
|
|
self._set_status("PAUSIERT", ORANGE)
|
|||
|
|
else:
|
|||
|
|
if not self.ad_playing:
|
|||
|
|
self.ad_playing = True
|
|||
|
|
if self.active and self.current_track \
|
|||
|
|
and self.track_number > 0:
|
|||
|
|
with self._lock:
|
|||
|
|
frames = self.recorder.harvest_frames()
|
|||
|
|
if frames:
|
|||
|
|
num = self.track_number
|
|||
|
|
trk = dict(self.current_track)
|
|||
|
|
threading.Thread(
|
|||
|
|
target=self._save,
|
|||
|
|
args=(frames, trk, num),
|
|||
|
|
daemon=True).start()
|
|||
|
|
self.current_track = None
|
|||
|
|
if self.active:
|
|||
|
|
self._set_status("\U0001f507 WERBUNG", ORANGE)
|
|||
|
|
self.artist_lbl.configure(
|
|||
|
|
text="Werbung erkannt")
|
|||
|
|
self.title_lbl.configure(
|
|||
|
|
text="wird nicht aufgenommen")
|
|||
|
|
self.tnum_lbl.configure(text="")
|
|||
|
|
if self.active and self.current_track is None:
|
|||
|
|
self.recorder.harvest_frames()
|
|||
|
|
self.pause_since = None
|
|||
|
|
|
|||
|
|
if (self.active and self.pause_since
|
|||
|
|
and self.auto_stop_secs > 0):
|
|||
|
|
all_done = (self.playlist_total > 0
|
|||
|
|
and self.track_number >= self.playlist_total)
|
|||
|
|
timeout = self.auto_stop_secs
|
|||
|
|
if self.playlist_total > 0 and not all_done:
|
|||
|
|
timeout = max(timeout, 300)
|
|||
|
|
elapsed = time.time() - self.pause_since
|
|||
|
|
remaining = timeout - elapsed
|
|||
|
|
if remaining <= 0:
|
|||
|
|
self._stop(finished=True)
|
|||
|
|
else:
|
|||
|
|
if all_done:
|
|||
|
|
lbl = f"Fertig! Stop {int(remaining)}s"
|
|||
|
|
elif self.playlist_total > 0:
|
|||
|
|
lbl = (f"{self.track_number}/{self.playlist_total}"
|
|||
|
|
f" \u23f8 {int(remaining)}s")
|
|||
|
|
else:
|
|||
|
|
lbl = f"Stop {int(remaining)}s"
|
|||
|
|
self.time_lbl.configure(
|
|||
|
|
text=lbl, text_color=ORANGE)
|
|||
|
|
|
|||
|
|
elif not self.platform_cfg.get("process"):
|
|||
|
|
if self.active:
|
|||
|
|
lvl = self.recorder.get_level()
|
|||
|
|
if lvl < self._silence_threshold:
|
|||
|
|
if self._silence_start is None:
|
|||
|
|
self._silence_start = time.time()
|
|||
|
|
elif (time.time() - self._silence_start
|
|||
|
|
>= self._min_silence_secs
|
|||
|
|
and self.current_track):
|
|||
|
|
with self._lock:
|
|||
|
|
frames = self.recorder.harvest_frames()
|
|||
|
|
if frames:
|
|||
|
|
num = self.track_number
|
|||
|
|
trk = dict(self.current_track)
|
|||
|
|
threading.Thread(
|
|||
|
|
target=self._save,
|
|||
|
|
args=(frames, trk, num),
|
|||
|
|
daemon=True).start()
|
|||
|
|
self.track_number += 1
|
|||
|
|
self.current_track = {
|
|||
|
|
"artist": self.platform_name,
|
|||
|
|
"title": f"Track {self.track_number:02d}",
|
|||
|
|
}
|
|||
|
|
self._update_track_ui()
|
|||
|
|
self.rec_start = time.time()
|
|||
|
|
self._silence_start = None
|
|||
|
|
self._set_status("NEUER TRACK", GREEN)
|
|||
|
|
else:
|
|||
|
|
self._silence_start = None
|
|||
|
|
|
|||
|
|
def _handle_track_change(self, new_title):
|
|||
|
|
sep = self.platform_cfg.get("sep", " - ")
|
|||
|
|
parts = new_title.split(sep, 1)
|
|||
|
|
new_artist, new_song = parts[0].strip(), parts[1].strip()
|
|||
|
|
|
|||
|
|
key = self._song_key(new_artist, new_song)
|
|||
|
|
if key in self.recorded_songs:
|
|||
|
|
with self._lock:
|
|||
|
|
self.recorder.harvest_frames()
|
|||
|
|
self.current_track = None
|
|||
|
|
self.artist_lbl.configure(text=new_artist)
|
|||
|
|
self.title_lbl.configure(text=f"\u2714 {new_song}")
|
|||
|
|
self.tnum_lbl.configure(text="BEREITS AUFGENOMMEN")
|
|||
|
|
self._set_status("\u23ed WARTE AUF NEUEN SONG", ORANGE)
|
|||
|
|
self.rec_start = time.time()
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
new_track = {"artist": new_artist, "title": new_song}
|
|||
|
|
with self._lock:
|
|||
|
|
frames = self.recorder.harvest_frames()
|
|||
|
|
if frames and self.current_track and self.track_number > 0:
|
|||
|
|
num = self.track_number
|
|||
|
|
trk = dict(self.current_track)
|
|||
|
|
threading.Thread(
|
|||
|
|
target=self._save, args=(frames, trk, num), daemon=True
|
|||
|
|
).start()
|
|||
|
|
self.track_number += 1
|
|||
|
|
self.current_track = new_track
|
|||
|
|
self.rec_start = time.time()
|
|||
|
|
|
|||
|
|
self._update_track_ui()
|
|||
|
|
self._set_status("AUFNAHME", GREEN)
|
|||
|
|
|
|||
|
|
# ── duplicate detection ─────────────────────────────────────
|
|||
|
|
|
|||
|
|
@staticmethod
|
|||
|
|
def _song_key(artist, title):
|
|||
|
|
return f"{artist}\n{title}".lower().strip()
|
|||
|
|
|
|||
|
|
def _scan_existing_songs(self):
|
|||
|
|
"""Scan session directory for already-recorded songs via ID3 tags."""
|
|||
|
|
found = set()
|
|||
|
|
if not self.session_dir or not os.path.isdir(self.session_dir):
|
|||
|
|
return found
|
|||
|
|
for f in os.listdir(self.session_dir):
|
|||
|
|
if not f.lower().endswith(".mp3"):
|
|||
|
|
continue
|
|||
|
|
try:
|
|||
|
|
tags = mutagen.File(os.path.join(self.session_dir, f), easy=True)
|
|||
|
|
if tags:
|
|||
|
|
artist = (tags.get("artist") or [""])[0]
|
|||
|
|
title = (tags.get("title") or [""])[0]
|
|||
|
|
if artist or title:
|
|||
|
|
found.add(self._song_key(artist, title))
|
|||
|
|
continue
|
|||
|
|
except Exception:
|
|||
|
|
pass
|
|||
|
|
name = f[:-4]
|
|||
|
|
parts = name.split(" - ", 2)
|
|||
|
|
if len(parts) >= 3:
|
|||
|
|
found.add(self._song_key(parts[1], parts[2]))
|
|||
|
|
return found
|
|||
|
|
|
|||
|
|
def _get_max_track_num(self):
|
|||
|
|
"""Find the highest track number in session_dir via ID3 tags."""
|
|||
|
|
max_num = 0
|
|||
|
|
if not self.session_dir or not os.path.isdir(self.session_dir):
|
|||
|
|
return max_num
|
|||
|
|
for f in os.listdir(self.session_dir):
|
|||
|
|
if not f.lower().endswith(".mp3"):
|
|||
|
|
continue
|
|||
|
|
try:
|
|||
|
|
tags = mutagen.File(os.path.join(self.session_dir, f), easy=True)
|
|||
|
|
if tags:
|
|||
|
|
trk = (tags.get("tracknumber") or ["0"])[0]
|
|||
|
|
max_num = max(max_num, int(trk.split("/")[0]))
|
|||
|
|
continue
|
|||
|
|
except Exception:
|
|||
|
|
pass
|
|||
|
|
parts = f[:-4].split(" - ", 2)
|
|||
|
|
if parts:
|
|||
|
|
try:
|
|||
|
|
max_num = max(max_num, int(parts[0]))
|
|||
|
|
except ValueError:
|
|||
|
|
pass
|
|||
|
|
return max_num
|
|||
|
|
|
|||
|
|
# ── save ───────────────────────────────────────────────────
|
|||
|
|
|
|||
|
|
def _save(self, frames, track, number):
|
|||
|
|
artist = track.get("artist", "")
|
|||
|
|
title = track.get("title", "")
|
|||
|
|
if not artist and not title:
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
safe = self._fn_format.format(
|
|||
|
|
nr=f"{number:02d}", artist=artist or "Unbekannt",
|
|||
|
|
titel=title or "Unbekannt")
|
|||
|
|
for ch in '<>:"/\\|?*':
|
|||
|
|
safe = safe.replace(ch, "_")
|
|||
|
|
|
|||
|
|
path = os.path.join(self.session_dir, f"{safe}.mp3")
|
|||
|
|
n = 1
|
|||
|
|
base = path[:-4]
|
|||
|
|
while os.path.exists(path):
|
|||
|
|
path = f"{base} ({n}).mp3"
|
|||
|
|
n += 1
|
|||
|
|
|
|||
|
|
ok = self.recorder.save_mp3(
|
|||
|
|
frames, path, title=title, artist=artist,
|
|||
|
|
bitrate=self.bitrate, album=self.playlist_name,
|
|||
|
|
track_num=number,
|
|||
|
|
)
|
|||
|
|
if ok:
|
|||
|
|
self.recorded_songs.add(self._song_key(artist, title))
|
|||
|
|
name = os.path.basename(path)
|
|||
|
|
self.songs.append(name)
|
|||
|
|
self.root.after(0, lambda: self._add_song(name))
|
|||
|
|
self.root.after(0, self._refresh_total_stats)
|
|||
|
|
|
|||
|
|
def _add_song(self, name):
|
|||
|
|
self.song_box.configure(state="normal")
|
|||
|
|
self.song_box.insert("end", f"\u2713 {name}\n")
|
|||
|
|
self.song_box.see("end")
|
|||
|
|
self.song_box.configure(state="disabled")
|
|||
|
|
if self.playlist_total > 0:
|
|||
|
|
self.cnt_lbl.configure(
|
|||
|
|
text=f"{self.track_number} / {self.playlist_total} Songs")
|
|||
|
|
else:
|
|||
|
|
self.cnt_lbl.configure(text=f"{len(self.songs)} Songs")
|
|||
|
|
|
|||
|
|
# ── sleep prevention ───────────────────────────────────────
|
|||
|
|
|
|||
|
|
@staticmethod
|
|||
|
|
def _prevent_sleep():
|
|||
|
|
kernel32.SetThreadExecutionState(
|
|||
|
|
ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_AWAYMODE_REQUIRED)
|
|||
|
|
|
|||
|
|
@staticmethod
|
|||
|
|
def _allow_sleep():
|
|||
|
|
kernel32.SetThreadExecutionState(ES_CONTINUOUS)
|
|||
|
|
|
|||
|
|
# ── UI helpers ─────────────────────────────────────────────
|
|||
|
|
|
|||
|
|
def _update_track_ui(self):
|
|||
|
|
if self.current_track:
|
|||
|
|
self.artist_lbl.configure(text=self.current_track["artist"])
|
|||
|
|
self.title_lbl.configure(text=self.current_track["title"])
|
|||
|
|
if self.playlist_total > 0:
|
|||
|
|
self.tnum_lbl.configure(
|
|||
|
|
text=f"TRACK #{self.track_number:02d}"
|
|||
|
|
f" / {self.playlist_total}")
|
|||
|
|
else:
|
|||
|
|
self.tnum_lbl.configure(
|
|||
|
|
text=f"TRACK #{self.track_number:02d}")
|
|||
|
|
|
|||
|
|
def _set_status(self, text, color):
|
|||
|
|
self.stat_lbl.configure(text=text, text_color=color)
|
|||
|
|
self.dot_lbl.configure(text_color=color)
|
|||
|
|
|
|||
|
|
def _tick_timer(self):
|
|||
|
|
if self.active and self.rec_start:
|
|||
|
|
s = int(time.time() - self.rec_start)
|
|||
|
|
m, s = divmod(s, 60)
|
|||
|
|
self.time_lbl.configure(text=f"{m:02d}:{s:02d}", text_color=GREEN)
|
|||
|
|
elif not self.active:
|
|||
|
|
self.time_lbl.configure(text="", text_color=DIM)
|
|||
|
|
self.root.after(500, self._tick_timer)
|
|||
|
|
|
|||
|
|
def _tick_level(self):
|
|||
|
|
if self.active:
|
|||
|
|
lvl = self.recorder.get_level()
|
|||
|
|
smooth = self.level_bar.get() * 0.35 + lvl * 0.65
|
|||
|
|
self.level_bar.set(smooth)
|
|||
|
|
self.level_bar.configure(
|
|||
|
|
progress_color=RED if lvl > 0.85 else GREEN)
|
|||
|
|
else:
|
|||
|
|
cur = self.level_bar.get()
|
|||
|
|
if cur > 0.01:
|
|||
|
|
self.level_bar.set(cur * 0.5)
|
|||
|
|
else:
|
|||
|
|
self.level_bar.set(0)
|
|||
|
|
self.root.after(80, self._tick_level)
|
|||
|
|
|
|||
|
|
def _tick_pulse(self):
|
|||
|
|
if self.active:
|
|||
|
|
self._pulse_on = not self._pulse_on
|
|||
|
|
self.dot_lbl.configure(
|
|||
|
|
text_color=GREEN if self._pulse_on else "#3E4D1E")
|
|||
|
|
self.root.after(650, self._tick_pulse)
|
|||
|
|
|
|||
|
|
def _tick_alive(self):
|
|||
|
|
proc = self.platform_cfg.get("process")
|
|||
|
|
if self.spotify_hwnd:
|
|||
|
|
if user32.IsWindow(self.spotify_hwnd):
|
|||
|
|
self._alive_fails = 0
|
|||
|
|
else:
|
|||
|
|
self._alive_fails += 1
|
|||
|
|
new_hwnd = find_app_window(proc) if proc else None
|
|||
|
|
if new_hwnd:
|
|||
|
|
self.spotify_hwnd = new_hwnd
|
|||
|
|
self._alive_fails = 0
|
|||
|
|
else:
|
|||
|
|
not_done = (self.playlist_total > 0
|
|||
|
|
and self.track_number < self.playlist_total)
|
|||
|
|
threshold = 10 if not_done else 4
|
|||
|
|
if self._alive_fails >= threshold:
|
|||
|
|
self.spotify_hwnd = None
|
|||
|
|
self._update_sp_status(False)
|
|||
|
|
name = self.platform_name
|
|||
|
|
self.embed_msg.configure(
|
|||
|
|
text=f"\u26a0 {name} wurde geschlossen.\n\n"
|
|||
|
|
f"Starte {name} neu und\n"
|
|||
|
|
"starte die App erneut.")
|
|||
|
|
self.embed_msg.place(relx=0.5, rely=0.5,
|
|||
|
|
anchor="center")
|
|||
|
|
if self.active:
|
|||
|
|
self._stop()
|
|||
|
|
|
|||
|
|
if self.active and self.recorder._stream:
|
|||
|
|
try:
|
|||
|
|
if not self.recorder._stream.is_active():
|
|||
|
|
self.recorder.stop()
|
|||
|
|
try:
|
|||
|
|
self.recorder.start()
|
|||
|
|
self._prevent_sleep()
|
|||
|
|
except Exception:
|
|||
|
|
self._stop()
|
|||
|
|
except Exception:
|
|||
|
|
pass
|
|||
|
|
|
|||
|
|
self.root.after(3000, self._tick_alive)
|
|||
|
|
|
|||
|
|
# ── statistics ─────────────────────────────────────────────
|
|||
|
|
|
|||
|
|
def _count_total_mp3s(self):
|
|||
|
|
"""Count all MP3 files recursively in output_base."""
|
|||
|
|
total = 0
|
|||
|
|
for root, _dirs, files in os.walk(self.output_base):
|
|||
|
|
for f in files:
|
|||
|
|
if f.lower().endswith(".mp3"):
|
|||
|
|
total += 1
|
|||
|
|
return total
|
|||
|
|
|
|||
|
|
def _refresh_total_stats(self):
|
|||
|
|
n = self._count_total_mp3s()
|
|||
|
|
folders = 0
|
|||
|
|
try:
|
|||
|
|
for entry in os.scandir(self.output_base):
|
|||
|
|
if entry.is_dir():
|
|||
|
|
folders += 1
|
|||
|
|
except OSError:
|
|||
|
|
pass
|
|||
|
|
self.total_lbl.configure(
|
|||
|
|
text=f"\U0001f4ca Gesamt: {n} Songs in {folders} Playlists")
|
|||
|
|
|
|||
|
|
# ── settings ───────────────────────────────────────────────
|
|||
|
|
|
|||
|
|
def _choose_folder(self):
|
|||
|
|
init = self._custom_folder or self.output_base
|
|||
|
|
p = filedialog.askdirectory(initialdir=init)
|
|||
|
|
if not p:
|
|||
|
|
return
|
|||
|
|
if self._folder_mode == "custom":
|
|||
|
|
self._custom_folder = p
|
|||
|
|
else:
|
|||
|
|
self.output_base = p
|
|||
|
|
self._lbl_set(self.folder_lbl, p)
|
|||
|
|
self._lbl_set(self.top_folder_lbl, p)
|
|||
|
|
self._refresh_total_stats()
|
|||
|
|
|
|||
|
|
def _open_folder(self):
|
|||
|
|
if self._folder_mode == "custom" and self._custom_folder:
|
|||
|
|
folder = self._custom_folder
|
|||
|
|
elif self.session_dir and os.path.isdir(self.session_dir):
|
|||
|
|
folder = self.session_dir
|
|||
|
|
else:
|
|||
|
|
folder = self.output_base
|
|||
|
|
os.startfile(folder)
|
|||
|
|
|
|||
|
|
def _set_bitrate(self, val):
|
|||
|
|
self.bitrate = int(val.split()[0])
|
|||
|
|
|
|||
|
|
def _set_auto_stop(self, val):
|
|||
|
|
if val == "Aus":
|
|||
|
|
self.auto_stop_secs = 0
|
|||
|
|
else:
|
|||
|
|
self.auto_stop_secs = int(val.split()[0])
|
|||
|
|
|
|||
|
|
# ── cleanup ────────────────────────────────────────────────
|
|||
|
|
|
|||
|
|
def _on_close(self):
|
|||
|
|
if not self._app_initialized:
|
|||
|
|
self.root.destroy()
|
|||
|
|
return
|
|||
|
|
self._user_stopped = True
|
|||
|
|
if self._restart_after_id:
|
|||
|
|
self.root.after_cancel(self._restart_after_id)
|
|||
|
|
self._restart_after_id = None
|
|||
|
|
if self.active:
|
|||
|
|
self._stop()
|
|||
|
|
self._allow_sleep()
|
|||
|
|
self._restore_spotify()
|
|||
|
|
self.recorder.cleanup()
|
|||
|
|
self.root.destroy()
|
|||
|
|
|
|||
|
|
def run(self):
|
|||
|
|
self.root.mainloop()
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ═══════════════════════════════════════════════════════════════
|
|||
|
|
# Entry point
|
|||
|
|
# ═══════════════════════════════════════════════════════════════
|
|||
|
|
|
|||
|
|
def main():
|
|||
|
|
app = SpotifyRecorderApp()
|
|||
|
|
app.run()
|
|||
|
|
|
|||
|
|
|
|||
|
|
if __name__ == "__main__":
|
|||
|
|
try:
|
|||
|
|
main()
|
|||
|
|
except Exception:
|
|||
|
|
import tkinter as _tk
|
|||
|
|
from tkinter import messagebox as _mb
|
|||
|
|
_r = _tk.Tk()
|
|||
|
|
_r.withdraw()
|
|||
|
|
_mb.showerror(
|
|||
|
|
"Surovy's Music Recorder",
|
|||
|
|
f"Fehler:\n\n{traceback.format_exc()}\n\n"
|
|||
|
|
f"pip install -r requirements.txt",
|
|||
|
|
)
|
|||
|
|
_r.destroy()
|
|||
|
|
sys.exit(1)
|