timers.pyw

import tkinter as tk
from tkinter import ttk, messagebox
import datetime
import os
import json
import re

# Файл для сохранения данных
DATA_FILE = "timers.json"

# Загрузка данных из файла
def load_data():
    if os.path.exists(DATA_FILE):
        with open(DATA_FILE, "r", encoding="utf-8") as file:
            return json.load(file)
    return {}

# Сохранение данных в файл
def save_data(data):
    with open(DATA_FILE, "w", encoding="utf-8") as file:
        json.dump(data, file, ensure_ascii=False, indent=4)

# Класс для управления таймером
class Timer:
    def __init__(self, timer_id, name, hours, minutes, seconds, start_time=None):
        self.timer_id = timer_id  # Уникальный ID таймера
        self.name = name
        self.total_seconds = hours * 3600 + minutes * 60 + seconds
        self.start_time = start_time
        self.remaining_seconds = self.total_seconds
        self.running = False

    def start(self):
        if not self.running:
            self.start_time = datetime.datetime.now()
            self.running = True
            self.update_ui_state()

    def stop(self):
        if self.running:
            self.running = False
            self.start_time = None  # Удаляем время старта
            self.remaining_seconds = self.total_seconds  # Сбрасываем на изначальное значение
            self.update_ui_state()

    def reset(self):
        self.remaining_seconds = self.total_seconds
        self.running = False
        self.start_time = None  # Удаляем время старта
        self.update_ui_state()

    def update(self):
        if self.running:
            elapsed = (datetime.datetime.now() - self.start_time).total_seconds()
            self.remaining_seconds = self.total_seconds - int(elapsed)
            if self.remaining_seconds <= 0:
                self.remaining_seconds = 0
                self.running = False
                self.show_notification()  # Показываем уведомление
        return self.remaining_seconds

    def show_notification(self):
        # Создаем новое окно для уведомления
        notification_window = tk.Toplevel()
        notification_window.title("Таймеры")
        notification_window.geometry("300x100")
        notification_window.attributes('-topmost', True)  # Окно всегда поверх других

        # Добавляем текст уведомления
        label = ttk.Label(notification_window, text=f"Таймер '{self.name}' завершён!")
        label.pack(pady=20)

        # Добавляем кнопку "ОК"
        ok_button = ttk.Button(notification_window, text="ОК", command=notification_window.destroy)
        ok_button.pack(pady=5)

        # Поднимаем окно уведомления на передний план
        notification_window.lift()
        notification_window.focus_force()

    def update_ui_state(self):
        if hasattr(self, 'hours_spinbox') and hasattr(self, 'minutes_spinbox') and hasattr(self, 'seconds_spinbox'):
            state = "disabled" if self.running else "enabled"
            self.hours_spinbox.config(state=state)
            self.minutes_spinbox.config(state=state)
            self.seconds_spinbox.config(state=state)
            if hasattr(self, 'name_entry'):
                self.name_entry.config(state=state)

# Основное окно приложения
class TimerApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Таймеры")
        self.timers = {}
        self.next_timer_id = 1  # Счётчик для уникальных ID таймеров

        # Стиль для ttk
        self.style = ttk.Style()
        self.style.configure("TButton", padding=1, font=("Arial", 9))
        self.style.configure("TEntry", padding=1, font=("Arial", 9))
        self.style.configure("TLabel", padding=1, font=("Arial", 9))

        # Кнопка для добавления нового таймера
        self.add_button = ttk.Button(root, text="Добавить таймер", command=self.add_timer)
        self.add_button.pack(pady=10)

        # Фрейм для отображения таймеров
        self.timers_frame = ttk.Frame(root)
        self.timers_frame.pack()

        # Загрузка таймеров из файла
        self.load_timers()

        # Сохранение данных при закрытии приложения
        self.root.protocol("WM_DELETE_WINDOW", self.on_close)

    # Загрузка таймеров из файла
    def load_timers(self):
        data = load_data()
        for timer_data in sorted(data.values(), key=lambda x: x["id"]):  # Сортируем по ID
            timer_id = timer_data["id"]
            name = timer_data["name"]
            hours, minutes, seconds = timer_data["time"]
            start_time = datetime.datetime.fromisoformat(timer_data["start_time"]) if timer_data["start_time"] else None
            timer = Timer(timer_id, name, hours, minutes, seconds, start_time)
            if start_time:
                elapsed = (datetime.datetime.now() - start_time).total_seconds()
                timer.remaining_seconds -= int(elapsed)
                if timer.remaining_seconds <= 0:
                    timer.remaining_seconds = 0
                    timer.running = False  # Таймер завершен
                    timer.show_notification()  # Показываем уведомление при загрузке
                else:
                    timer.running = True
            self.timers[timer_id] = timer
            self.display_timer(timer)
            self.next_timer_id = max(self.next_timer_id, timer_id + 1)  # Обновляем счётчик ID

    # Отображение таймера в интерфейсе
    def display_timer(self, timer):
        frame = ttk.Frame(self.timers_frame)
        frame.pack(pady=5)

        # Кнопка-крестик для удаления таймера
        delete_button = ttk.Button(frame, text="×", width=2, command=lambda: self.delete_timer(timer, frame))
        delete_button.pack(side=tk.LEFT, padx=5)

        # Поле для редактирования названия таймера
        name_var = tk.StringVar(value=timer.name)
        name_entry = ttk.Entry(frame, textvariable=name_var, width=25)
        name_entry.pack(side=tk.LEFT, padx=5)
        name_entry.bind("<FocusOut>", lambda e: self.update_timer_name(timer, name_var.get(), frame))

        # Разрешаем вставку по Ctrl+V
        name_entry.bind("<Control-v>", lambda e: name_entry.event_generate("<<Paste>>"))

        # Сохраняем ссылку на поле ввода имени в объекте таймера
        timer.name_entry = name_entry

        # Поля для редактирования времени (часы, минуты, секунды)
        time_frame = ttk.Frame(frame)
        time_frame.pack(side=tk.LEFT)

        # Валидация ввода (только цифры, максимум 2 символа)
        def validate_input(new_value):
            return re.match(r"^\d{0,2}$", new_value) is not None

        vcmd = (self.root.register(validate_input), "%P")

        hours_var = tk.IntVar(value=timer.total_seconds // 3600)
        minutes_var = tk.IntVar(value=(timer.total_seconds % 3600) // 60)
        seconds_var = tk.IntVar(value=timer.total_seconds % 60)

        # Поле для часов с кнопками вверх/вниз
        hours_spinbox = ttk.Spinbox(time_frame, from_=0, to=23, width=3, textvariable=hours_var, validate="key", validatecommand=vcmd)
        hours_spinbox.pack(side=tk.LEFT)
        ttk.Label(time_frame, text="ч").pack(side=tk.LEFT)

        # Поле для минут с кнопками вверх/вниз
        minutes_spinbox = ttk.Spinbox(time_frame, from_=0, to=59, width=3, textvariable=minutes_var, validate="key", validatecommand=vcmd)
        minutes_spinbox.pack(side=tk.LEFT)
        ttk.Label(time_frame, text="м").pack(side=tk.LEFT)

        # Поле для секунд с кнопками вверх/вниз
        seconds_spinbox = ttk.Spinbox(time_frame, from_=0, to=59, width=3, textvariable=seconds_var, validate="key", validatecommand=vcmd)
        seconds_spinbox.pack(side=tk.LEFT)
        ttk.Label(time_frame, text="с").pack(side=tk.LEFT)

        # Сохраняем ссылки на Spinbox'ы в объекте таймера
        timer.hours_spinbox = hours_spinbox
        timer.minutes_spinbox = minutes_spinbox
        timer.seconds_spinbox = seconds_spinbox

        # Оставшееся время
        time_label = ttk.Label(frame, text=self.format_time(timer.remaining_seconds), width=10, font=("Arial", 10, "bold"))
        time_label.pack(side=tk.LEFT, padx=10)

        # Установка цвета текста
        def update_color():
            if timer.remaining_seconds <= 0:
                time_label.config(foreground="red")  # Красный, если время вышло
            elif timer.running:
                time_label.config(foreground="green")  # Зелёный, если таймер запущен
            else:
                time_label.config(foreground="blue")  # Синий, если таймер остановлен

        update_color()

        # Обновление времени таймера при изменении полей
        def update_time(*args):
            try:
                hours = int(hours_var.get())
                minutes = int(minutes_var.get())
                seconds = int(seconds_var.get())

                # Если минуты или секунды больше 59, устанавливаем их в 59
                if minutes > 59:
                    minutes_var.set(59)
                    minutes = 59
                if seconds > 59:
                    seconds_var.set(59)
                    seconds = 59

                timer.total_seconds = hours * 3600 + minutes * 60 + seconds
                if not timer.running:
                    timer.remaining_seconds = timer.total_seconds
                time_label.config(text=self.format_time(timer.remaining_seconds))  # Обновляем отображение времени
                update_color()  # Обновляем цвет текста
                self.save_timers()
            except ValueError:
                pass

        hours_var.trace_add("write", update_time)
        minutes_var.trace_add("write", update_time)
        seconds_var.trace_add("write", update_time)

        # Кнопка "Старт/Стоп"
        start_stop_button = ttk.Button(frame, text="Старт" if not timer.running else "Стоп", command=lambda: self.toggle_timer(timer, time_label, start_stop_button))
        start_stop_button.pack(side=tk.LEFT, padx=5)

        # Кнопка "Сброс"
        reset_button = ttk.Button(frame, text="Сброс", command=lambda: self.reset_timer(timer, time_label, start_stop_button))
        reset_button.pack(side=tk.LEFT, padx=5)

        # Обновление времени каждую секунду
        def update_time_label():
            if timer.running:
                remaining = timer.update()
                time_label.config(text=self.format_time(remaining))
                update_color()
                if remaining <= 0:
                    start_stop_button.config(text="Старт")  # Переключаем кнопку на "Старт"
                    self.save_timers()
            self.root.after(1000, update_time_label)

        update_time_label()

        # Блокировка полей ввода, если таймер запущен
        if timer.running:
            timer.update_ui_state()

    # Форматирование времени в чч:мм:сс
    def format_time(self, seconds):
        hours = seconds // 3600
        minutes = (seconds % 3600) // 60
        seconds = seconds % 60
        return f"{hours:02}:{minutes:02}:{seconds:02}"

    # Удаление таймера
    def delete_timer(self, timer, frame):
        del self.timers[timer.timer_id]
        frame.destroy()  # Удаляем фрейм таймера из интерфейса
        self.save_timers()

    # Обновление названия таймера
    def update_timer_name(self, timer, new_name, frame):
        # Обновляем имя таймера
        timer.name = new_name
        self.save_timers()

    # Переключение между стартом и остановкой таймера
    def toggle_timer(self, timer, time_label, start_stop_button):
        if timer.running:
            timer.stop()  # Останавливаем и сбрасываем таймер
            start_stop_button.config(text="Старт")
            time_label.config(text=self.format_time(timer.remaining_seconds))  # Обновляем отображение времени
            self.update_color(timer, time_label)  # Обновляем цвет текста
        else:
            timer.start()
            start_stop_button.config(text="Стоп")
            self.update_color(timer, time_label)  # Обновляем цвет текста
        self.save_timers()

    # Сброс таймера
    def reset_timer(self, timer, time_label, start_stop_button):
        timer.reset()
        start_stop_button.config(text="Старт")
        time_label.config(text=self.format_time(timer.remaining_seconds))
        self.update_color(timer, time_label)
        self.save_timers()

    # Обновление цвета текста
    def update_color(self, timer, time_label):
        if timer.remaining_seconds <= 0:
            time_label.config(foreground="red")  # Красный, если время вышло
        elif timer.running:
            time_label.config(foreground="green")  # Зелёный, если таймер запущен
        else:
            time_label.config(foreground="blue")  # Синий, если таймер остановлен

    # Добавление нового таймера
    def add_timer(self):
        # Получаем список всех имен таймеров
        existing_names = {t.name for t in self.timers.values()}
        
        # Ищем максимальный номер, который уже используется в именах
        max_number = 0
        for name in existing_names:
            if name.startswith("Новый таймер 1"):
                try:
                    number = int(name.split(" ")[-1])
                    if number > max_number:
                        max_number = number
                except ValueError:
                    pass
        
        # Формируем новое имя с увеличенным номером
        name = f"Новый таймер {max_number + 1}"
        
        # Создаем новый таймер
        timer_id = self.next_timer_id
        self.next_timer_id += 1
        timer = Timer(timer_id, name, 0, 0, 0)
        self.timers[timer_id] = timer
        self.display_timer(timer)
        self.save_timers()

    # Сохранение всех таймеров в файл
    def save_timers(self):
        data = {}
        for timer_id, timer in self.timers.items():
            data[timer_id] = {
                "id": timer_id,  # Сохраняем ID таймера
                "name": timer.name,
                "time": [timer.total_seconds // 3600, (timer.total_seconds % 3600) // 60, timer.total_seconds % 60],
                "start_time": timer.start_time.isoformat() if timer.start_time else None
            }
        save_data(data)

    # Сохранение данных при закрытии приложения
    def on_close(self):
        self.save_timers()
        self.root.destroy()

# Запуск приложения
if __name__ == "__main__":
    root = tk.Tk()
    app = TimerApp(root)
    root.mainloop()