677 lines
28 KiB
Python
677 lines
28 KiB
Python
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
|
||
from export import exportiere_txt, exportiere_excel
|
||
from integra_lookup import finde_integra_nummern
|
||
from config import LOGO_PATH, DATUM_FORMAT
|
||
import config
|
||
|
||
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("<Return>", 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 TXT
|
||
wrap4 = tk.Frame(actions, highlightthickness=3, highlightbackground="black", bd=0)
|
||
wrap4.pack(side="right", padx=2, pady=2)
|
||
ttk.Button(
|
||
wrap4,
|
||
text="Export TXT",
|
||
command=lambda: self._with_busy(lambda: exportiere_txt(self.vorgaenge, self.berechne_dauer_min), toast="TXT exportiert")
|
||
).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)
|
||
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("<FocusOut>", lambda e: _on_nummer_change())
|
||
e_nummer.bind("<KeyRelease>", 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}")
|
||
|
||
|