import os import tkinter as tk import tkinter.ttk as ttk from tkinter import messagebox, simpledialog from datetime import datetime from PIL import Image, ImageTk from storage import lade_daten, speichere_daten, reset_daten, lade_einstellungen, speichere_einstellungen from export import exportiere_excel from integra_lookup import finde_integra_nummern from config import LOGO_PATH, DATUM_FORMAT import config #Before from export import exportiere_txt, exportiere_excel class ZeitErfassungApp: # ---------------------- Optionen / Einstellungen ---------------------- def _set_excel_path(self): from tkinter import filedialog pfad = filedialog.askopenfilename( title="Bearbeitungs-Excel wählen", filetypes=[ ("Excel", "*.xlsx *.xlsm *.xlsb *.xls"), ("Alle Dateien", "*.*") ], ) if pfad: config.set_server_excel(pfad) messagebox.showinfo("Gespeichert", f"Pfad gespeichert:\n{config.SERVER_EXCEL}") # --------------------------- Konstruktor ------------------------------ def __init__(self, root: tk.Tk): self.root = root self.root.title("Zeiterfassung MERZ") self.root.geometry("900x560") # Fenstericon setzen (ICO bevorzugt, PNG geht auf manchen Systemen auch) try: icon_path = LOGO_PATH if icon_path.lower().endswith(".ico"): self.root.iconbitmap(icon_path) else: img = Image.open(icon_path) icon_img = ImageTk.PhotoImage(img) self.root.iconphoto(True, icon_img) self._icon_ref = icon_img except Exception as e: print(f"Fenstericon konnte nicht gesetzt werden: {e}") # Daten self.vorgaenge = lade_daten() # Grundfarben (helle Palette) self.bg_color = "#F5F5F7" self.fg_color = "#1D1D1F" self.root.configure(bg=self.bg_color) # UI aufbauen self._build_gui() self._build_menu() self._create_busy_overlay() self.aktualisiere_liste() # ↵ Enter startet den Vorgang self.root.bind("", lambda e: self.start_vorgang()) # --------------------------- Apple-Style ------------------------------ def _apply_apple_style(self): self.bg = "#F5F5F7" # Fensterhintergrund self.card = "#FFFFFF" # Karten/Flächen self.border = "#E5E5EA" self.text = "#1D1D1F" self.subtext = "#3A3A3C" self.blue = "#0A84FF" # Akzent self.blue_hover = "#147CFF" self.blue_pressed = "#0068DA" self.neutral_hover = "#F2F2F7" style = ttk.Style() style.theme_use("default") # Globale Schrift style.configure(".", background=self.bg, foreground=self.text, font=("Segoe UI", 11)) # Karten / Toolbar style.configure("Card.TFrame", background=self.card, borderwidth=1, relief="solid") style.configure("Toolbar.TFrame", background=self.bg) # Labels style.configure("TLabel", background=self.bg, foreground=self.text, font=("Segoe UI", 11)) style.configure("Title.TLabel", background=self.bg, foreground=self.text, font=("Segoe UI", 16, "bold")) style.configure("Secondary.TLabel", background=self.bg, foreground=self.subtext) # Entry style.configure("TEntry", fieldbackground=self.card, background=self.card, foreground=self.text) # Neutraler Button style.configure("TButton", background=self.card, foreground=self.text, padding=(12, 8), borderwidth=1, relief="flat") style.map("TButton", background=[("active", self.neutral_hover)], relief=[("pressed", "sunken")]) # Primär-Button (sichtbarere States) style.configure("Accent.TButton", background=self.blue, foreground="#FFFFFF", padding=(14, 9), borderwidth=0, relief="flat") style.map("Accent.TButton", background=[("active", self.blue_hover), ("pressed", self.blue_pressed)]) # Danger-Button (optional nutzbar) style.configure("Danger.TButton", background="#FF3B30", foreground="white", padding=(12, 8), borderwidth=0, relief="flat") style.map("Danger.TButton", background=[("active", "#FF554D"), ("pressed", "#D92A21")]) # Progressbar style.configure("Thin.Horizontal.TProgressbar", troughcolor=self.card, background=self.blue) # 👉 Treeview-Header fett style.configure("Treeview.Heading", font=("Segoe UI", 11, "bold")) # ---------------------------- GUI-Aufbau ------------------------------ def _build_gui(self): self._apply_apple_style() # Toolbar oben toolbar = ttk.Frame(self.root, style="Toolbar.TFrame") toolbar.pack(fill="x", padx=12, pady=(8, 12)) # Logo + Titel try: logo_img = Image.open(LOGO_PATH).resize((32, 32), Image.LANCZOS) self.logo = ImageTk.PhotoImage(logo_img) ttk.Label(toolbar, image=self.logo, style="TLabel").pack(side="left", padx=(0, 8)) except Exception: pass ttk.Label(toolbar, text="Zeiterfassung", style="Title.TLabel").pack(side="left") ttk.Label(toolbar, text="", style="TLabel").pack(side="left", expand=True) # Spacer # Hauptkarte main_card = ttk.Frame(self.root, style="Card.TFrame") main_card.pack(fill="both", expand=True, padx=12, pady=(0, 12)) # ---------------- Eingabebereich mit schwarzem Rahmen ---------------- input_wrap = tk.Frame(main_card, bg=self.card, highlightthickness=3, highlightbackground="#000000") input_wrap.pack(fill="x", padx=12, pady=(12, 8)) inner = tk.Frame(input_wrap, bg=self.card) inner.pack(fill="x", padx=10, pady=8) inner.grid_columnconfigure(0, weight=0) inner.grid_columnconfigure(1, weight=1) inner.grid_columnconfigure(2, weight=0) # Grid: Label | Entry (dehnbar) | Start-Button inner.grid_columnconfigure(0, weight=0) inner.grid_columnconfigure(1, weight=1) inner.grid_columnconfigure(2, weight=0) self.maschinennummer = tk.StringVar() ttk.Label(inner, text="Maschinennummer:").grid(row=0, column=0, sticky="w", padx=(0, 10)) self.entry = ttk.Entry(inner, textvariable=self.maschinennummer) self.entry.grid(row=0, column=1, sticky="ew") # füllt bis rechts self.entry.focus_set() self.start_button_inline = ttk.Button(inner, text="Start", command=self.start_vorgang, style="Accent.TButton") self.start_button_inline.grid(row=0, column=2, sticky="e", padx=(10, 0)) # ---------------- Liste + Scrollbar (Treeview mit Spalten & Trennlinien) ---------------- list_wrap = tk.Frame(main_card, bg=self.card, highlightthickness=3, highlightbackground="black") list_wrap.pack(fill="both", expand=True, padx=12, pady=(0, 12)) # Kopfzeile (lassen wir zur Optik drin – kann aber weg, weil Treeview auch Headings hat) header = tk.Frame(list_wrap, bg=self.card) header.pack(fill="x", padx=8, pady=(8, 0)) header.grid_columnconfigure(0, weight=12) header.grid_columnconfigure(1, weight=10) header.grid_columnconfigure(2, weight=18) header.grid_columnconfigure(3, weight=18) header.grid_columnconfigure(4, weight=8) header.grid_columnconfigure(5, weight=34) # Treeview (eigentliche Tabelle) list_frame = tk.Frame(list_wrap, bg=self.card) list_frame.pack(fill="both", expand=True, padx=8, pady=(0, 8)) cols = ("maschine", "bearb", "start", "stopp", "dauer", "kommentar") self.tree = ttk.Treeview(list_frame, columns=cols, show="headings", selectmode="browse") self.tree.pack(side="left", fill="both", expand=True) # Spaltenüberschriften + Breiten self.tree.heading("maschine", text="Maschine") self.tree.heading("bearb", text="Bearb.-Nr.") self.tree.heading("start", text="Start") self.tree.heading("stopp", text="Stopp") self.tree.heading("dauer", text="Dauer") self.tree.heading("kommentar",text="Kommentar") # Breiten/Stretch – passe nach Geschmack an self.tree.column("maschine", width=120, anchor="w", stretch=True) self.tree.column("bearb", width=100, anchor="w", stretch=True) self.tree.column("start", width=160, anchor="w", stretch=True) self.tree.column("stopp", width=160, anchor="w", stretch=True) self.tree.column("dauer", width=80, anchor="w", stretch=False) self.tree.column("kommentar", width=280, anchor="w", stretch=True) # Scrollbar scrollbar = ttk.Scrollbar(list_frame, orient="vertical", command=self.tree.yview) scrollbar.pack(side="right", fill="y") self.tree.configure(yscrollcommand=scrollbar.set) # (optional) etwas Zeilenhöhe ttk.Style().configure("Treeview", rowheight=24) # ---------------- Aktionsleiste unten ---------------- actions = ttk.Frame(main_card, style="Toolbar.TFrame") actions.pack(fill="x", padx=12, pady=(0, 12)) # Stop mit Kommentar wrap1 = tk.Frame(actions, highlightthickness=3, highlightbackground="black", bd=0) wrap1.pack(side="left", padx=2, pady=2) ttk.Button(wrap1, text="Stop mit Kommentar", command=self.stoppe_auswahl).pack() # Auswahl löschen wrap2 = tk.Frame(actions, highlightthickness=3, highlightbackground="black", bd=0) wrap2.pack(side="left", padx=2, pady=2) ttk.Button(wrap2, text="Auswahl löschen", command=self.loesche_auswahl).pack() # Alles zurücksetzen wrap3 = tk.Frame(actions, highlightthickness=3, highlightbackground="black", bd=0) wrap3.pack(side="left", padx=2, pady=2) ttk.Button(wrap3, text="Alles zurücksetzen", command=self.reset, style="Danger.TButton").pack() # Export Excel wrap5 = tk.Frame(actions, highlightthickness=3, highlightbackground="black", bd=0) wrap5.pack(side="right", padx=2, pady=2) ttk.Button( wrap5, text="Export Excel", command=lambda: self._with_busy(lambda: exportiere_excel(self.vorgaenge, self.berechne_dauer_min), toast="Excel exportiert") ).pack() # ------------------------------ Menü --------------------------------- def _build_menu(self): menubar = tk.Menu(self.root) # Optionen optionen_menu = tk.Menu(menubar, tearoff=0) darstellung_menu = tk.Menu(optionen_menu, tearoff=0) optionen_menu.add_command(label="Bearbeitungs-Excel festlegen…", command=self._set_excel_path) optionen_menu.add_command(label="Ausgewählten Eintrag bearbeiten…", command=self._open_edit_dialog) optionen_menu.add_command(label="Personalnummer festlegen",command=self.optionen_dialog) #hier kommt der Befehl hin, wo man die Personalnummer eingeben kann! menubar.add_cascade(label="Optionen", menu=optionen_menu) # Bearbeiten bearbeiten_menu = tk.Menu(menubar, tearoff=0) bearbeiten_menu.add_command(label="Bearbeitungstabelle öffnen", command=self.oeffne_excel_datei) menubar.add_cascade(label="Bearbeiten", menu=bearbeiten_menu) self.root.config(menu=menubar) # --------------------------- Busy/Toast UI ---------------------------- def _create_busy_overlay(self): # halbtransparente Überlagerung (vereinfachte Variante ohne echte Alpha) self._overlay = tk.Frame(self.root, bg="#000000") self._overlay.place_forget() inner = tk.Frame(self._overlay, bg=self.card, highlightthickness=1, highlightbackground=self.border) inner.place(relx=0.5, rely=0.5, anchor="center") inner.configure(padx=20, pady=14) lbl = tk.Label(inner, text="Bitte warten…", bg=self.card, fg=self.text, font=("Segoe UI", 11, "bold")) lbl.pack(pady=(0, 8)) self._pbar = ttk.Progressbar(inner, mode="indeterminate", length=240, style="Thin.Horizontal.TProgressbar") self._pbar.pack() # Toast (kleine Meldung unten rechts) self._toast = tk.Label(self.root, text="", bg="#222222", fg="white", font=("Segoe UI", 10), padx=10, pady=6) def _with_busy(self, func, toast: str | None = None): #Einfache Busy-Anzeige: Cursor auf 'Warte', Funktion ausführen, optional Toast. try: # Cursor auf 'busy' setzen self.root.config(cursor="watch") self.root.update_idletasks() func() if toast: # Kurze Erfolgsmeldung try: from tkinter import messagebox messagebox.showinfo("Info", toast) except Exception: pass except Exception as e: # Fehler anzeigen try: from tkinter import messagebox messagebox.showerror("Fehler", str(e)) except Exception: raise finally: # Cursor zurücksetzen self.root.config(cursor="") self.root.update_idletasks() def _append_vorgang(self, maschine: str, bearbeitungsnummer: str = ""): #Einen Vorgang anlegen, speichern und Liste aktualisieren. self.vorgaenge.append({ "nummer": maschine, "bearbeitungsnummer": bearbeitungsnummer or "", "start": datetime.now(), "stopp": None, "kommentar": "" }) speichere_daten(self.vorgaenge) self.aktualisiere_liste() # --------------------------- Aktionen/Logik --------------------------- def start_vorgang(self): nummer = self.maschinennummer.get().strip() if not nummer: messagebox.showerror("Fehler", "Bitte Maschinennummer eingeben.") return # INTEGRA-Suche bearb_num, fehler = finde_integra_nummern(nummer) # Fall A: Treffer -> Vorgang normal mit Bearbeitungsnummer anlegen if not fehler: self._append_vorgang(nummer, bearb_num) return # Fall B: Fehler mit Vorschlag: "Meintest du: XYZ?" if "Meintest du:" in fehler: vorschlag = fehler.split("Meintest du:")[-1].strip().rstrip("?") dialog = tk.Toplevel(self.root) dialog.title("INTEGRA-Suche") dialog.transient(self.root) dialog.grab_set() dialog.resizable(False, False) # Text msg = tk.Label(dialog, text=fehler, wraplength=380, justify="left") msg.pack(padx=16, pady=(16, 10)) # Buttons (mit schwarzer Umrandung wie in der App) btns = tk.Frame(dialog) btns.pack(pady=(0, 12)) def on_uebernehmen(): # Vorschlag ins Feld übernehmen und direkt nochmal starten self.maschinennummer.set(vorschlag) dialog.destroy() self.start_vorgang() def on_ok(): # Trotz Fehler mit ursprünglicher Eingabe starten (ohne Bearbeitungsnummer) dialog.destroy() self._append_vorgang(nummer, "") def on_abort(): # Nichts tun, nicht starten dialog.destroy() # Rahmen um die Buttons (3 px) wie bei dir: w1 = tk.Frame(btns, highlightthickness=0, highlightbackground="black", bd=0); w1.pack(side="left", padx=6) tk.Button(w1, text="Übernehmen", command=on_uebernehmen, width=12).pack() w2 = tk.Frame(btns, highlightthickness=0, highlightbackground="black", bd=0); w2.pack(side="left", padx=6) tk.Button(w2, text="OK", command=on_ok, width=10).pack() w3 = tk.Frame(btns, highlightthickness=0, highlightbackground="black", bd=0); w3.pack(side="left", padx=6) tk.Button(w3, text="Abbrechen", command=on_abort, width=12).pack() # Fenster halbwegs mittig über dem Hauptfenster platzieren dialog.update_idletasks() rw, rh = self.root.winfo_width(), self.root.winfo_height() rx, ry = self.root.winfo_rootx(), self.root.winfo_rooty() dw, dh = dialog.winfo_width(), dialog.winfo_height() dialog.geometry(f"+{rx + (rw-dw)//2}+{ry + (rh-dh)//2}") return # Fall C: Fehler ohne Vorschlag -> optional Hinweis, kein Start messagebox.showwarning("INTEGRA-Suche", fehler) # -> nichts anlegen def _get_selected_index(self) -> int | None: """Index der ausgewählten Zeile im Treeview, oder None.""" sel = self.tree.selection() if not sel: return None # wir verwenden die iids als String des Index (siehe aktualisiere_liste) return int(sel[0]) def stoppe_auswahl(self): idx = self._get_selected_index() if idx is None: messagebox.showwarning("Hinweis", "Bitte wähle einen Vorgang aus.") return vorgang = self.vorgaenge[idx] if vorgang.get("stopp"): messagebox.showinfo("Hinweis", "Dieser Vorgang wurde bereits gestoppt.") return benutzer_kommentar = simpledialog.askstring("Kommentar", "Kommentar zum Vorgang:") vorgang["stopp"] = datetime.now() if benutzer_kommentar: # Kommentar nur anhängen, Bearbeitungsnummer bleibt separat alt = vorgang.get("kommentar") or "" vorgang["kommentar"] = (alt + " " + benutzer_kommentar).strip() speichere_daten(self.vorgaenge) self.aktualisiere_liste() def loesche_auswahl(self): idx = self._get_selected_index() if idx is None: messagebox.showwarning("Hinweis", "Bitte wähle einen Vorgang aus.") return if messagebox.askyesno("Löschen", "Bist du sicher, dass du den ausgewählten Vorgang löschen willst?"): del self.vorgaenge[idx] speichere_daten(self.vorgaenge) self.aktualisiere_liste() messagebox.showinfo("Gelöscht", "Der ausgewählte Vorgang wurde gelöscht.") def reset(self): if messagebox.askyesno("Zurücksetzen", "Bist du sicher, dass du alle Daten löschen willst?"): self.vorgaenge.clear() self.maschinennummer.set("") reset_daten() self.aktualisiere_liste() messagebox.showinfo("Zurückgesetzt", "Alle Daten wurden gelöscht.") def oeffne_excel_datei(self): if not config.SERVER_EXCEL: messagebox.showerror("Fehler", "Kein Pfad zur Bearbeitungs-Excel gesetzt.\nOptionen → „Bearbeitungs-Excel festlegen…“") return if not os.path.exists(config.SERVER_EXCEL): messagebox.showerror("Fehler", f"Excel-Datei nicht gefunden:\n{config.SERVER_EXCEL}") return try: os.startfile(config.SERVER_EXCEL) # Windows except AttributeError: # Fallback für andere Systeme import subprocess, sys if sys.platform == "darwin": subprocess.call(["open", config.SERVER_EXCEL]) else: subprocess.call(["xdg-open", config.SERVER_EXCEL]) # ------------------------- Anzeige / Darstellung ---------------------- def berechne_dauer_min(self, start: datetime, stopp: datetime) -> float: return round((stopp - start).total_seconds() / 60, 2) def aktualisiere_liste(self): # Tabelle leeren for iid in self.tree.get_children(): self.tree.delete(iid) # Einträge neu füllen – iid = Index, damit Auswahl ↔ Daten passt for i, v in enumerate(self.vorgaenge): start_str = v["start"].strftime(DATUM_FORMAT) if v["start"] else "" if v["stopp"]: stopp_str = v["stopp"].strftime(DATUM_FORMAT) dauer_str = f"{self.berechne_dauer_min(v['start'], v['stopp'])} Min" else: stopp_str = "Läuft..." dauer_str = "" bearb_nummer = v.get("bearbeitungsnummer", "") kommentar = v["kommentar"] if v["kommentar"] else "" values = (v["nummer"], bearb_nummer, start_str, stopp_str, dauer_str, kommentar) self.tree.insert("", "end", iid=str(i), values=values) # ------------------------------ Themes -------------------------------- def _open_theme_window(self): # Hinweis: Das Layout ist auf hell optimiert. Umschalten möglich, aber rein optisch. theme_window = tk.Toplevel(self.root) theme_window.title("Darstellung") theme_window.geometry("260x150") theme_window.configure(bg=self.bg_color) theme_var = tk.StringVar(value="light") # default: light def apply_theme(): val = theme_var.get() if val == "dark": messagebox.showinfo("Info", "Dark Mode ist aktuell nur eingeschränkt unterstützt (UI ist für hell optimiert).") theme_window.destroy() tk.Radiobutton( theme_window, text="Light (empfohlen)", variable=theme_var, value="light", bg=self.bg_color, fg=self.fg_color, selectcolor="#FFFFFF" ).pack(pady=(12, 4)) tk.Radiobutton( theme_window, text="Dark (experimentell)", variable=theme_var, value="dark", bg=self.bg_color, fg=self.fg_color, selectcolor="#FFFFFF" ).pack() ttk.Button(theme_window, text="Anwenden", command=apply_theme).pack(pady=12) def _get_selected_index(self) -> int | None: """Index der ausgewählten Zeile im Treeview, oder None.""" if hasattr(self, "tree"): sel = self.tree.selection() if not sel: return None return int(sel[0]) # iid = Index # Fallback, falls noch Listbox verwendet wird if hasattr(self, "listbox"): sel = self.listbox.curselection() if not sel: return None return int(sel[0]) return None def _fmt_dt(self, dt: datetime | None) -> str: return dt.strftime(DATUM_FORMAT) if dt else "" def _parse_dt(self, s: str) -> datetime | None: s = (s or "").strip() if not s: return None try: return datetime.strptime(s, DATUM_FORMAT) except Exception: # Toleranter: ISO versuchen try: return datetime.fromisoformat(s) except Exception: return None def _open_edit_dialog(self): idx = self._get_selected_index() if idx is None: messagebox.showwarning("Hinweis", "Bitte zuerst einen Vorgang auswählen.") return v = self.vorgaenge[idx] dlg = tk.Toplevel(self.root) dlg.title("Eintrag bearbeiten") dlg.transient(self.root) dlg.grab_set() dlg.resizable(False, False) # Grid-Layout frm = tk.Frame(dlg, bg=self.bg_color) frm.pack(fill="both", expand=True, padx=12, pady=12) for i in range(2): frm.grid_columnconfigure(i, weight=1) # Felder tk.Label(frm, text="Maschinennummer", bg=self.bg_color, fg=self.fg_color).grid(row=0, column=0, sticky="w", pady=(0,4)) e_nummer = ttk.Entry(frm) e_nummer.grid(row=0, column=1, sticky="ew", pady=(0,4)) e_nummer.insert(0, v.get("nummer","")) tk.Label(frm, text="Bearbeitungsnummer (auto)", bg=self.bg_color, fg=self.fg_color).grid(row=1, column=0, sticky="w", pady=(0,4)) e_bearb = ttk.Entry(frm, state="readonly") e_bearb.grid(row=1, column=1, sticky="ew", pady=(0,4)) # Anfangswert anzeigen bearb_var = tk.StringVar(value=v.get("bearbeitungsnummer","")) e_bearb.configure(textvariable=bearb_var) tk.Label(frm, text=f"Start ({DATUM_FORMAT})", bg=self.bg_color, fg=self.fg_color).grid(row=2, column=0, sticky="w", pady=(0,4)) e_start = ttk.Entry(frm) e_start.grid(row=2, column=1, sticky="ew", pady=(0,4)) e_start.insert(0, self._fmt_dt(v.get("start"))) tk.Label(frm, text=f"Stopp ({DATUM_FORMAT})", bg=self.bg_color, fg=self.fg_color).grid(row=3, column=0, sticky="w", pady=(0,4)) e_stopp = ttk.Entry(frm) e_stopp.grid(row=3, column=1, sticky="ew", pady=(0,4)) e_stopp.insert(0, self._fmt_dt(v.get("stopp"))) tk.Label(frm, text="Kommentar", bg=self.bg_color, fg=self.fg_color).grid(row=4, column=0, sticky="nw", pady=(0,4)) txt_komm = tk.Text(frm, height=4, wrap="word") txt_komm.grid(row=4, column=1, sticky="ew", pady=(0,4)) txt_komm.insert("1.0", v.get("kommentar","")) # Live: Wenn Maschinennummer geändert → INTEGRA neu suchen und Bearb.-Nr. aktualisieren def _on_nummer_change(*_): nummer = e_nummer.get().strip() if not nummer: bearb_var.set("") return try: bearb_num, fehler = finde_integra_nummern(nummer) if fehler: # wir zeigen den Fehler nicht als Popup, nur Feld leeren bearb_var.set("") else: bearb_var.set(bearb_num or "") except Exception: bearb_var.set("") e_nummer.bind("", lambda e: _on_nummer_change()) e_nummer.bind("", lambda e: (_on_nummer_change() if e.keysym not in ("Shift","Control","Alt") else None)) # Buttons (mit deinem schwarzen Rahmen) btns = tk.Frame(frm, bg=self.bg_color) btns.grid(row=5, column=0, columnspan=2, sticky="e", pady=(8,0)) def _save_and_close(): nummer = e_nummer.get().strip() if not nummer: messagebox.showerror("Fehler", "Maschinennummer darf nicht leer sein.") return start_dt = self._parse_dt(e_start.get()) if not start_dt: messagebox.showerror("Fehler", f"Start muss im Format {DATUM_FORMAT} vorliegen.") return stopp_dt = self._parse_dt(e_stopp.get()) if e_stopp.get().strip() and not stopp_dt: messagebox.showerror("Fehler", f"Stopp muss im Format {DATUM_FORMAT} vorliegen (oder leer lassen).") return if stopp_dt and stopp_dt < start_dt: messagebox.showerror("Fehler", "Stopp darf nicht vor Start liegen.") return kommentar = txt_komm.get("1.0","end").strip() # Bearbeitungsnummer nicht direkt editierbar, aber automatisch gesetzt: v["nummer"] = nummer v["start"] = start_dt v["stopp"] = stopp_dt v["kommentar"] = kommentar v["bearbeitungsnummer"] = bearb_var.get().strip() # auto speichere_daten(self.vorgaenge) self.aktualisiere_liste() dlg.destroy() def _cancel(): dlg.destroy() w1 = tk.Frame(btns, highlightthickness=3, highlightbackground="black", bd=0); w1.pack(side="right", padx=4) ttk.Button(w1, text="Speichern", command=_save_and_close).pack() w2 = tk.Frame(btns, highlightthickness=3, highlightbackground="black", bd=0); w2.pack(side="right", padx=4) ttk.Button(w2, text="Abbrechen", command=_cancel).pack() # Dialog mittig platzieren dlg.update_idletasks() rx, ry = self.root.winfo_rootx(), self.root.winfo_rooty() rw, rh = self.root.winfo_width(), self.root.winfo_height() dw, dh = dlg.winfo_width(), dlg.winfo_height() dlg.geometry(f"+{rx + (rw - dw)//2}+{ry + (rh - dh)//2}") #---------------------------------Personalnummer eingeben-------------------- def optionen_dialog(self): einstellungen = lade_einstellungen() win = tk.Toplevel(self.root) win.title("Optionen") win.geometry("350x220") win.resizable(False, False) frm = ttk.Frame(win, padding=10) frm.pack(fill="both", expand=True) # --- Personalnummer (NEU) --- ttk.Label(frm, text="Personalnummer:").grid(row=0, column=0, sticky="w") personalnummer_var = tk.StringVar(value=str(einstellungen.get("personalnummer", 56))) ttk.Entry(frm, textvariable=personalnummer_var, width=10).grid(row=0, column=1, sticky="w") # Weitere Optionen bleiben wie sie sind… def speichern(): # Validate Personalnummer try: pn = int(personalnummer_var.get()) except: pn = 56 einstellungen["personalnummer"] = pn speichere_einstellungen(einstellungen) win.destroy() ttk.Button(frm, text="Speichern", command=speichern).grid(row=99, column=0, pady=15) ttk.Button(frm, text="Abbrechen", command=win.destroy).grid(row=99, column=1, pady=15)