电脑定时锁屏软件V1.0

共计 16686 个字符，预计需要花费 42 分钟才能阅读完成。

小孩玩电脑没有时间概念，所以用 AI 弄了这个定时锁屏软件，点击开始之后窗口会自动隐藏，只能通过快捷键 Ctal+Alt+N+ M 调出窗口，倒计时还有 10 秒的时间，会弹窗提示

链接：https://pan.quark.cn/s/291bd01a9fd6

 下方是软件代码：import tkinter as tk
from tkinter import messagebox, ttk
import threading
import time
import os
import sys
import ctypes
import keyboard
from datetime import datetime

class LockScreenApp:
def init(self, root):
self.root = root
self.root.title("电脑锁屏助手 v1.0、吾爱首发")
self.root.geometry("400x350")
self.root.resizable(False, False)
self.root.attributes("-topmost", True)

# 设置窗口图标
try:
if hasattr(sys, '_MEIPASS'):
icon_path = os.path.join(sys._MEIPASS, 'icon.ico')
else:
icon_path = 'icon.ico'
if os.path.exists(icon_path):
self.root.iconbitmap(icon_path)
except Exception:
# 如果图标不存在或无法加载，忽略错误
pass
# 设置主题颜色 - 使用微信绿
self.bg_color = "#f0f0f0"
self.btn_color = "#07C160" # 微信绿
self.btn_hover_color = "#06984e" # 微信绿 - 深
self.text_color = "#333333"
self.root.configure(bg=self.bg_color)

# 初始化变量
self.lock_timer = None
self.is_timer_running = False
self.remaining_time = 0
self.paused_time = 0
self.is_paused = False
self.last_error = None

# 初始化窗口位置记忆
self.last_window_position = None

# 创建 GUI 组件
self.create_widgets()

# 设置全局热键
self.set_hotkey()

# 创建系统托盘图标
self.create_tray_icon()

def create_widgets(self):
main_frame = ttk.Frame(self.root, padding="20")
main_frame.pack(fill=tk.BOTH, expand=True)
main_frame.configure(style="Main.TFrame")

style = ttk.Style()
style.configure("Main.TFrame", background=self.bg_color)
style.configure("TLabel", background=self.bg_color, foreground=self.text_color)
style.configure("Title.TLabel", font=("SimHei", 16, "bold"), background=self.bg_color, foreground=self.text_color)
style.configure("Subtitle.TLabel", font=("SimHei", 10), background=self.bg_color, foreground="#666666")
style.configure("Status.TLabel", font=("SimHei", 10), background=self.bg_color, foreground=self.text_color)
style.configure("Hotkey.TLabel", font=("SimHei", 8), foreground="#666666", background=self.bg_color)
style.configure("TButton", font=("SimHei", 10))

title_frame = ttk.Frame(main_frame)
title_frame.pack(fill=tk.X, pady=(0, 15))
title_frame.configure(style="Main.TFrame")

title_label = ttk.Label(title_frame, text="电脑锁屏助手", style="Title.TLabel")
title_label.pack(side=tk.LEFT)

def create_custom_button(parent, text, command, width=5):
btn = tk.Button(
parent, 
text=text, 
font=("SimHei", 11, "bold"),
bg=self.btn_color,
fg="white",
activebackground=self.btn_hover_color,
activeforeground="white",
relief=tk.RAISED,
bd=0,
highlightthickness=0,
padx=10,
pady=10,
width=width,
command=command
)
btn.configure(highlightbackground=self.btn_color, highlightcolor=self.btn_color, highlightthickness=0)
btn.bind("<Enter>", lambda e, b=btn: b.config(bg=self.btn_hover_color))
btn.bind("<Leave>", lambda e, b=btn: b.config(bg=self.btn_color))
btn.bind("<ButtonPress-1>", lambda e, b=btn: b.config(bg="#004080"))
btn.bind("<ButtonRelease-1>", lambda e, b=btn: b.config(bg=self.btn_hover_color))
return btn

# 时间选择器区域 - 放在上面一行
time_select_frame = ttk.Frame(main_frame)
time_select_frame.pack(fill=tk.X, pady=15)
time_select_frame.configure(style="Main.TFrame")

# 5 分钟按钮
self.btn_5min = create_custom_button(time_select_frame, "5 分钟", lambda: self.start_timer(5), width=3)
self.btn_5min.pack(side=tk.LEFT, padx=10, pady=5)

# 10 分钟按钮
self.btn_10min = create_custom_button(time_select_frame, "10 分钟", lambda: self.start_timer(10), width=4)
self.btn_10min.pack(side=tk.LEFT, padx=10, pady=5)

# 自定义时间输入区域
custom_frame = ttk.Frame(time_select_frame)
custom_frame.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=10)
custom_frame.configure(style="Main.TFrame")

self.custom_time_var = tk.StringVar()
self.custom_time_entry = ttk.Entry(
custom_frame, 
textvariable=self.custom_time_var,
width=4,
font=(("SimHei", 22))
)
self.custom_time_entry.pack(side=tk.LEFT, padx=(0, 5), pady=2)
self.custom_time_entry.bind("<KeyRelease>", self.validate_time_input)
self.custom_time_entry.bind("<Return>", lambda event: self.start_custom_timer())

ttk.Label(custom_frame, text="分钟", font=(("SimHei", 20))).pack(side=tk.LEFT, padx=2)

# 按钮操作区域 - 放在下面一行
action_frame = ttk.Frame(main_frame)
action_frame.pack(fill=tk.X, pady=10)
action_frame.configure(style="Main.TFrame")

# 开始按钮
self.btn_start = create_custom_button(action_frame, "开始", self.start_custom_timer, width=6)
self.btn_start.pack(side=tk.LEFT, padx=10, pady=5)

# 暂停 / 继续按钮
self.btn_pause = create_custom_button(action_frame, "暂停 / 继续", self.toggle_pause, width=8)
self.btn_pause.pack(side=tk.LEFT, padx=10, pady=5)

# 新增清空按钮
self.btn_clear = create_custom_button(action_frame, "清空", self.cancel_timer, width=6)
self.btn_clear.pack(side=tk.LEFT, padx=10, pady=5)

status_frame = ttk.Frame(main_frame)
status_frame.pack(fill=tk.X, pady=15)
status_frame.configure(style="Main.TFrame")

ttk.Label(status_frame, text="状态:", style="TLabel").pack(side=tk.LEFT)
self.status_var = tk.StringVar()
self.status_var.set("就绪")
self.status_label = ttk.Label(status_frame, textvariable=self.status_var, style="Status.TLabel")
self.status_label.pack(side=tk.LEFT, padx=5)

bottom_frame = ttk.Frame(main_frame)
bottom_frame.pack(fill=tk.X, side=tk.BOTTOM)
bottom_frame.configure(style="Main.TFrame")

hotkey_label = ttk.Label(bottom_frame, text="Ctrl+Alt+N+M 调出窗口", style="Hotkey.TLabel")
hotkey_label.pack(pady=(10, 0))

def start_timer(self, minutes):
"""启动倒计时计时器"""
try:
if self.is_timer_running:
# 取消当前计时器
self.cancel_timer()

# 设置新的倒计时时间
self.remaining_time = minutes * 60
self.is_timer_running = True
self.is_paused = False

# 更新状态
self.status_var.set(f"锁屏将在 {minutes} 分钟后启动")
self.update_tray_tooltip(f"锁屏将在 {minutes} 分钟后启动")

# 记录启动事件
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"计时器启动时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}, 设定时间: {minutes} 分钟 \n")

# 创建并启动计时器线程
self.lock_timer = threading.Thread(target=self.countdown)
self.lock_timer.daemon = True
self.lock_timer.start()

# 隐藏窗口
self.hide_window()
except Exception as e:
# 记录启动错误
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"启动计时器错误: {str(e)}\n")
messagebox.showerror("错误", f"启动计时器时出错: {str(e)}")

def validate_time_input(self, event=None):
"""验证时间输入，只允许数字和小数点，最多 480 分钟"""
input_text = self.custom_time_var.get()

# 移除非数字和小数点的字符
new_text = ''.join(c for c in input_text if c.isdigit() or c =='.')

# 确保只有一个小数点
if new_text.count('.') > 1:
parts = new_text.split('.')
new_text = parts[0] + '.' + ''.join(parts[1:])

# 更新输入框
if new_text != input_text:
self.custom_time_var.set(new_text)
# 保持光标位置
pos = event.widget.index(tk.INSERT)
event.widget.icursor(pos - (len(input_text) - len(new_text)))

# 检查是否超过 480 分钟（8 小时）try:
if new_text:
minutes = float(new_text)
if minutes > 480:
self.custom_time_var.set('480')
self.status_var.set("警告: 超过最大时间限制")
else:
self.status_var.set("就绪")
except ValueError:
pass

def start_custom_timer(self):
"""从输入框启动自定义时间计时"""
try:
time_str = self.custom_time_var.get()
if not time_str:
messagebox.showwarning("输入错误", "请输入时间")
return

minutes = float(time_str)
if minutes <= 0:
messagebox.showwarning("输入错误", "请输入大于 0 的时间")
return

if minutes > 480:
messagebox.showwarning("输入错误", "最大时间为 480 分钟")
return

# 保留浮点数，但设置最小时间为 0.1 分钟（6 秒）if minutes < 0.1:
minutes = 0.1 # 最少 0.1 分钟

self.start_timer(minutes)
except ValueError:
messagebox.showwarning("输入错误", "请输入有效的数字")
self.custom_time_entry.focus_set()

def toggle_pause(self):
"""暂停或恢复计时器"""
if not self.is_timer_running:
messagebox.showinfo("提示", "计时器未运行")
return

if self.is_paused:
# 恢复计时器
self.is_paused = False
self.btn_pause.config(text="暂停 / 继续")
self.btn_pause.config(bg=self.btn_color, fg="white", activebackground=self.btn_hover_color)
time_text = self.format_time(self.remaining_time)
self.status_var.set(f"恢复倒计时，剩余时间: {time_text}")
self.update_tray_tooltip(f"恢复倒计时: {time_text}")
# 继续倒计时线程
self.lock_timer = threading.Thread(target=self.countdown)
self.lock_timer.daemon = True
self.lock_timer.start()
# 记录恢复事件
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"计时器恢复时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}, 剩余时间: {time_text}\n")
else:
# 暂停计时器
self.is_paused = True
self.btn_pause.config(text="继续")
self.btn_pause.config(bg="#ffc107", fg="#333333", activebackground="#e0a800")
time_text = self.format_time(self.remaining_time)
self.status_var.set(f"已暂停，剩余时间: {time_text}")
self.update_tray_tooltip(f"已暂停: {time_text}")
# 记录暂停事件
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"计时器暂停时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}, 剩余时间: {time_text}\n")

def countdown(self):
"""倒计时线程函数"""
try:
# 记录倒计时开始
start_time = time.time()
target_time = start_time + self.remaining_time
# 清除可能存在的警告窗口引用
if hasattr(self, '_warning_window'):
if self._warning_window.winfo_exists():
self._warning_window.destroy()

while self.is_timer_running and not self.is_paused:
# 计算剩余时间（更准确的计时方式）current_time = time.time()
self.remaining_time = int(target_time - current_time)

if self.remaining_time <= 0:
break

# 更新状态和托盘提示
time_text = self.format_time(self.remaining_time)

# 使用线程安全的方式更新 GUI
self.root.after(0, lambda tt=time_text: self.status_var.set(f"剩余时间: {tt}"))
self.update_tray_tooltip(f"剩余时间: {time_text}")

# 添加倒计时提示功能（10 秒及以内）if 0 < self.remaining_time <= 10:
# 使用线程安全的方式显示或更新提示框
self.root.after(0, lambda remaining=self.remaining_time: self._show_lock_warning(remaining))

# 休眠 1 秒，但可以被中断
for _ in range(10): # 分成 10 次小休眠，以便更快响应暂停 / 取消
if not self.is_timer_running or self.is_paused:
break
time.sleep(0.1)

# 检查是否被暂停或取消
if not self.is_timer_running or self.is_paused:
break

# 倒计时结束，执行锁屏
if self.remaining_time <= 0 and self.is_timer_running and not self.is_paused:
self.lock_screen()
except Exception as e:
# 记录倒计时错误
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"倒计时错误: {str(e)}\n")
# 尝试锁屏作为安全措施
try:
self.lock_screen()
except:
pass

def format_time(self, seconds):
"""格式化时间为分: 秒"""
minutes = seconds // 60
secs = seconds % 60
return f"{minutes:02d}:{secs:02d}"

def _show_lock_warning(self, remaining):
"""显示锁屏前的警告提示，支持动态更新倒计时"""
# 检查是否已存在警告窗口，如果存在则更新内容，否则创建新窗口
if hasattr(self, '_warning_window') and self._warning_window.winfo_exists():
# 更新现有窗口的标签文本
if hasattr(self, '_warning_label'):
self._warning_label.config(text=f"电脑还有 {remaining} 秒锁屏了")
else:
# 创建一个独立的提示窗口
self._warning_window = tk.Toplevel(self.root)
self._warning_window.title("锁屏警告")
self._warning_window.geometry("300x150")
self._warning_window.attributes("-topmost", True)
self._warning_window.configure(bg="#f0f0f0")

# 居中窗口
self._warning_window.update_idletasks()
width = self._warning_window.winfo_width()
height = self._warning_window.winfo_height()
x = (self._warning_window.winfo_screenwidth() // 2) - (width // 2)
y = (self._warning_window.winfo_screenheight() // 2) - (height // 2)
self._warning_window.geometry(f"{width}x{height}+{x}+{y}")

# 添加提示标签
self._warning_label = tk.Label(
self._warning_window, 
text=f"电脑还有 {remaining} 秒锁屏了", 
font=("SimHei", 16, "bold"),
bg="#f0f0f0",
fg="#ff0000"
)
self._warning_label.pack(pady=20)

# 添加关闭按钮
btn_ok = tk.Button(
self._warning_window, 
text="知道了", 
font=("SimHei", 12),
bg=self.btn_color,
fg="white",
activebackground=self.btn_hover_color,
relief=tk.RAISED,
bd=0,
padx=20,
pady=8,
command=self._warning_window.destroy
)
btn_ok.pack(pady=10)
btn_ok.configure(highlightbackground=self.btn_color, highlightthickness=0)

def lock_screen(self):
"""锁定屏幕（支持多种锁屏方式作为备选）"""
try:
# 记录锁屏时间
lock_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"屏幕锁定时间: {lock_time}\n")

# 方法 1: 使用 Windows API (首选方法)
try:
result = ctypes.windll.user32.LockWorkStation()
if result:
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write("锁屏成功: 使用 Windows API\n")
else:
raise Exception("LockWorkStation API 调用失败")
except Exception as e1:
# 记录首选方法失败
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"首选锁屏方法失败: {str(e1)}\n")

# 方法 2: 使用 rundll32 命令
try:
import subprocess
subprocess.run(["rundll32.exe", "user32.dll,LockWorkStation"], 
shell=True, check=True)
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write("锁屏成功: 使用 rundll32 命令 \n")
except Exception as e2:
# 记录方法 2 失败
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"备用锁屏方法失败: {str(e2)}\n")

# 方法 3: 使用 PowerShell 命令
try:
import subprocess
powershell_command = "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('^({ESC}{TAB}{ESC})')"
subprocess.run(["powershell.exe", "-Command", powershell_command], 
shell=True, check=True)
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write("锁屏成功: 使用 PowerShell 命令 \n")
except Exception as e3:
# 所有方法都失败
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"所有锁屏方法都失败: {str(e3)}\n")

# 显示消息提示用户手动锁屏
messagebox.showwarning(
"锁屏失败",
"无法自动锁定屏幕。请手动锁定您的计算机。\n" +
"锁屏时间:" + lock_time
)

# 重置状态
self.reset_timer()

except Exception as e:
# 记录总错误
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"锁屏过程总错误: {str(e)}\n")

# 即使出错也要重置状态
self.reset_timer()

def reset_timer(self):
"""重置计时器状态"""
self.is_timer_running = False
self.is_paused = False
self.remaining_time = 0
self.btn_pause.config(text="暂停")
self.status_var.set("就绪")
self.update_tray_tooltip("就绪")

def cancel_timer(self):
"""取消当前计时器"""
# 确保线程安全地停止
self.is_timer_running = False
self.is_paused = False
self.remaining_time = 0

# 重置 UI 状态
self.btn_pause.config(text="暂停")
self.status_var.set("就绪")
self.update_tray_tooltip("就绪")

# 如果有正在运行的计时器线程，尝试让它自然结束
# 注意：Python 中不能强制终止线程，而是通过标志位让它自己退出

# 额外确保界面可见，用户能看到取消后的状态
self.show_window()

# 记录取消事件
try:
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"计时器取消时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
except Exception as e:
# 即使日志写入失败，也要确保功能正常
pass

def hide_window(self):
"""隐藏窗口"""
# 保存当前窗口位置
try:
x = self.root.winfo_x()
y = self.root.winfo_y()
if x > 0 and y > 0: # 确保位置有效
self.last_window_position = (x, y)
except:
pass # 忽略获取位置时的错误

# 完全隐藏窗口（不仅是最小化）self.root.withdraw()
# 在系统托盘显示消息
try:
self.tray_icon.showmessage(
"锁屏助手",
"程序已在后台运行 \n 按 Ctrl+Alt+N+M 调出窗口",
timeout=5000
)
except:
pass # 忽略托盘错误

def show_window(self):
"""显示窗口"""
try:
# 从隐藏状态恢复
self.root.deiconify()
# 确保窗口在最上层
self.root.attributes("-topmost", True)
self.root.attributes("-topmost", False) # 允许其他窗口也能成为顶层
# 激活窗口
self.root.focus_force()

# 检查是否有保存的窗口位置，如果没有则居中显示
if not hasattr(self, 'last_window_position'):
# 计算屏幕中心位置
screen_width = self.root.winfo_screenwidth()
screen_height = self.root.winfo_screenheight()
window_width = 400 # 窗口宽度
window_height = 350 # 窗口高度

x = (screen_width - window_width) // 2
y = (screen_height - window_height) // 2

# 设置窗口位置并保存
self.root.geometry(f"+{x}+{y}")
self.last_window_position = (x, y)
else:
# 使用之前保存的位置
x, y = self.last_window_position
self.root.geometry(f"+{x}+{y}")
except Exception as e:
# 记录错误但不显示，避免影响用户体验
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"显示窗口错误: {str(e)}\n")

def create_tray_icon(self):
"""创建系统托盘图标"""
try:
# 尝试导入并创建系统托盘图标
import pystray
from pystray import MenuItem as item
from PIL import Image, ImageDraw

# 创建一个简单的图标
def create_image():
width = 64
height = 64
color1 = "#0078d7"
color2 = "white"

# 创建空白图像
image = Image.new('RGB', (width, height), color1)
dc = ImageDraw.Draw(image)

# 绘制简单的锁图标
dc.rectangle([10, 25, 54, 45], fill=color2)
dc.rectangle([25, 15, 39, 35], fill=color2)
dc.ellipse([20, 10, 44, 20], fill=color1, outline=color2, width=3)

return image

# 创建菜单
menu = (item('显示窗口', self.show_window),
item('暂停 / 恢复', self.toggle_pause),
item('退出', self.on_closing)
)

# 创建托盘图标
self.tray_icon = pystray.Icon("LockScreen", create_image(), "锁屏助手", menu)

# 在单独的线程中运行托盘图标
self.tray_thread = threading.Thread(target=self.tray_icon.run, daemon=True)
self.tray_thread.start()
except ImportError:
# 如果没有安装 pystray，使用 tkinter 的简化方法
self.tray_icon = None
pass

def update_tray_tooltip(self, message):
"""更新系统托盘提示文本"""
try:
if hasattr(self, 'tray_icon') and self.tray_icon:
self.tray_icon.title = f"锁屏助手 - {message}"
except:
pass # 忽略托盘错误

def set_hotkey(self):
"""设置全局热键"""
try:
# 移除可能已存在的热键（避免重复设置）try:
keyboard.remove_hotkey('ctrl+alt+n+m')
except:
pass

# 设置组合热键 Ctrl+Alt+N+M
keyboard.add_hotkey('ctrl+alt+n+m', self.show_window)

# 记录热键设置成功
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"热键设置成功: Ctrl+Alt+N+M\n")

except Exception as e:
# 记录错误
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"热键设置失败: {str(e)}\n")

# 尝试使用备用方案
try:
# 备用方案：使用全局钩子监听按键事件
def on_key_event(event):
# 检查是否按下了 Ctrl+Alt+N+ M 组合键
if event.name == 'm' and keyboard.is_pressed('ctrl') and keyboard.is_pressed('alt') and keyboard.is_pressed('n'):
self.show_window()

# 监听所有按键事件
keyboard.on_press(on_key_event)

# 记录备用方案设置成功
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write("备用热键方案设置成功 \n")

except Exception as e2:
# 记录备用方案失败
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"备用热键方案设置失败: {str(e2)}\n")

# 显示警告消息
messagebox.showwarning(
"热键设置警告", 
"无法设置全局热键。请确保以管理员权限运行程序。\n" +
"您仍然可以通过系统托盘图标访问程序。"
)

def on_closing(self):
"""窗口关闭事件处理"""
# 取消计时器
self.cancel_timer()
# 清理热键
try:
keyboard.unhook_all()
except:
pass
# 关闭托盘图标
try:
if hasattr(self, 'tray_icon') and self.tray_icon:
self.tray_icon.stop()
except:
pass
# 记录程序退出
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"程序退出时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
f.write("="*50 + "\n")
# 关闭窗口
self.root.destroy()

def check_environment(self):
"""检查运行环境"""
try:
# 创建日志目录（如果不存在）log_file = "lock_screen_log.txt"

# 写入程序启动信息
with open(log_file, "a", encoding="utf-8") as f:
f.write("="*50 + "\n")
f.write(f"程序启动时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
f.write(f"Python 版本: {sys.version}\n")
f.write(f"操作系统: Windows\n")

# 检查是否以管理员权限运行
try:
is_admin = ctypes.windll.shell32.IsUserAnAdmin()
with open(log_file, "a", encoding="utf-8") as f:
f.write(f"管理员权限: {' 是 'if is_admin else' 否 '}\n")
except:
with open(log_file, "a", encoding="utf-8") as f:
f.write("无法检查管理员权限 \n")

except Exception as e:
# 如果日志写入失败，尝试简单的异常处理
self.last_error = str(e)
pass

try:
with open("lock_screen_log.txt", "a", encoding="utf-8") as f:
f.write(f"未捕获异常: {exc_type.__name__}: {str(exc_value)}\n")
import traceback
traceback.print_tb(exc_traceback, file=f)
f.write("="*50 + "\n")
except:
pass # 如果日志写入失败，忽略

# 设置全局异常处理
sys.excepthook = handle_exception

root = tk.Tk()
# 创建应用实例
app = LockScreenApp(root)
# 运行应用
root.mainloop()