alarm_timer_2.pyw

import tkinter as tk
from tkinter import ttk
from tkinter import messagebox
import threading
import time

class TimerApp:
    def __init__(self, root):
        self.duration = 0
        self.start_time = 0

        self.root = root
        self.root.title("Timer-Control")
        # get the screen dimension
        window_width = 300
        window_height = 200
        screen_width = root.winfo_screenwidth()
        screen_height = root.winfo_screenheight()
        # find the center point
        center_x = int(screen_width/2 - window_width / 2)
        center_y = int(screen_height/2 - window_height / 2)
        self.root.geometry(f'{window_width}x{window_height}+{center_x}+{center_y}')

        self.timer_thread = None
        self.stop_event = threading.Event()

        
        self.label = tk.Label(root, text="Timer (Minuten):")
        self.label.pack(pady=5)

        # Eingabefeld
        self.entry_frame = tk.Frame(root)
        self.entry_frame.pack(pady=5)
        
        self.decrease_btn = tk.Button(self.entry_frame, text="−", width=3, command=lambda: self.adjust_time(-5))
        self.decrease_btn.pack(side="left", padx=5)

        self.entry = tk.Entry(self.entry_frame, width=5, justify="center")
        self.entry.insert(tk.END, '45')
        self.entry.pack(side="left")

        self.increase_btn = tk.Button(self.entry_frame, text="+", width=3, command=lambda: self.adjust_time(5))
        self.increase_btn.pack(side="left", padx=5)

        self.entry.focus_set()
        self.entry.bind("<FocusIn>", self.select_all)
        self.entry.bind("<Return>", lambda event: self.start_timer()) # enter button starts timer

        # Start-Button
        self.start_btn = tk.Button(root, text="Start", command=self.start_timer)
        self.start_btn.pack(pady=5)

        # Stopp-Button
        self.stop_btn = tk.Button(root, text="Stop", command=self.stop_timer)
        self.stop_btn.pack(pady=5)

        # Progress bar
        self.progress_frame = tk.Frame(root)
        self.progress_frame.pack(pady=10)

        self.progress = ttk.Progressbar(
            self.progress_frame,
            orient="horizontal",
            length=250,
            mode="determinate"
        )
        self.progress.pack()

        # Countdown label over the progress bar
        self.time_label = tk.Label(
            self.progress_frame,
            text="00:00",
            font=("Arial", 12, "bold"),
            background="#f0f0f0"  # match default ttk bg
        )
        self.time_label.place(relx=0.5, rely=0.5, anchor="center")
    

    ### UI LOGIC ###

    def adjust_time(self, delta):
        try:
            value = float(self.entry.get())
        except ValueError:
            value = 0

        value = max(0, value + delta)  # prevent negative values

        self.entry.delete(0, tk.END)
        self.entry.insert(0, f"{value:g}")
        self.entry.select_range(0, tk.END)

    def select_all(self, event):
        self.entry.after(1, lambda: self.entry.select_range(0, tk.END))

    ### TIMER LOGIC ###

    def timer_task(self, duration):
        print(f"[Thread] Timer gestartet für {duration} Sekunden")
        start = time.time()
        while time.time() - start < duration:
            if self.stop_event.is_set():
                print("[Thread] Timer gestoppt")
                return
            time.sleep(0.1)

        print("[Thread] Timer fertig – Alarm!")
        self.show_alarm_window()

    def start_timer(self):
        if self.timer_thread and self.timer_thread.is_alive():
            messagebox.showwarning("Läuft schon", "Ein Timer läuft bereits!")
            return

        try:
            self.duration = float(self.entry.get()) * 60 # in Minuten umwandeln
        except ValueError:
            messagebox.showerror("Ungültige Eingabe", "Bitte eine Zahl eingeben.")
            return

        self.stop_event.clear()
        self.progress["value"] = 0
        self.progress["maximum"] = self.duration
        self.start_time = time.time()

        self.timer_thread = threading.Thread(target=self.timer_task, args=(self.duration,),daemon=True)
        self.timer_thread.start()

        self.update_progress() # start UI updates
        self.update_time_label(self.duration)

    def stop_timer(self):
        self.stop_event.set()
        self.progress["value"] = 0
        self.time_label.config(text="00:00")

    def update_progress(self):
        if self.stop_event.is_set():
            self.progress["value"] = 0
            self.time_label.config(text="00:00")
            return

        elapsed = int(time.time() - self.start_time)
        remaining = max(0, self.duration - elapsed)

        self.progress["value"] = min(elapsed, self.duration)
        self.update_time_label(remaining)

        if elapsed < self.duration:
            self.root.after(1000, self.update_progress)

    def update_time_label(self, seconds):
        minutes = int(seconds) // 60
        secs = int(seconds) % 60
        self.time_label.config(text=f"{minutes:02d}:{secs:02d}")

    def show_alarm_window(self):
        alarm = tk.Toplevel(self.root)
        #alarm.attributes("-fullscreen", True)
        alarm.state('zoomed')
        alarm.attributes("-topmost", True)
        alarm.configure(bg="red")
        label = tk.Label(alarm, text="ZEIT IST UM!", font=("Arial", 80), fg="white", bg="red")
        label.pack(expand=True)
        exit_button = tk.Button(alarm, text="Schließen", command=alarm.destroy, height = 25, width = 80)
        exit_button.pack(pady=20)
        alarm.bind("<Escape>", lambda e: alarm.destroy())  # ESC zum Schließen

if __name__ == "__main__":
    root = tk.Tk()
    app = TimerApp(root)
    root.mainloop()