2857 lines
123 KiB
Python
2857 lines
123 KiB
Python
import ctypes
|
||
import datetime as dt
|
||
import json
|
||
import os
|
||
import platform
|
||
import re
|
||
import subprocess
|
||
import sys
|
||
import psutil
|
||
import signal
|
||
import traceback
|
||
from shutil import copy
|
||
from typing import Optional
|
||
|
||
from PyQt5 import uic
|
||
from PyQt5.QtCore import Qt, QTimer, QPropertyAnimation, QRect, QEasingCurve, QSize, QPoint, QUrl, QObject, QParallelAnimationGroup
|
||
from PyQt5.QtGui import QColor, QIcon, QPixmap, QPainter, QDesktopServices
|
||
from PyQt5.QtGui import QFontDatabase
|
||
from PyQt5.QtSvg import QSvgRenderer
|
||
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QProgressBar, QGraphicsBlurEffect, QPushButton, \
|
||
QGraphicsDropShadowEffect, QSystemTrayIcon, QFrame, QGraphicsOpacityEffect, QHBoxLayout
|
||
from loguru import logger
|
||
from packaging.version import Version
|
||
from qfluentwidgets import Theme, setTheme, setThemeColor, SystemTrayMenu, Action, FluentIcon as fIcon, isDarkTheme, \
|
||
Dialog, ProgressRing, PlainTextEdit, ImageLabel, PushButton, InfoBarIcon, Flyout, FlyoutAnimationType, CheckBox, \
|
||
PrimaryPushButton, IconWidget
|
||
|
||
import conf
|
||
import list_
|
||
import tip_toast
|
||
from tip_toast import active_windows
|
||
import utils
|
||
import weather_db as db
|
||
from conf import base_directory
|
||
from extra_menu import ExtraMenu, open_settings
|
||
from generate_speech import generate_speech_sync, list_pyttsx3_voices
|
||
from menu import open_plaza
|
||
from network_thread import check_update, weatherReportThread
|
||
from play_audio import play_audio
|
||
from plugin import p_loader
|
||
from utils import restart, stop, share, update_timer, DarkModeWatcher
|
||
from file import config_center, schedule_center
|
||
|
||
if os.name == 'nt':
|
||
import pygetwindow
|
||
|
||
# 适配高DPI缩放
|
||
if platform.system() == 'Windows' and platform.release() not in ['7', 'XP', 'Vista']:
|
||
QApplication.setHighDpiScaleFactorRoundingPolicy(
|
||
Qt.HighDpiScaleFactorRoundingPolicy.PassThrough)
|
||
QApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
|
||
QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps)
|
||
else:
|
||
logger.warning('不兼容的系统,跳过高DPI标识')
|
||
|
||
today = dt.date.today()
|
||
|
||
# 存储窗口对象
|
||
windows = []
|
||
order = []
|
||
error_dialog = None
|
||
|
||
current_lesson_name = '课程表未加载'
|
||
current_state = 0 # 0：课间 1：上课 2: 休息段
|
||
current_time = dt.datetime.now().strftime('%H:%M:%S')
|
||
current_week = dt.datetime.now().weekday()
|
||
current_lessons = {}
|
||
loaded_data = {}
|
||
parts_type = []
|
||
notification = tip_toast
|
||
excluded_lessons = []
|
||
last_notify_time = None
|
||
notify_cooldown = 2 # 2秒内仅能触发一次通知(防止触发114514个通知导致爆炸
|
||
|
||
timeline_data = {}
|
||
next_lessons = []
|
||
parts_start_time = []
|
||
|
||
temperature = '未设置'
|
||
weather_icon = 0
|
||
weather_name = ''
|
||
weather_data_temp = None
|
||
city = 101010100 # 默认城市
|
||
theme = None
|
||
|
||
time_offset = 0 # 时差偏移
|
||
first_start = True
|
||
error_cooldown = dt.timedelta(seconds=2) # 冷却时间(s)
|
||
ignore_errors = []
|
||
last_error_time = dt.datetime.now() - error_cooldown # 上一次错误
|
||
|
||
ex_menu = None
|
||
dark_mode_watcher = None
|
||
was_floating_mode = False # 浮窗状态
|
||
|
||
if config_center.read_conf('Other', 'do_not_log') != '1':
|
||
logger.add(f"{base_directory}/log/ClassWidgets_main_{{time}}.log", rotation="1 MB", encoding="utf-8",
|
||
retention="1 minute")
|
||
logger.info('未禁用日志输出')
|
||
else:
|
||
logger.info('已禁用日志输出功能，若需保存日志，请在“设置”->“高级选项”中关闭禁用日志功能')
|
||
|
||
|
||
def global_exceptHook(exc_type, exc_value, exc_tb): # 全局异常捕获
|
||
if config_center.read_conf('Other', 'safe_mode') == '1': # 安全模式
|
||
return
|
||
|
||
error_details = ''.join(traceback.format_exception(exc_type, exc_value, exc_tb)) # 异常详情
|
||
if error_details in ignore_errors: # 忽略重复错误
|
||
return
|
||
|
||
global last_error_time, error_dialog, error_cooldown
|
||
|
||
current_time = dt.datetime.now()
|
||
if current_time - last_error_time > error_cooldown: # 冷却时间
|
||
last_error_time = current_time
|
||
logger.error(f"全局异常捕获：{exc_type} {exc_value} {exc_tb}")
|
||
logger.error(f"详细堆栈信息：\n{error_details}")
|
||
if not error_dialog:
|
||
w = ErrorDialog(error_details)
|
||
w.exec()
|
||
else:
|
||
# 忽略冷却时间
|
||
pass
|
||
|
||
|
||
sys.excepthook = global_exceptHook # 设置全局异常捕获
|
||
|
||
def handle_dark_mode_change(is_dark):
|
||
"""处理DarkModeWatcher触发的UI更新"""
|
||
if config_center.read_conf('General', 'color_mode') == '2':
|
||
logger.info(f"系统颜色模式更新: {'深色' if is_dark else '浅色'}")
|
||
current_theme = Theme.DARK if is_dark else Theme.LIGHT
|
||
setTheme(current_theme)
|
||
if mgr:
|
||
mgr.clear_widgets()
|
||
else:
|
||
logger.warning("主题更改时,mgr还未初始化")
|
||
# if current_state == 1:
|
||
# setThemeColor(f"#{config_center.read_conf('Color', 'attend_class')}")
|
||
# else:
|
||
# setThemeColor(f"#{config_center.read_conf('Color', 'finish_class')}")
|
||
|
||
|
||
def setTheme_(): # 设置主题
|
||
global theme
|
||
color_mode = config_center.read_conf('General', 'color_mode')
|
||
if color_mode == '2': # 自动
|
||
logger.info(f'颜色模式: 自动({color_mode})')
|
||
if platform.system() == 'Darwin' and Version(platform.mac_ver()[0]) < Version('10.14'):
|
||
return
|
||
if platform.system() == 'Windows':
|
||
# Windows 7特殊处理
|
||
if sys.getwindowsversion().major == 6 and sys.getwindowsversion().minor == 1:
|
||
setTheme(Theme.LIGHT)
|
||
return
|
||
# 检查Windows版本是否支持深色模式（Windows 10 build 14393及以上）
|
||
try:
|
||
win_build = sys.getwindowsversion().build
|
||
if win_build < 14393: # 不支持深色模式的最低版本
|
||
return
|
||
except AttributeError:
|
||
# 无法获取版本信息，保守返回
|
||
return
|
||
if platform.system() == 'Linux':
|
||
return
|
||
if dark_mode_watcher:
|
||
is_dark = dark_mode_watcher.isDark()
|
||
if is_dark is not None:
|
||
logger.info(f"当前颜色模式: {'深色' if is_dark else '浅色'}")
|
||
setTheme(Theme.DARK if is_dark else Theme.LIGHT)
|
||
else:
|
||
logger.warning("无法获取系统颜色模式，暂时使用浅色主题")
|
||
setTheme(Theme.LIGHT)
|
||
else:
|
||
logger.warning("DarkModeWatcher 未被初始化，使用浅色主题")
|
||
setTheme(Theme.LIGHT)
|
||
elif color_mode == '1':
|
||
logger.info(f'颜色模式: 深色({color_mode})')
|
||
setTheme(Theme.DARK)
|
||
else:
|
||
logger.info(f'颜色模式: 浅色({color_mode})')
|
||
setTheme(Theme.LIGHT)
|
||
|
||
|
||
def get_timeline_data():
|
||
if len(loaded_data['timeline']) == 1:
|
||
return loaded_data['timeline']['default']
|
||
else:
|
||
if str(current_week) in loaded_data['timeline'] and loaded_data['timeline'][str(current_week)]: # 如果此周有时间线
|
||
return loaded_data['timeline'][str(current_week)]
|
||
else:
|
||
return loaded_data['timeline']['default']
|
||
|
||
|
||
# 获取Part开始时间
|
||
def get_start_time():
|
||
global parts_start_time, timeline_data, loaded_data, order, parts_type
|
||
loaded_data = schedule_center.schedule_data
|
||
timeline = get_timeline_data()
|
||
part = loaded_data['part']
|
||
parts_start_time = []
|
||
timeline_data = {}
|
||
order = []
|
||
|
||
for item_name, item_value in part.items():
|
||
try:
|
||
h, m = item_value[:2]
|
||
try:
|
||
part_type = item_value[2]
|
||
except IndexError:
|
||
part_type = 'part'
|
||
except Exception as e:
|
||
logger.error(f'加载课程表文件[节点类型]出错：{e}')
|
||
part_type = 'part'
|
||
|
||
# 应用时差偏移到课程表时间
|
||
start_time = dt.datetime.combine(today, dt.time(h, m)) + dt.timedelta(seconds=time_offset)
|
||
parts_start_time.append(start_time)
|
||
order.append(item_name)
|
||
parts_type.append(part_type)
|
||
except Exception as e:
|
||
logger.error(f'加载课程表文件[起始时间]出错：{e}')
|
||
|
||
paired = zip(parts_start_time, order)
|
||
paired_sorted = sorted(paired, key=lambda x: x[0]) # 按时间大小排序
|
||
if paired_sorted:
|
||
parts_start_time, order = zip(*paired_sorted)
|
||
|
||
def sort_timeline_key(item):
|
||
item_name = item[0]
|
||
prefix = item_name[0]
|
||
if len(item_name) > 1:
|
||
try:
|
||
# 提取节点序数
|
||
part_num = int(item_name[1])
|
||
# 提取课程序数
|
||
class_num = 0
|
||
if len(item_name) > 2:
|
||
class_num = int(item_name[2:])
|
||
if prefix == 'a':
|
||
return part_num, class_num, 0
|
||
else:
|
||
return part_num, class_num, 1
|
||
except ValueError:
|
||
# 如果转换失败，返回原始字符串
|
||
return item_name
|
||
return item_name
|
||
|
||
# 对timeline排序后添加到timeline_data
|
||
sorted_timeline = sorted(timeline.items(), key=sort_timeline_key)
|
||
for item_name, item_time in sorted_timeline:
|
||
try:
|
||
timeline_data[item_name] = item_time
|
||
except Exception as e:
|
||
logger.error(f'加载课程表文件[课程数据]出错：{e}')
|
||
|
||
|
||
def get_part():
|
||
if not parts_start_time:
|
||
return None
|
||
|
||
def return_data():
|
||
c_time = parts_start_time[i]
|
||
return c_time, int(order[i]) # 返回开始时间、Part序号
|
||
|
||
current_dt = dt.datetime.now() # 当前时间
|
||
|
||
for i in range(len(parts_start_time)): # 遍历每个Part
|
||
time_len = dt.timedelta(minutes=0) # Part长度
|
||
|
||
for item_name, item_time in timeline_data.items():
|
||
if item_name.startswith(f'a{str(order[i])}') or item_name.startswith(f'f{str(order[i])}'):
|
||
time_len += dt.timedelta(minutes=int(item_time)) # 累计Part的时间点总长度
|
||
time_len += dt.timedelta(seconds=1)
|
||
|
||
if time_len != dt.timedelta(seconds=1): # 有课程
|
||
if i == len(parts_start_time) - 1: # 最后一个Part
|
||
return return_data()
|
||
else:
|
||
if current_dt <= parts_start_time[i] + time_len:
|
||
return return_data()
|
||
|
||
return parts_start_time[0] + dt.timedelta(seconds=time_offset), 0, 'part'
|
||
|
||
def get_excluded_lessons():
|
||
global excluded_lessons
|
||
if config_center.read_conf('General', 'excluded_lesson') == "0":
|
||
excluded_lessons = []
|
||
return
|
||
excluded_lessons_raw = config_center.read_conf('General', 'excluded_lessons')
|
||
excluded_lessons = excluded_lessons_raw.split(',') if excluded_lessons_raw != '' else []
|
||
|
||
# 获取当前活动
|
||
def get_current_lessons(): # 获取当前课程
|
||
global current_lessons
|
||
timeline = get_timeline_data()
|
||
if config_center.read_conf('General', 'enable_alt_schedule') == '1' or conf.is_temp_week():
|
||
try:
|
||
if conf.get_week_type():
|
||
schedule = loaded_data.get('schedule_even')
|
||
else:
|
||
schedule = loaded_data.get('schedule')
|
||
except Exception as e:
|
||
logger.error(f'加载课程表文件[单双周]出错：{e}')
|
||
schedule = loaded_data.get('schedule')
|
||
else:
|
||
schedule = loaded_data.get('schedule')
|
||
class_count = 0
|
||
for item_name, _ in timeline.items():
|
||
if item_name.startswith('a'):
|
||
if schedule[str(current_week)]:
|
||
try:
|
||
if schedule[str(current_week)][class_count] != '未添加':
|
||
current_lessons[item_name] = schedule[str(current_week)][class_count]
|
||
else:
|
||
current_lessons[item_name] = '暂无课程'
|
||
except IndexError:
|
||
current_lessons[item_name] = '暂无课程'
|
||
except Exception as e:
|
||
current_lessons[item_name] = '暂无课程'
|
||
logger.debug(f'加载课程表文件出错：{e}')
|
||
class_count += 1
|
||
else:
|
||
current_lessons[item_name] = '暂无课程'
|
||
class_count += 1
|
||
|
||
|
||
# 获取倒计时、弹窗提示
|
||
def get_countdown(toast=False): # 重构好累aaaa
|
||
global last_notify_time
|
||
current_dt = dt.datetime.now()
|
||
if last_notify_time and (current_dt - last_notify_time).seconds < notify_cooldown:
|
||
return
|
||
def after_school(): # 放学
|
||
if parts_type[part] == 'break': # 休息段
|
||
notification.push_notification(0, current_lesson_name) # 下课
|
||
else:
|
||
if config_center.read_conf('Toast', 'after_school') == '1':
|
||
notification.push_notification(2) # 放学
|
||
|
||
current_dt = dt.datetime.combine(today, dt.datetime.strptime(current_time, '%H:%M:%S').time()) # 当前时间
|
||
return_text = []
|
||
got_return_data = False
|
||
|
||
if parts_start_time:
|
||
c_time, part = get_part()
|
||
|
||
if current_dt >= c_time:
|
||
for item_name, item_time in timeline_data.items():
|
||
if item_name.startswith(f'a{str(part)}') or item_name.startswith(f'f{str(part)}'):
|
||
# 判断时间是否上下课，发送通知
|
||
if current_dt == c_time and toast:
|
||
if item_name.startswith('a'):
|
||
notification.push_notification(1, current_lesson_name) # 上课
|
||
last_notify_time = current_dt
|
||
else:
|
||
if next_lessons: # 下课/放学
|
||
notification.push_notification(0, next_lessons[0]) # 下课
|
||
last_notify_time = current_dt
|
||
else:
|
||
after_school()
|
||
|
||
if current_dt == c_time - dt.timedelta(
|
||
minutes=int(config_center.read_conf('Toast', 'prepare_minutes'))):
|
||
if config_center.read_conf('Toast',
|
||
'prepare_minutes') != '0' and toast and item_name.startswith('a'):
|
||
if not current_state: # 课间
|
||
notification.push_notification(3, next_lessons[0]) # 准备上课（预备铃）
|
||
last_notify_time = current_dt
|
||
|
||
# 放学
|
||
if (c_time + dt.timedelta(minutes=int(item_time)) == current_dt and not next_lessons and
|
||
not current_state and toast):
|
||
after_school()
|
||
last_notify_time = current_dt
|
||
|
||
add_time = int(item_time)
|
||
c_time += dt.timedelta(minutes=add_time)
|
||
|
||
if got_return_data:
|
||
break
|
||
|
||
if c_time >= current_dt:
|
||
# 根据所在时间段使用不同标语
|
||
if item_name.startswith('a'):
|
||
return_text.append('当前活动结束还有')
|
||
else:
|
||
return_text.append('课间时长还有')
|
||
# 返回倒计时、进度条
|
||
time_diff = c_time - current_dt
|
||
minute, sec = divmod(time_diff.seconds, 60)
|
||
return_text.append(f'{minute:02d}:{sec:02d}')
|
||
# 进度条
|
||
seconds = time_diff.seconds
|
||
return_text.append(int(100 - seconds / (int(item_time) * 60) * 100))
|
||
got_return_data = True
|
||
if not return_text:
|
||
return_text = ['目前课程已结束', f'00:00', 100]
|
||
else:
|
||
prepare_minutes_str = config_center.read_conf('Toast', 'prepare_minutes')
|
||
if prepare_minutes_str != '0' and toast:
|
||
prepare_minutes = int(prepare_minutes_str)
|
||
if current_dt == c_time - dt.timedelta(minutes=prepare_minutes):
|
||
next_lesson_name = None
|
||
next_lesson_key = None
|
||
if timeline_data:
|
||
for key in sorted(timeline_data.keys()):
|
||
if key.startswith(f'a{str(part)}'):
|
||
next_lesson_key = key
|
||
break
|
||
if next_lesson_key and next_lesson_key in current_lessons:
|
||
lesson_name = current_lessons[next_lesson_key]
|
||
if lesson_name != '暂无课程':
|
||
next_lesson_name = lesson_name
|
||
if current_state == 0:
|
||
now = dt.datetime.now()
|
||
if not last_notify_time or (now - last_notify_time).seconds >= notify_cooldown:
|
||
if next_lesson_name != None:
|
||
notification.push_notification(3, next_lesson_name)
|
||
if f'a{part}1' in timeline_data:
|
||
time_diff = c_time - current_dt
|
||
minute, sec = divmod(time_diff.seconds, 60)
|
||
return_text = ['距离上课还有', f'{minute:02d}:{sec:02d}', 100]
|
||
else:
|
||
return_text = ['目前课程已结束', f'00:00', 100]
|
||
return return_text
|
||
|
||
|
||
# 获取将发生的活动
|
||
def get_next_lessons():
|
||
global current_lesson_name
|
||
global next_lessons
|
||
next_lessons = []
|
||
part = 0
|
||
current_dt = dt.datetime.combine(today, dt.datetime.strptime(current_time, '%H:%M:%S').time()) # 当前时间
|
||
|
||
if parts_start_time:
|
||
c_time, part = get_part()
|
||
|
||
def before_class():
|
||
if part == 0 or part == 3:
|
||
return True
|
||
else:
|
||
if current_dt >= parts_start_time[part] - dt.timedelta(minutes=60):
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
if before_class():
|
||
for item_name, item_time in timeline_data.items():
|
||
if item_name.startswith(f'a{str(part)}') or item_name.startswith(f'f{str(part)}'):
|
||
add_time = int(item_time)
|
||
if c_time > current_dt and item_name.startswith('a'):
|
||
next_lessons.append(current_lessons[item_name])
|
||
c_time += dt.timedelta(minutes=add_time)
|
||
|
||
|
||
def get_next_lessons_text():
|
||
if not next_lessons:
|
||
cache_text = '当前暂无课程'
|
||
else:
|
||
cache_text = ''
|
||
if len(next_lessons) >= 5:
|
||
range_time = 5
|
||
else:
|
||
range_time = len(next_lessons)
|
||
for i in range(range_time):
|
||
if range_time > 2:
|
||
if next_lessons[i] != '暂无课程':
|
||
cache_text += f'{list_.get_subject_abbreviation(next_lessons[i])} ' # 获取课程简称
|
||
else:
|
||
cache_text += f'无 '
|
||
else:
|
||
if next_lessons[i] != '暂无课程':
|
||
cache_text += f'{next_lessons[i]} '
|
||
else:
|
||
cache_text += f'暂无 '
|
||
return cache_text
|
||
|
||
|
||
# 获取当前活动
|
||
def get_current_lesson_name():
|
||
global current_lesson_name, current_state
|
||
current_dt = dt.datetime.combine(today, dt.datetime.strptime(current_time, '%H:%M:%S').time()) # 当前时间
|
||
current_lesson_name = '暂无课程'
|
||
current_state = 0
|
||
|
||
if parts_start_time:
|
||
c_time, part = get_part()
|
||
|
||
if current_dt >= c_time:
|
||
if parts_type[part] == 'break': # 休息段
|
||
current_lesson_name = loaded_data['part_name'][str(part)]
|
||
current_state = 2
|
||
|
||
for item_name, item_time in timeline_data.items():
|
||
if item_name.startswith(f'a{str(part)}') or item_name.startswith(f'f{str(part)}'):
|
||
add_time = int(item_time)
|
||
c_time += dt.timedelta(minutes=add_time)
|
||
if c_time > current_dt:
|
||
if item_name.startswith('a'):
|
||
current_lesson_name = current_lessons[item_name]
|
||
current_state = 1
|
||
else:
|
||
current_lesson_name = '课间'
|
||
current_state = 0
|
||
return
|
||
|
||
def get_hide_status():
|
||
# 1 -> hide, 0 -> show
|
||
# 满分啦（
|
||
# 祝所有用 Class Widgets 的、不用 Class Widgets 的学子体测满分啊（（
|
||
global current_state, current_lesson_name, excluded_lessons
|
||
return 1 if {
|
||
'0': lambda: 0,
|
||
'1': lambda: current_state,
|
||
'2': lambda: check_windows_maximize() or check_fullscreen(),
|
||
'3': lambda: current_state
|
||
}[config_center.read_conf('General', 'hide')]() and not (current_lesson_name in excluded_lessons) else 0
|
||
|
||
|
||
# 定义 RECT 结构体
|
||
class RECT(ctypes.Structure):
|
||
_fields_ = [("left", ctypes.c_long),
|
||
("top", ctypes.c_long),
|
||
("right", ctypes.c_long),
|
||
("bottom", ctypes.c_long)]
|
||
|
||
def get_process_name(pid): # 获取进程名称
|
||
try:
|
||
if isinstance(pid, int):
|
||
pid = ctypes.windll.user32.GetWindowThreadProcessId(pid, None)
|
||
return psutil.Process(pid).name().lower()
|
||
except (psutil.NoSuchProcess, AttributeError, ValueError):
|
||
return "unknown"
|
||
|
||
def check_fullscreen(): # 检查是否全屏
|
||
if os.name != 'nt':
|
||
return False
|
||
user32 = ctypes.windll.user32
|
||
hwnd = user32.GetForegroundWindow()
|
||
if not hwnd:
|
||
return False
|
||
if hwnd == user32.GetDesktopWindow():
|
||
return False
|
||
if hwnd == user32.GetShellWindow():
|
||
return False
|
||
pid = ctypes.c_ulong()
|
||
user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
|
||
process_name = get_process_name(pid.value)
|
||
current_pid = os.getpid()
|
||
# logger.debug(f"前景窗口句柄: {hwnd}, PID: {pid.value}, 进程名: {process_name}")
|
||
if pid.value == current_pid:
|
||
return False
|
||
# 排除特定系统进程
|
||
excluded_system_processes = {
|
||
'explorer.exe', # 文件资源管理器/桌面
|
||
'shellexperiencehost.exe', # Shell体验主机 (开始菜单、操作中心)
|
||
'searchui.exe', # Cortana/搜索界面
|
||
'applicationframehost.exe', # UWP应用框架
|
||
'systemsettings.exe', # 设置
|
||
'taskmgr.exe' # 任务管理器
|
||
}
|
||
if process_name in excluded_system_processes:
|
||
# logger.debug(f"前景窗口进程 '{process_name}' 在排除列表 (系统进程), 排除.")
|
||
return False
|
||
title_buffer = ctypes.create_unicode_buffer(256)
|
||
user32.GetWindowTextW(hwnd, title_buffer, 256)
|
||
window_title_lower = title_buffer.value.strip().lower()
|
||
# logger.debug(f"前景窗口标题: '{title_buffer.value}' (小写: '{window_title_lower}')")
|
||
# 排除特定窗口标题
|
||
excluded_system_window_titles = {
|
||
"program manager", # 桌面窗口
|
||
"windows input experience", # 输入法相关
|
||
"msctfmonitor window", # 输入法相关
|
||
"startmenuexperiencehost" # 开始菜单
|
||
}
|
||
if window_title_lower in excluded_system_window_titles:
|
||
# logger.debug(f"前景窗口标题 '{window_title_lower}' 在排除列表 (系统窗口), 排除.")
|
||
return False
|
||
rect = RECT()
|
||
user32.GetWindowRect(hwnd, ctypes.byref(rect))
|
||
# 使用桌面窗口作为屏幕尺寸参考
|
||
screen_rect_desktop = RECT()
|
||
user32.GetWindowRect(user32.GetDesktopWindow(), ctypes.byref(screen_rect_desktop))
|
||
# logger.debug(f"窗口矩形: 左={rect.left}, 上={rect.top}, 右={rect.right}, 下={rect.bottom}")
|
||
# logger.debug(f"桌面矩形: 左={screen_rect_desktop.left}, 上={screen_rect_desktop.top}, 右={screen_rect_desktop.right}, 下={screen_rect_desktop.bottom}")
|
||
is_covering_screen = (
|
||
rect.left <= screen_rect_desktop.left and
|
||
rect.top <= screen_rect_desktop.top and
|
||
rect.right >= screen_rect_desktop.right and
|
||
rect.bottom >= screen_rect_desktop.bottom
|
||
)
|
||
if is_covering_screen:
|
||
screen_area = (screen_rect_desktop.right - screen_rect_desktop.left) * (screen_rect_desktop.bottom - screen_rect_desktop.top)
|
||
window_area = (rect.right - rect.left) * (rect.bottom - rect.top)
|
||
is_fullscreen = window_area >= screen_area * 0.95
|
||
# logger.debug(f"覆盖屏幕: {is_covering_screen}, 窗口面积: {window_area}, 屏幕面积: {screen_area}, 是否全屏判断: {is_fullscreen}")
|
||
return is_fullscreen
|
||
return False
|
||
|
||
|
||
class ErrorDialog(Dialog): # 重大错误提示框
|
||
def __init__(self, error_details='Traceback (most recent call last):', parent=None):
|
||
# KeyboardInterrupt 直接 exit
|
||
if error_details.endswith('KeyboardInterrupt') or error_details.endswith('KeyboardInterrupt\n'):
|
||
stop()
|
||
|
||
super().__init__(
|
||
'Class Widgets 崩溃报告',
|
||
'抱歉！Class Widgets 发生了严重的错误从而无法正常运行。您可以保存下方的错误信息并向他人求助。'
|
||
'若您认为这是程序的Bug，请点击“报告此问题”或联系开发者。',
|
||
parent
|
||
)
|
||
global error_dialog
|
||
error_dialog = True
|
||
|
||
self.is_dragging = False
|
||
self.drag_position = QPoint()
|
||
self.title_bar_height = 30
|
||
|
||
self.title_layout = QHBoxLayout()
|
||
|
||
self.iconLabel = ImageLabel()
|
||
self.iconLabel.setImage(f"{base_directory}/img/logo/favicon-error.ico")
|
||
self.error_log = PlainTextEdit()
|
||
self.report_problem = PushButton(fIcon.FEEDBACK, '报告此问题')
|
||
self.copy_log_btn = PushButton(fIcon.COPY, '复制日志')
|
||
self.ignore_error_btn = PushButton(fIcon.INFO, '忽略错误')
|
||
self.ignore_same_error = CheckBox()
|
||
self.ignore_same_error.setText('在下次启动之前，忽略此错误')
|
||
self.restart_btn = PrimaryPushButton(fIcon.SYNC, '重新启动')
|
||
|
||
self.iconLabel.setScaledContents(True)
|
||
self.iconLabel.setFixedSize(50, 50)
|
||
self.titleLabel.setText('出错啦！ヽ(*。>Д<)o゜')
|
||
self.titleLabel.setStyleSheet("font-family: Microsoft YaHei UI; font-size: 25px; font-weight: 500;")
|
||
self.error_log.setReadOnly(True)
|
||
self.error_log.setPlainText(error_details)
|
||
self.error_log.setFixedHeight(200)
|
||
self.restart_btn.setFixedWidth(150)
|
||
self.yesButton.hide()
|
||
self.cancelButton.hide() # 隐藏取消按钮
|
||
self.title_layout.setSpacing(12)
|
||
|
||
# 按钮事件
|
||
self.report_problem.clicked.connect(
|
||
lambda: QDesktopServices.openUrl(QUrl(
|
||
'https://github.com/Class-Widgets/Class-Widgets/issues/'
|
||
'new?assignees=&labels=Bug&projects=&template=BugReport.yml&title=[Bug]:'))
|
||
)
|
||
self.copy_log_btn.clicked.connect(self.copy_log)
|
||
self.ignore_error_btn.clicked.connect(self.ignore_error)
|
||
self.restart_btn.clicked.connect(restart)
|
||
|
||
self.title_layout.addWidget(self.iconLabel) # 标题布局
|
||
self.title_layout.addWidget(self.titleLabel)
|
||
self.textLayout.insertLayout(0, self.title_layout) # 页面
|
||
self.textLayout.addWidget(self.error_log)
|
||
self.textLayout.addWidget(self.ignore_same_error)
|
||
self.buttonLayout.insertStretch(0, 1) # 按钮布局
|
||
self.buttonLayout.insertWidget(0, self.copy_log_btn)
|
||
self.buttonLayout.insertWidget(1, self.report_problem)
|
||
self.buttonLayout.insertStretch(1)
|
||
self.buttonLayout.insertWidget(4, self.ignore_error_btn)
|
||
self.buttonLayout.insertWidget(5, self.restart_btn)
|
||
|
||
def copy_log(self): # 复制日志
|
||
QApplication.clipboard().setText(self.error_log.toPlainText())
|
||
Flyout.create(
|
||
icon=InfoBarIcon.SUCCESS,
|
||
title='复制成功！ヾ(^▽^*)))',
|
||
content="日志已成功复制到剪贴板。",
|
||
target=self.copy_log_btn,
|
||
parent=self,
|
||
isClosable=True,
|
||
aniType=FlyoutAnimationType.PULL_UP
|
||
)
|
||
|
||
def ignore_error(self):
|
||
global ignore_errors
|
||
if self.ignore_same_error.isChecked():
|
||
ignore_errors.append(self.error_log.toPlainText())
|
||
self.close()
|
||
|
||
def mousePressEvent(self, event):
|
||
if event.button() == Qt.LeftButton and event.y() <= self.title_bar_height:
|
||
self.is_dragging = True
|
||
self.drag_position = event.globalPos() - self.frameGeometry().topLeft()
|
||
|
||
def mouseMoveEvent(self, event):
|
||
if self.is_dragging:
|
||
self.move(event.globalPos() - self.drag_position)
|
||
|
||
def mouseReleaseEvent(self, event):
|
||
if event.button() == Qt.LeftButton:
|
||
self.is_dragging = False
|
||
|
||
|
||
|
||
class PluginManager: # 插件管理器
|
||
def __init__(self):
|
||
self.cw_contexts = {}
|
||
self.get_app_contexts()
|
||
self.temp_window = []
|
||
self.method = PluginMethod(self.cw_contexts)
|
||
|
||
def get_app_contexts(self, path=None):
|
||
self.cw_contexts = {
|
||
"Widgets_Width": list_.widget_width,
|
||
"Widgets_Name": list_.widget_name,
|
||
"Widgets_Code": list_.widget_conf, # 小组件列表
|
||
|
||
"Current_Lesson": current_lesson_name, # 当前课程名
|
||
"State": current_state, # 0：课间 1：上课（上下课状态）
|
||
"Current_Part": get_part(), # 返回开始时间、Part序号
|
||
"Next_Lessons_text": get_next_lessons_text(), # 下节课程
|
||
"Next_Lessons": next_lessons, # 下节课程
|
||
"Current_Lessons": current_lessons, # 当前课程
|
||
"Current_Week": current_week, # 当前周次
|
||
"Excluded_Lessons": excluded_lessons, # 排除的课程
|
||
|
||
"Current_Time": current_time, # 当前时间
|
||
"Timeline_Data": timeline_data, # 时间线数据
|
||
"Parts_Start_Time": parts_start_time, # 节点开始时间
|
||
"Parts_Type": parts_type, # 节点类型
|
||
"Time_Offset": time_offset, # 时差偏移
|
||
|
||
"Schedule_Name": config_center.schedule_name, # 课程表名称
|
||
"Loaded_Data": loaded_data, # 加载的课程表数据
|
||
"Order": order, # 课程顺序
|
||
|
||
"Weather": weather_name, # 天气情况
|
||
"Temp": temperature, # 温度
|
||
"Weather_Data": weather_data_temp, # 天气数据
|
||
"Weather_Icon": weather_icon, # 天气图标
|
||
"Weather_API": config_center.read_conf('Weather', 'api'), # 天气API
|
||
"City": city, # 城市代码
|
||
|
||
"Notification": notification.notification_contents, # 检测到的通知内容
|
||
"Last_Notify_Time": last_notify_time, # 上次通知时间
|
||
|
||
"PLUGIN_PATH": os.path.normpath(os.path.join(conf.PLUGINS_DIR, path)) if path else conf.PLUGINS_DIR, # 传递插件目录
|
||
"Config_Center": config_center, # 配置中心实例
|
||
"Schedule_Center": schedule_center, # 课程表中心实例
|
||
"Base_Directory": base_directory, # 资源目录
|
||
"Widgets_Mgr": mgr, # 组件管理器实例
|
||
"Theme": theme, # 当前主题
|
||
}
|
||
return self.cw_contexts
|
||
|
||
|
||
class PluginMethod: # 插件方法
|
||
def __init__(self, app_context):
|
||
self.app_contexts = app_context
|
||
|
||
def register_widget(self, widget_code, widget_name, widget_width): # 注册小组件
|
||
self.app_contexts['Widgets_Width'][widget_code] = widget_width
|
||
self.app_contexts['Widgets_Name'][widget_code] = widget_name
|
||
self.app_contexts['Widgets_Code'][widget_name] = widget_code
|
||
|
||
def adjust_widget_width(self, widget_code, width): # 调整小组件宽度
|
||
self.app_contexts['Widgets_Width'][widget_code] = width
|
||
|
||
@staticmethod
|
||
def get_widget(widget_code): # 获取小组件实例
|
||
for widget in mgr.widgets:
|
||
if widget.path == widget_code:
|
||
return widget
|
||
return None
|
||
|
||
@staticmethod
|
||
def change_widget_content(widget_code, title, content): # 修改小组件内容
|
||
for widget in mgr.widgets:
|
||
if widget.path == widget_code:
|
||
widget.update_widget_for_plugin([title, content])
|
||
|
||
@staticmethod
|
||
def is_get_notification(): # 检查是否有通知
|
||
if notification.pushed_notification:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
@staticmethod
|
||
def send_notification(state=1, lesson_name='示例课程', title='通知示例', subtitle='副标题',
|
||
content='这是一条通知示例', icon=None, duration=2000): # 发送通知
|
||
notification.main(state, lesson_name, title, subtitle, content, icon, duration)
|
||
|
||
@staticmethod
|
||
def subprocess_exec(title, action): # 执行系统命令
|
||
w = openProgressDialog(title, action)
|
||
p_mgr.temp_window = [w]
|
||
w.show()
|
||
|
||
@staticmethod
|
||
def read_config(path, section, option): # 读取配置文件
|
||
try:
|
||
with open(path, 'r', encoding='utf-8') as r:
|
||
config = json.load(r)
|
||
return config.get(section, option)
|
||
except Exception as e:
|
||
logger.error(f"插件读取配置文件失败：{e}")
|
||
|
||
@staticmethod
|
||
def generate_speech(
|
||
text: str,
|
||
engine: str = "edge",
|
||
voice: Optional[str] = None,
|
||
timeout: float = 10.0,
|
||
auto_fallback: bool = True
|
||
|
||
) -> str:
|
||
"""
|
||
同步生成语音文件（供插件调用）
|
||
|
||
参数：
|
||
text (str): 要转换的文本（支持中英文混合）
|
||
engine (str): 首选的TTS引擎（默认edge）
|
||
voice (str): 指定语音ID（可选，默认自动选择）
|
||
timeout (float): 超时时间（秒，默认10）
|
||
auto_fallback (bool): 是否自动回退引擎（默认True）
|
||
|
||
返回：
|
||
str: 生成的音频文件路径
|
||
"""
|
||
return generate_speech_sync(
|
||
text=text,
|
||
engine=engine,
|
||
voice=voice,
|
||
auto_fallback=auto_fallback,
|
||
timeout=timeout
|
||
)
|
||
|
||
@staticmethod
|
||
def play_audio(file_path: str, tts_delete_after: bool = True):
|
||
"""
|
||
播放音频文件
|
||
|
||
参数：
|
||
file_path (str): 要播放的音频文件路径
|
||
tts_delete_after (bool): 播放后是否删除文件（默认True）
|
||
|
||
说明：
|
||
- 删除操作有重试机制（3次尝试）
|
||
"""
|
||
play_audio(file_path, tts_delete_after)
|
||
|
||
|
||
class WidgetsManager:
|
||
def __init__(self):
|
||
self.widgets = [] # 小组件实例
|
||
self.widgets_list = [] # 小组件列表配置
|
||
self.state = 1
|
||
|
||
self.widgets_width = 0 # 小组件总宽度
|
||
self.spacing = 0 # 小组件间隔
|
||
|
||
self.start_pos_x = 0 # 小组件起始位置
|
||
self.start_pos_y = 0
|
||
|
||
self.hide_status = None # [0] -> 在 current_state 设置的灵活隐藏， [1] -> 隐藏模式
|
||
|
||
def sync_widget_animation(self, target_pos):
|
||
for widget in self.widgets:
|
||
if widget.path == 'widget-current-activity.ui':
|
||
widget.animate_expand(target_pos) # 主组件形变动画
|
||
|
||
def init_widgets(self): # 初始化小组件
|
||
self.widgets_list = list_.get_widget_config()
|
||
self.check_widgets_exist()
|
||
self.spacing = conf.load_theme_config(theme)['spacing']
|
||
|
||
self.get_start_pos()
|
||
cnt_all = {}
|
||
|
||
# 添加小组件实例
|
||
for w in range(len(self.widgets_list)):
|
||
cnt_all[self.widgets_list[w]] = cnt_all.get(self.widgets_list[w], -1) + 1
|
||
widget = DesktopWidget(self, self.widgets_list[w], True if w == 0 else False,cnt = cnt_all[self.widgets_list[w]], position=self.get_widget_pos("", w), widget_cnt = w)
|
||
self.widgets.append(widget)
|
||
|
||
self.create_widgets()
|
||
|
||
def close_all_widgets(self):
|
||
# 统一关闭所有组件
|
||
if hasattr(self, '_closing'):
|
||
return
|
||
self._closing = True
|
||
for widget in self.widgets:
|
||
widget.close() # 触发各个widget的closeEvent
|
||
|
||
def check_widgets_exist(self):
|
||
for widget in self.widgets_list:
|
||
if widget not in list_.widget_width.keys():
|
||
self.widgets_list.remove(widget)
|
||
|
||
@staticmethod
|
||
def get_widget_width(path):
|
||
try:
|
||
width = conf.load_theme_width(theme)[path]
|
||
except KeyError:
|
||
width = list_.widget_width[path]
|
||
return int(width)
|
||
|
||
@staticmethod
|
||
def get_widgets_height():
|
||
return int(conf.load_theme_config(theme)['height'])
|
||
|
||
def create_widgets(self):
|
||
for widget in self.widgets:
|
||
widget.show()
|
||
logger.info(f'显示小组件：{widget.path, widget.windowTitle()}')
|
||
|
||
def adjust_ui(self): # 更新小组件UI
|
||
for widget in self.widgets:
|
||
# 调整窗口尺寸
|
||
width = self.get_widget_width(widget.path)
|
||
height = self.get_widgets_height()
|
||
pos_x = self.get_widget_pos(widget.path, widget.widget_cnt)[0]
|
||
op = int(config_center.read_conf('General', 'opacity')) / 100
|
||
|
||
if widget.animation is None:
|
||
widget.widget_transition(pos_x, width, height, op)
|
||
|
||
def get_widget_pos(self, path, cnt=None): # 获取小组件位置
|
||
num = self.widgets_list.index(path) if cnt is None else cnt
|
||
self.get_start_pos()
|
||
pos_x = self.start_pos_x + self.spacing * num
|
||
for i in range(num):
|
||
try:
|
||
pos_x += conf.load_theme_width(theme)[self.widgets_list[i]]
|
||
except KeyError:
|
||
pos_x += list_.widget_width[self.widgets_list[i]]
|
||
except:
|
||
pos_x += 0
|
||
return [int(pos_x), int(self.start_pos_y)]
|
||
|
||
def get_start_pos(self):
|
||
self.calculate_widgets_width()
|
||
screen_geometry = app.primaryScreen().availableGeometry()
|
||
screen_width = screen_geometry.width()
|
||
screen_height = screen_geometry.height()
|
||
|
||
margin = max(0, int(config_center.read_conf('General', 'margin')))
|
||
self.start_pos_y = margin
|
||
self.start_pos_x = (screen_width - self.widgets_width) // 2
|
||
|
||
def calculate_widgets_width(self): # 计算小组件占用宽度
|
||
self.widgets_width = 0
|
||
# 累加小组件宽度
|
||
for widget in self.widgets_list:
|
||
try:
|
||
self.widgets_width += self.get_widget_width(widget)
|
||
except Exception as e:
|
||
logger.warning(f'计算小组件宽度发生错误：{e}')
|
||
self.widgets_width += 0
|
||
|
||
self.widgets_width += self.spacing * (len(self.widgets_list) - 1)
|
||
|
||
def hide_windows(self):
|
||
self.state = 0
|
||
for widget in self.widgets:
|
||
widget.animate_hide()
|
||
|
||
def full_hide_windows(self):
|
||
self.state = 0
|
||
for widget in self.widgets:
|
||
widget.animate_hide(True)
|
||
|
||
def show_windows(self):
|
||
if fw.animating: # 避免动画Bug
|
||
return
|
||
if fw.isVisible():
|
||
fw.close()
|
||
self.state = 1
|
||
for widget in self.widgets:
|
||
widget.animate_show()
|
||
|
||
def clear_widgets(self):
|
||
global fw, was_floating_mode
|
||
if fw and fw.isVisible():
|
||
fw.close()
|
||
was_floating_mode = True
|
||
else:
|
||
was_floating_mode = False
|
||
for widget in self.widgets:
|
||
widget.animate_hide_opacity()
|
||
for widget in self.widgets:
|
||
self.widgets.remove(widget)
|
||
init()
|
||
|
||
def update_widgets(self):
|
||
c = 0
|
||
self.adjust_ui()
|
||
|
||
for widget in self.widgets:
|
||
if c == 0:
|
||
get_countdown(True)
|
||
widget.update_data(path=widget.path)
|
||
c += 1
|
||
p_loader.update_plugins()
|
||
|
||
if notification.pushed_notification:
|
||
notification.pushed_notification = False
|
||
|
||
def decide_to_hide(self):
|
||
if config_center.read_conf('General', 'hide_method') == '0': # 正常
|
||
self.hide_windows()
|
||
elif config_center.read_conf('General', 'hide_method') == '1': # 单击即完全隐藏
|
||
self.full_hide_windows()
|
||
elif config_center.read_conf('General', 'hide_method') == '2': # 最小化为浮窗
|
||
if not fw.animating:
|
||
self.full_hide_windows()
|
||
fw.show()
|
||
else:
|
||
self.hide_windows()
|
||
|
||
def cleanup_resources(self):
|
||
self.hide_status = None # 重置hide_status
|
||
widgets_to_clean = list(self.widgets)
|
||
self.widgets.clear()
|
||
for widget in widgets_to_clean:
|
||
widget_path = getattr(widget, 'path', '未知组件')
|
||
try:
|
||
if hasattr(widget, 'weather_timer') and widget.weather_timer:
|
||
try:
|
||
widget.weather_timer.stop()
|
||
except RuntimeError:
|
||
pass
|
||
if hasattr(widget, 'weather_thread') and widget.weather_thread:
|
||
try:
|
||
if widget.weather_thread.isRunning():
|
||
widget.weather_thread.quit()
|
||
if not widget.weather_thread.wait(500):
|
||
logger.warning(f"组件 {widget_path} 的天气线程未正常退出，强制终止")
|
||
widget.weather_thread.terminate()
|
||
widget.weather_thread.wait()
|
||
except RuntimeError:
|
||
pass
|
||
widget.deleteLater()
|
||
except Exception as ex:
|
||
logger.error(f"清理组件 {widget_path} 时发生异常: {ex}")
|
||
|
||
def stop(self):
|
||
if mgr:
|
||
mgr.cleanup_resources()
|
||
for widget in self.widgets:
|
||
widget.stop()
|
||
if self.animation:
|
||
self.animation.stop()
|
||
if self.opacity_animation:
|
||
self.opacity_animation.stop()
|
||
self.close()
|
||
|
||
class openProgressDialog(QWidget):
|
||
def __init__(self, action_title='打开 记事本', action='notepad'):
|
||
super().__init__()
|
||
self.setWindowFlags(self.windowFlags() | Qt.WindowStaysOnTopHint | Qt.Tool)
|
||
time = int(config_center.read_conf('Plugin', 'auto_delay'))
|
||
self.action = action
|
||
|
||
screen_geometry = app.primaryScreen().availableGeometry()
|
||
self.screen_width = screen_geometry.width()
|
||
self.screen_height = screen_geometry.height()
|
||
self.init_ui()
|
||
self.init_font()
|
||
self.move((self.screen_width - self.width()) // 2, self.screen_height - self.height() - 100)
|
||
|
||
self.action_name = self.findChild(QLabel, 'action_name')
|
||
self.action_name.setText(action_title)
|
||
|
||
self.opening_countdown = self.findChild(ProgressRing, 'opening_countdown')
|
||
self.opening_countdown.setRange(0, time - 1)
|
||
self.progress_timer = QTimer(self)
|
||
self.progress_timer.timeout.connect(self.update_progress)
|
||
self.progress_timer.start(1000)
|
||
|
||
self.timer = QTimer(self)
|
||
self.timer.timeout.connect(self.execute_action)
|
||
self.timer.start(time * 1000)
|
||
|
||
self.cancel_opening = self.findChild(QPushButton, 'cancel_opening')
|
||
self.cancel_opening.clicked.connect(self.cancel_action)
|
||
|
||
self.intro_animation()
|
||
|
||
def update_progress(self):
|
||
self.opening_countdown.setValue(self.opening_countdown.value() + 1)
|
||
|
||
def execute_action(self):
|
||
self.timer.stop()
|
||
subprocess.Popen(self.action)
|
||
self.close()
|
||
|
||
def cancel_action(self):
|
||
self.timer.stop()
|
||
self.close()
|
||
|
||
def save_position(self):
|
||
pass
|
||
|
||
def init_ui(self):
|
||
self.setWindowFlags(
|
||
Qt.WindowType.FramelessWindowHint | Qt.WindowType.WindowStaysOnTopHint |
|
||
Qt.X11BypassWindowManagerHint # 绕过窗口管理器以在全屏显示通知
|
||
)
|
||
self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
|
||
|
||
if isDarkTheme():
|
||
uic.loadUi(f'{base_directory}/ui/default/dark/toast-open_dialog.ui', self)
|
||
else:
|
||
uic.loadUi(f'{base_directory}/ui/default/toast-open_dialog.ui', self)
|
||
|
||
backgnd = self.findChild(QFrame, 'backgnd')
|
||
shadow_effect = QGraphicsDropShadowEffect(self)
|
||
shadow_effect.setBlurRadius(28)
|
||
shadow_effect.setXOffset(0)
|
||
shadow_effect.setYOffset(6)
|
||
shadow_effect.setColor(QColor(0, 0, 0, 80))
|
||
backgnd.setGraphicsEffect(shadow_effect)
|
||
|
||
def init_font(self):
|
||
font_path = f'{base_directory}/font/HarmonyOS_Sans_SC_Bold.ttf'
|
||
font_id = QFontDatabase.addApplicationFont(font_path)
|
||
if font_id != -1:
|
||
font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
|
||
|
||
self.setStyleSheet(f"""
|
||
QLabel, ProgressRing, PushButton{{
|
||
font-family: "{font_family}";
|
||
font-weight: bold
|
||
}}
|
||
""")
|
||
|
||
def intro_animation(self): # 弹出动画
|
||
self.setMinimumWidth(300)
|
||
label_width = self.action_name.sizeHint().width() - 120
|
||
self.animation = QPropertyAnimation(self, b'windowOpacity')
|
||
self.animation.setDuration(400)
|
||
self.animation.setStartValue(0)
|
||
self.animation.setEndValue(1)
|
||
self.animation.setEasingCurve(QEasingCurve.Type.InOutCirc)
|
||
|
||
self.animation_rect = QPropertyAnimation(self, b'geometry')
|
||
self.animation_rect.setDuration(450)
|
||
self.animation_rect.setStartValue(
|
||
QRect(self.x(), self.screen_height, self.width(), self.height())
|
||
)
|
||
self.animation_rect.setEndValue(
|
||
QRect((self.screen_width - (self.width() + label_width)) // 2,
|
||
self.screen_height - 250,
|
||
self.width() + label_width,
|
||
self.height())
|
||
)
|
||
self.animation_rect.setEasingCurve(QEasingCurve.Type.InOutCirc)
|
||
|
||
self.animation.start()
|
||
self.animation_rect.start()
|
||
|
||
def closeEvent(self, event):
|
||
event.ignore()
|
||
self.setMinimumWidth(0)
|
||
self.position = self.pos()
|
||
# 关闭时保存一次位置
|
||
self.save_position()
|
||
self.deleteLater()
|
||
self.hide()
|
||
p_mgr.temp_window.clear()
|
||
|
||
|
||
class FloatingWidget(QWidget): # 浮窗
|
||
def __init__(self):
|
||
super().__init__()
|
||
self.setWindowFlags(self.windowFlags() | Qt.WindowStaysOnTopHint | Qt.Tool)
|
||
self.animation_rect = None
|
||
self.animation = None
|
||
self.m_Position = None
|
||
self.p_Position = None
|
||
self.m_flag = None
|
||
self.r_Position = None
|
||
self._is_topmost_callback_added = False
|
||
self.init_ui()
|
||
self.init_font()
|
||
self.position = None
|
||
self.animating = False
|
||
self.focusing = False
|
||
self.text_changed = False
|
||
|
||
self.current_lesson_name_text = self.findChild(QLabel, 'subject')
|
||
self.activity_countdown = self.findChild(QLabel, 'activity_countdown')
|
||
self.countdown_progress_bar = self.findChild(ProgressRing, 'progressBar')
|
||
|
||
self.setFocusPolicy(Qt.FocusPolicy.NoFocus)
|
||
self.setAttribute(Qt.WA_TransparentForMouseEvents, False)
|
||
|
||
# 动态获取屏幕尺寸
|
||
screen_geometry = QApplication.primaryScreen().availableGeometry()
|
||
screen_width = screen_geometry.width()
|
||
screen_height = screen_geometry.height()
|
||
|
||
# 加载保存的位置
|
||
saved_pos = self.load_position()
|
||
if saved_pos:
|
||
# 边界检查
|
||
saved_pos = self.adjust_position_to_screen(saved_pos)
|
||
self.position = saved_pos
|
||
else:
|
||
# 使用动态计算的默认位置
|
||
self.position = QPoint(
|
||
(screen_width - self.width()) // 2, # 居中横向
|
||
50 # 距离顶部 50px
|
||
)
|
||
|
||
update_timer.add_callback(self.update_data)
|
||
|
||
def adjust_position_to_screen(self, pos):
|
||
screen = QApplication.screenAt(pos)
|
||
if not screen:
|
||
screen = QApplication.primaryScreen()
|
||
screen_geometry = screen.availableGeometry()
|
||
window_width = self.width()
|
||
window_height = self.height()
|
||
# 计算屏幕边界
|
||
screen_left = screen_geometry.x()
|
||
screen_right = screen_geometry.x() + screen_geometry.width()
|
||
screen_top = screen_geometry.y()
|
||
screen_bottom = screen_geometry.y() + screen_geometry.height()
|
||
|
||
new_x, new_y = pos.x(), pos.y()
|
||
if pos.x() < screen_left:
|
||
# 当窗口可见部分不足50%时调整
|
||
visible_width = (pos.x() + window_width) - screen_left
|
||
if visible_width < window_width / 2:
|
||
new_x = screen_left
|
||
elif (pos.x() + window_width) > screen_right:
|
||
visible_width = screen_right - pos.x()
|
||
if visible_width < window_width / 2:
|
||
new_x = screen_right - window_width
|
||
if pos.y() < screen_top:
|
||
visible_height = (pos.y() + window_height) - screen_top
|
||
if visible_height < window_height / 2:
|
||
new_y = screen_top
|
||
elif (pos.y() + window_height) > screen_bottom:
|
||
visible_height = screen_bottom - pos.y()
|
||
if visible_height < window_height / 2:
|
||
new_y = screen_bottom - window_height
|
||
return QPoint(new_x, new_y)
|
||
|
||
def _ensure_topmost(self):
|
||
# 始终处于顶层
|
||
if active_windows:
|
||
return
|
||
if os.name == 'nt':
|
||
try:
|
||
hwnd = self.winId().__int__()
|
||
if ctypes.windll.user32.IsWindow(hwnd):
|
||
HWND_TOPMOST = -1
|
||
SWP_NOMOVE = 0x0002
|
||
SWP_NOSIZE = 0x0001
|
||
SWP_SHOWWINDOW = 0x0040
|
||
SWP_NOACTIVATE = 0x0010
|
||
ctypes.windll.user32.SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOSIZE | SWP_SHOWWINDOW)
|
||
self.raise_()
|
||
else:
|
||
if self._is_topmost_callback_added:
|
||
try:
|
||
utils.update_timer.remove_callback(self._ensure_topmost)
|
||
except ValueError:
|
||
pass # 可能已经被移除了
|
||
self._is_topmost_callback_added = False
|
||
logger.debug(f"句柄 {hwnd} 无效，已移除置顶回调。")
|
||
except RuntimeError as e:
|
||
if 'Internal C++ object' in str(e) and 'already deleted' in str(e):
|
||
logger.debug(f"尝试访问已删除的 FloatingWidget 时出错，移除回调: {e}")
|
||
if self._is_topmost_callback_added:
|
||
try:
|
||
utils.update_timer.remove_callback(self._ensure_topmost)
|
||
except ValueError:
|
||
pass # 可能已经被移除了
|
||
self._is_topmost_callback_added = False
|
||
else:
|
||
logger.error(f"检查或设置浮窗置顶时发生运行时错误: {e}")
|
||
except Exception as e:
|
||
logger.error(f"检查或设置浮窗置顶时出错: {e}")
|
||
if self._is_topmost_callback_added:
|
||
try:
|
||
utils.update_timer.remove_callback(self._ensure_topmost)
|
||
except ValueError:
|
||
pass
|
||
self._is_topmost_callback_added = False
|
||
logger.debug(f"因错误 {e} 移除浮窗置顶回调。")
|
||
|
||
def save_position(self):
|
||
current_screen = QApplication.screenAt(self.pos())
|
||
if not current_screen:
|
||
current_screen = QApplication.primaryScreen()
|
||
screen_geometry = current_screen.availableGeometry()
|
||
pos = self.pos()
|
||
x = pos.x()
|
||
window_width = self.width()
|
||
if mgr.state:
|
||
return
|
||
screen_left = screen_geometry.left()
|
||
screen_right = screen_geometry.right()
|
||
if x < screen_left:
|
||
visible_width = (x + window_width) - screen_left
|
||
if visible_width < window_width / 2:
|
||
x = screen_left
|
||
elif (x + window_width) > screen_right:
|
||
if self.animating:
|
||
return
|
||
visible_width = screen_right - x
|
||
if visible_width < window_width / 2:
|
||
x = screen_right - window_width
|
||
y = min(max(pos.y(), screen_geometry.top()), screen_geometry.bottom())
|
||
pos = QPoint(x, y)
|
||
config_center.write_conf('FloatingWidget', 'pos_x', str(pos.x()))
|
||
if not self.animating:
|
||
config_center.write_conf('FloatingWidget', 'pos_y', str(pos.y()))
|
||
|
||
def load_position(self):
|
||
x = config_center.read_conf('FloatingWidget', 'pos_x')
|
||
y = config_center.read_conf('FloatingWidget', 'pos_y')
|
||
if x and y:
|
||
return QPoint(int(x), int(y))
|
||
return None
|
||
|
||
def init_ui(self):
|
||
setTheme_()
|
||
if os.path.exists(f'{base_directory}/ui/{theme}/widget-floating.ui'):
|
||
if isDarkTheme() and conf.load_theme_config(theme)['support_dark_mode']:
|
||
uic.loadUi(f'{base_directory}/ui/{theme}/dark/widget-floating.ui', self)
|
||
else:
|
||
uic.loadUi(f'{base_directory}/ui/{theme}/widget-floating.ui', self)
|
||
else:
|
||
if isDarkTheme() and conf.load_theme_config(theme)['support_dark_mode']:
|
||
uic.loadUi(f'{base_directory}/ui/default/dark/widget-floating.ui', self)
|
||
else:
|
||
uic.loadUi(f'{base_directory}/ui/default/widget-floating.ui', self)
|
||
|
||
# 设置窗口无边框和透明背景
|
||
self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
|
||
|
||
# 根据平台和设置应用窗口标志
|
||
if sys.platform == 'darwin':
|
||
flags = Qt.WindowType.FramelessWindowHint | Qt.WindowType.WindowStaysOnTopHint | Qt.WindowType.Widget | Qt.X11BypassWindowManagerHint
|
||
else:
|
||
flags = Qt.WindowType.FramelessWindowHint | Qt.WindowType.WindowStaysOnTopHint | Qt.WindowType.Tool | Qt.X11BypassWindowManagerHint
|
||
|
||
self.setWindowFlags(flags)
|
||
|
||
# 始终添加置顶回调逻辑
|
||
if os.name == 'nt':
|
||
if not self._is_topmost_callback_added:
|
||
try:
|
||
if hasattr(utils, 'update_timer') and utils.update_timer:
|
||
utils.update_timer.add_callback(self._ensure_topmost)
|
||
self._is_topmost_callback_added = True
|
||
self._ensure_topmost() # 立即执行一次确保初始置顶
|
||
else:
|
||
logger.warning("utils.update_timer 不可用，无法为浮窗添加置顶回调。")
|
||
except Exception as e:
|
||
logger.error(f"为浮窗添加置顶回调时出错: {e}")
|
||
|
||
if sys.platform == 'darwin':
|
||
self.setWindowFlags(
|
||
Qt.WindowType.FramelessWindowHint | Qt.WindowType.WindowStaysOnTopHint |
|
||
Qt.WindowType.Widget | # macOS 失焦时仍然显示
|
||
Qt.X11BypassWindowManagerHint # 绕过窗口管理器以在全屏显示通知
|
||
)
|
||
else:
|
||
self.setWindowFlags(Qt.WindowType.FramelessWindowHint | Qt.WindowType.WindowStaysOnTopHint |
|
||
Qt.WindowType.Tool |
|
||
Qt.X11BypassWindowManagerHint # 绕过窗口管理器以在全屏显示通知
|
||
)
|
||
|
||
backgnd = self.findChild(QFrame, 'backgnd')
|
||
shadow_effect = QGraphicsDropShadowEffect(self)
|
||
shadow_effect.setBlurRadius(28)
|
||
shadow_effect.setXOffset(0)
|
||
shadow_effect.setYOffset(6)
|
||
shadow_effect.setColor(QColor(0, 0, 0, 75))
|
||
backgnd.setGraphicsEffect(shadow_effect)
|
||
|
||
def init_font(self):
|
||
font_path = f'{base_directory}/font/HarmonyOS_Sans_SC_Bold.ttf'
|
||
font_id = QFontDatabase.addApplicationFont(font_path)
|
||
if font_id != -1:
|
||
font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
|
||
|
||
self.setStyleSheet(f"""
|
||
QLabel, ProgressRing{{
|
||
font-family: "{font_family}";
|
||
}}
|
||
""")
|
||
|
||
def update_data(self):
|
||
time_color = QColor(f'#{config_center.read_conf("Color", "floating_time")}')
|
||
self.activity_countdown.setStyleSheet(f"color: {time_color.name()};")
|
||
if self.animating: # 执行动画时跳过更新
|
||
return
|
||
if platform.system() == 'Windows' and platform.release() != '7':
|
||
self.setWindowOpacity(int(config_center.read_conf('General', 'opacity')) / 100) # 设置窗口透明度
|
||
else:
|
||
self.setWindowOpacity(1.0)
|
||
cd_list = get_countdown()
|
||
self.text_changed = False
|
||
if self.current_lesson_name_text.text() != current_lesson_name:
|
||
self.text_changed = True
|
||
|
||
self.current_lesson_name_text.setText(current_lesson_name)
|
||
|
||
if cd_list: # 模糊倒计时
|
||
blur_floating = config_center.read_conf('General', 'blur_floating_countdown') == '1'
|
||
if blur_floating: # 模糊显示
|
||
if cd_list[1] == '00:00':
|
||
self.activity_countdown.setText(f"< - 分钟")
|
||
else:
|
||
minutes = int(cd_list[1].split(':')[0]) + 1
|
||
self.activity_countdown.setText(f"< {minutes} 分钟")
|
||
else: # 精确显示
|
||
self.activity_countdown.setText(cd_list[1])
|
||
self.countdown_progress_bar.setValue(cd_list[2])
|
||
|
||
self.adjustSize_animation()
|
||
|
||
self.update()
|
||
|
||
def showEvent(self, event): # 窗口显示
|
||
logger.info('显示浮窗')
|
||
current_screen = QApplication.screenAt(self.pos()) or QApplication.primaryScreen()
|
||
screen_geometry = current_screen.availableGeometry()
|
||
|
||
if self.position:
|
||
if self.position.y() > screen_geometry.center().y():
|
||
# 下半屏
|
||
start_pos = QPoint(
|
||
self.position.x(),
|
||
screen_geometry.bottom() + self.height()
|
||
)
|
||
else:
|
||
# 上半屏
|
||
start_pos = QPoint(
|
||
self.position.x(),
|
||
screen_geometry.top() - self.height()
|
||
)
|
||
else:
|
||
# 默认:顶部中央滑入
|
||
start_pos = QPoint(
|
||
(screen_geometry.width() - self.width()) // 2,
|
||
screen_geometry.top() - self.height()
|
||
)
|
||
self.position = QPoint(
|
||
(screen_geometry.width() - self.width()) // 2,
|
||
max(50, int(config_center.read_conf('General', 'margin')))
|
||
)
|
||
|
||
self.animation = QPropertyAnimation(self, b'windowOpacity')
|
||
self.animation.setDuration(450)
|
||
self.animation.setStartValue(0)
|
||
self.animation.setEndValue(int(config_center.read_conf('General', 'opacity')) / 100)
|
||
self.animation.setEasingCurve(QEasingCurve.Type.OutCubic)
|
||
|
||
self.animation_rect = QPropertyAnimation(self, b'geometry')
|
||
self.animation_rect.setDuration(600)
|
||
self.animation_rect.setStartValue(QRect(start_pos, self.size()))
|
||
self.animation_rect.setEndValue(QRect(self.position, self.size()))
|
||
|
||
if platform.system() == 'Darwin':
|
||
self.animation_rect.setEasingCurve(QEasingCurve.Type.OutQuad)
|
||
elif platform.system() == 'Windows':
|
||
self.animation_rect.setEasingCurve(QEasingCurve.Type.OutBack)
|
||
else:
|
||
self.animation_rect.setEasingCurve(QEasingCurve.Type.OutCubic)
|
||
|
||
self.animating = True
|
||
self.animation.start()
|
||
self.animation_rect.start()
|
||
self.animation_rect.finished.connect(self.animation_done)
|
||
|
||
def animation_done(self):
|
||
self.animating = False
|
||
|
||
def closeEvent(self, event):
|
||
# 跳过动画
|
||
if QApplication.instance().closingDown():
|
||
self.save_position()
|
||
event.accept()
|
||
return
|
||
event.ignore()
|
||
self.setMinimumWidth(0)
|
||
self.position = self.pos()
|
||
self.save_position()
|
||
current_screen = QApplication.screenAt(self.pos())
|
||
if not current_screen:
|
||
current_screen = QApplication.primaryScreen()
|
||
screen_geometry = current_screen.availableGeometry()
|
||
screen_center_y = screen_geometry.y() + (screen_geometry.height() // 2)
|
||
# 动态动画
|
||
current_pos = self.pos()
|
||
base_duration = 350 # 基础
|
||
max_duration = 550 # 最大
|
||
min_duration = 250 # 最小
|
||
# 获取主组件位置
|
||
main_widget = next(
|
||
(w for w in mgr.widgets if w.path == 'widget-current-activity.ui'),
|
||
None
|
||
)
|
||
if main_widget:
|
||
if current_pos.y() > screen_center_y: # 下半屏
|
||
# 屏幕底部
|
||
target_y = screen_geometry.bottom() + self.height() + 10
|
||
# 任务栏补偿
|
||
if platform.system() == "Windows":
|
||
target_y += 30
|
||
|
||
target_pos = QPoint(
|
||
main_widget.x(),
|
||
target_y
|
||
)
|
||
distance = abs(current_pos.y() - target_y)
|
||
else: # 上半屏
|
||
target_pos = main_widget.pos()
|
||
distance = abs(current_pos.y() - target_pos.y())
|
||
else:
|
||
target_pos = QPoint(
|
||
screen_geometry.center().x() - self.width() // 2,
|
||
int(config_center.read_conf('General', 'margin'))
|
||
)
|
||
distance = abs(current_pos.y() - target_pos.y())
|
||
|
||
max_distance = screen_geometry.height()
|
||
distance_ratio = min(distance / max_distance, 1.0)
|
||
duration = int(base_duration + (max_duration - base_duration) * (distance_ratio ** 0.7))
|
||
duration = max(min_duration, min(duration, max_duration))
|
||
# 多平台兼容
|
||
if platform.system() == "Darwin":
|
||
curve = QEasingCurve.Type.OutQuad
|
||
duration = int(duration * 0.85)
|
||
elif platform.system() == "Windows":
|
||
curve = QEasingCurve.Type.OutCubic
|
||
if current_pos.y() > screen_center_y:
|
||
duration += 50 # 底部移动稍慢
|
||
curve = QEasingCurve.Type.InOutQuad
|
||
|
||
self.animation = QPropertyAnimation(self, b"windowOpacity")
|
||
self.animation.setDuration(int(duration * 1.15))
|
||
self.animation.setStartValue(self.windowOpacity())
|
||
self.animation.setEndValue(0.0)
|
||
|
||
self.animation_rect = QPropertyAnimation(self, b"geometry")
|
||
self.animation_rect.setDuration(duration)
|
||
self.animation_rect.setStartValue(self.geometry())
|
||
self.animation_rect.setEndValue(QRect(target_pos, self.size()))
|
||
self.animation_rect.setEasingCurve(curve)
|
||
|
||
self.animating = True
|
||
self.animation.start()
|
||
self.animation_rect.start()
|
||
|
||
def cleanup():
|
||
self.hide()
|
||
self.save_position()
|
||
self.animating = False
|
||
if self._is_topmost_callback_added:
|
||
try:
|
||
utils.update_timer.remove_callback(self._ensure_topmost)
|
||
except ValueError:
|
||
pass
|
||
self._is_topmost_callback_added = False
|
||
|
||
self.animation_rect.finished.connect(cleanup)
|
||
|
||
def hideEvent(self, event):
|
||
event.accept()
|
||
logger.info('隐藏浮窗')
|
||
self.animating = False
|
||
self.setMinimumSize(QSize(self.width(), self.height()))
|
||
|
||
def adjustSize_animation(self):
|
||
if not self.text_changed:
|
||
return
|
||
self.setMinimumWidth(200)
|
||
current_geometry = self.geometry()
|
||
label_width = self.current_lesson_name_text.sizeHint().width() + 120
|
||
offset = label_width - current_geometry.width()
|
||
target_geometry = current_geometry.adjusted(0, 0, offset, 0)
|
||
self.animation = QPropertyAnimation(self, b'geometry')
|
||
self.animation.setDuration(450)
|
||
self.animation.setStartValue(current_geometry)
|
||
self.animation.setEndValue(target_geometry)
|
||
self.animation.setEasingCurve(QEasingCurve.Type.InOutCirc)
|
||
self.animating = True # 避免动画Bug x114514
|
||
self.animation.start()
|
||
self.animation.finished.connect(self.animation_done)
|
||
|
||
def mousePressEvent(self, event):
|
||
if event.button() == Qt.MouseButton.LeftButton:
|
||
self.m_flag = True
|
||
self.m_Position = event.globalPos() - self.pos() # 获取鼠标相对窗口的位置
|
||
self.p_Position = event.globalPos() # 获取鼠标相对屏幕的位置
|
||
event.accept()
|
||
|
||
def mouseMoveEvent(self, event):
|
||
if event.buttons() == Qt.MouseButton.LeftButton and self.m_flag:
|
||
self.move(event.globalPos() - self.m_Position) # 更改窗口位置
|
||
event.accept()
|
||
|
||
def mouseReleaseEvent(self, event):
|
||
self.r_Position = event.globalPos() # 获取鼠标相对窗口的位置
|
||
self.m_flag = False
|
||
# 保存位置到配置文件
|
||
self.save_position()
|
||
# 特定隐藏模式下不执行操作
|
||
hide_mode = config_center.read_conf('General', 'hide')
|
||
if hide_mode == '1' or hide_mode == '2':
|
||
return # 阻止手动展开/收起
|
||
if (
|
||
hasattr(self, "p_Position")
|
||
and self.r_Position == self.p_Position
|
||
and not self.animating
|
||
): # 非特定隐藏模式下执行点击事件
|
||
if hide_mode == '3':
|
||
if mgr.state:
|
||
mgr.decide_to_hide()
|
||
mgr.hide_status = (current_state, 1)
|
||
else:
|
||
mgr.show_windows()
|
||
mgr.hide_status = (current_state, 0)
|
||
elif hide_mode == '1':
|
||
mgr.show_windows()
|
||
self.close()
|
||
|
||
def focusInEvent(self, event):
|
||
self.focusing = True
|
||
|
||
def focusOutEvent(self, event):
|
||
self.focusing = False
|
||
|
||
def stop(self):
|
||
if mgr:
|
||
mgr.cleanup_resources()
|
||
for widget in self.widgets:
|
||
widget.stop()
|
||
if self.animation:
|
||
self.animation.stop()
|
||
if self.opacity_animation:
|
||
self.opacity_animation.stop()
|
||
self.close()
|
||
|
||
class DesktopWidget(QWidget): # 主要小组件
|
||
def __init__(self, parent=WidgetsManager, path='widget-time.ui', enable_tray=False, cnt=0, position=None, widget_cnt = None):
|
||
super().__init__()
|
||
self.setWindowFlags(self.windowFlags() | Qt.WindowStaysOnTopHint | Qt.Tool)
|
||
|
||
self.cnt = cnt
|
||
self.widget_cnt = widget_cnt
|
||
|
||
self.tray_menu = None
|
||
|
||
self.last_widgets = list_.get_widget_config()
|
||
self.path = path
|
||
|
||
self.last_code = 101010100
|
||
self.radius = conf.load_theme_config(theme)['radius']
|
||
self.last_theme = config_center.read_conf('General', 'theme')
|
||
self.last_color_mode = config_center.read_conf('General', 'color_mode')
|
||
self.w = 100
|
||
|
||
# 天气预警动画相关
|
||
self.weather_alert_timer = None
|
||
self.weather_alert_animation = None
|
||
self.weather_alert_text = None
|
||
self.alert_showing = False
|
||
|
||
self.position = parent.get_widget_pos(self.path) if position is None else position
|
||
self.animation = None
|
||
self.opacity_animation = None
|
||
mgr.hide_status = None
|
||
self._is_topmost_callback_added = False # 添加一个标志来跟踪回调是否已添加
|
||
|
||
try:
|
||
self.w = conf.load_theme_config(theme)['widget_width'][self.path]
|
||
except KeyError:
|
||
self.w = list_.widget_width[self.path]
|
||
self.h = conf.load_theme_config(theme)['height']
|
||
|
||
init_config()
|
||
self.init_ui(path)
|
||
self.init_font()
|
||
|
||
if enable_tray:
|
||
self.init_tray_menu() # 初始化托盘菜单
|
||
|
||
# 样式
|
||
self.backgnd = self.findChild(QFrame, 'backgnd')
|
||
if self.backgnd is None:
|
||
self.backgnd = self.findChild(QLabel, 'backgnd')
|
||
|
||
stylesheet = self.backgnd.styleSheet() # 应用圆角
|
||
updated_stylesheet = re.sub(r'border-radius:\d+px;', f'border-radius:{self.radius}px;', stylesheet)
|
||
self.backgnd.setStyleSheet(updated_stylesheet)
|
||
|
||
if path == 'widget-time.ui': # 日期显示
|
||
self.date_text = self.findChild(QLabel, 'date_text')
|
||
self.date_text.setText(f'{today.year} 年 {today.month} 月')
|
||
self.day_text = self.findChild(QLabel, 'day_text')
|
||
self.day_text.setText(f'{today.day}日 {list_.week[today.weekday()]}')
|
||
|
||
elif path == 'widget-countdown.ui': # 活动倒计时
|
||
self.countdown_progress_bar = self.findChild(QProgressBar, 'progressBar')
|
||
self.activity_countdown = self.findChild(QLabel, 'activity_countdown')
|
||
self.ac_title = self.findChild(QLabel, 'activity_countdown_title')
|
||
|
||
elif path == 'widget-current-activity.ui': # 当前活动
|
||
self.current_subject = self.findChild(QPushButton, 'subject')
|
||
self.blur_effect_label = self.findChild(QLabel, 'blurEffect')
|
||
# 模糊效果
|
||
self.blur_effect = QGraphicsBlurEffect()
|
||
self.current_subject.mouseReleaseEvent = self.rightReleaseEvent
|
||
|
||
update_timer.add_callback(self.detect_theme_changed)
|
||
|
||
elif path == 'widget-next-activity.ui': # 接下来的活动
|
||
self.nl_text = self.findChild(QLabel, 'next_lesson_text')
|
||
|
||
elif path == 'widget-countdown-day.ui': # 自定义倒计时
|
||
self.custom_title = self.findChild(QLabel, 'countdown_custom_title')
|
||
self.custom_countdown = self.findChild(QLabel, 'custom_countdown')
|
||
|
||
elif path == 'widget-weather.ui': # 天气组件
|
||
content_layout = self.findChild(QHBoxLayout, 'horizontalLayout_2')
|
||
content_layout.setSpacing(1)
|
||
self.temperature = self.findChild(QLabel, 'temperature')
|
||
self.weather_icon = self.findChild(QLabel, 'weather_icon')
|
||
self.alert_icon = IconWidget(self)
|
||
self.alert_icon.setFixedSize(22,22)
|
||
self.alert_icon.hide()
|
||
|
||
# 预警标签
|
||
self.weather_alert_text = QLabel(self)
|
||
self.weather_alert_text.setAlignment(Qt.AlignCenter)
|
||
self.weather_alert_text.setStyleSheet(self.temperature.styleSheet())
|
||
self.weather_alert_text.setFont(self.temperature.font())
|
||
self.weather_alert_text.hide()
|
||
content_layout.addWidget(self.alert_icon)
|
||
content_layout.addWidget(self.weather_alert_text)
|
||
|
||
self.weather_alert_timer = None
|
||
self.weather_alert_opacity = QGraphicsOpacityEffect(self)
|
||
self.weather_alert_opacity.setOpacity(1.0)
|
||
self.weather_alert_text.setGraphicsEffect(self.weather_alert_opacity)
|
||
self.weather_alert_animation = QPropertyAnimation(self.weather_alert_opacity, b"opacity")
|
||
self.weather_alert_animation.setDuration(700)
|
||
self.weather_alert_animation.setEasingCurve(QEasingCurve.OutCubic)
|
||
self.alert_icon_opacity = QGraphicsOpacityEffect(self)
|
||
self.alert_icon_opacity.setOpacity(1.0)
|
||
self.alert_icon.setGraphicsEffect(self.alert_icon_opacity)
|
||
self.alert_icon_animation = QPropertyAnimation(self.alert_icon_opacity, b"opacity")
|
||
self.alert_icon_animation.setDuration(700)
|
||
self.alert_icon_animation.setEasingCurve(QEasingCurve.OutCubic)
|
||
|
||
self.showing_temperature = True # 跟踪状态(预警/气温)
|
||
|
||
self.get_weather_data()
|
||
self.weather_timer = QTimer(self)
|
||
self.weather_timer.setInterval(30 * 60 * 1000) # 30分钟更新一次
|
||
self.weather_timer.timeout.connect(self.get_weather_data)
|
||
self.weather_timer.start()
|
||
update_timer.add_callback(self.detect_weather_code_changed)
|
||
|
||
if hasattr(self, 'img'): # 自定义图片主题兼容
|
||
img = self.findChild(QLabel, 'img')
|
||
if platform.system() == 'Windows' and platform.release() != '7':
|
||
opacity = QGraphicsOpacityEffect(self)
|
||
opacity.setOpacity(0.65)
|
||
img.setGraphicsEffect(opacity)
|
||
|
||
self.resize(self.w, self.height())
|
||
|
||
# 设置窗口位置
|
||
if first_start:
|
||
self.animate_window(self.position)
|
||
if platform.system() == 'Windows' and platform.release() != '7':
|
||
self.setWindowOpacity(int(config_center.read_conf('General', 'opacity')) / 100)
|
||
else:
|
||
self.setWindowOpacity(1.0)
|
||
else:
|
||
self.move(self.position[0], self.position[1])
|
||
self.resize(self.w, self.height())
|
||
if platform.system() == 'Windows' and platform.release() != '7':
|
||
self.setWindowOpacity(0)
|
||
self.animate_show_opacity()
|
||
else:
|
||
self.setWindowOpacity(1.0)
|
||
self.show()
|
||
|
||
self.update_data('')
|
||
|
||
@staticmethod
|
||
def _onThemeChangedFinished():
|
||
print('theme_changed')
|
||
|
||
def update_widget_for_plugin(self, context=None):
|
||
if context is None:
|
||
context = ['title', 'desc']
|
||
try:
|
||
title = self.findChild(QLabel, 'title')
|
||
desc = self.findChild(QLabel, 'content')
|
||
if title is not None:
|
||
title.setText(context[0])
|
||
if desc is not None:
|
||
desc.setText(context[1])
|
||
except Exception as e:
|
||
logger.error(f"更新插件小组件时出错：{e}")
|
||
|
||
def init_ui(self, path):
|
||
if conf.load_theme_config(theme)['support_dark_mode']:
|
||
if os.path.exists(f'{base_directory}/ui/{theme}/{path}'):
|
||
if isDarkTheme():
|
||
uic.loadUi(f'{base_directory}/ui/{theme}/dark/{path}', self)
|
||
else:
|
||
uic.loadUi(f'{base_directory}/ui/{theme}/{path}', self)
|
||
else:
|
||
if isDarkTheme():
|
||
uic.loadUi(f'{base_directory}/ui/{theme}/dark/widget-base.ui', self)
|
||
else:
|
||
uic.loadUi(f'{base_directory}/ui/{theme}/widget-base.ui', self)
|
||
else:
|
||
if os.path.exists(f'{base_directory}/ui/{theme}/{path}'):
|
||
uic.loadUi(f'{base_directory}/ui/{theme}/{path}', self)
|
||
else:
|
||
uic.loadUi(f'{base_directory}/ui/{theme}/widget-base.ui', self)
|
||
|
||
# 设置窗口无边框和透明背景
|
||
self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
|
||
|
||
if config_center.read_conf('General', 'hide') == '2' or (not int(config_center.read_conf('General', 'enable_click'))):
|
||
self.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents)
|
||
else:
|
||
self.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents, False)
|
||
|
||
if config_center.read_conf('General', 'pin_on_top') == '1': # 置顶
|
||
self.setWindowFlags(
|
||
Qt.WindowType.FramelessWindowHint | Qt.WindowType.WindowStaysOnTopHint |
|
||
Qt.WindowType.WindowDoesNotAcceptFocus | Qt.X11BypassWindowManagerHint # 绕过窗口管理器以在全屏显示通知
|
||
)
|
||
# 修改为使用定时器确保持续置顶
|
||
if os.name == 'nt':
|
||
if not self._is_topmost_callback_added:
|
||
try:
|
||
# 确保 utils.update_timer 存在且有效
|
||
if hasattr(utils, 'update_timer') and utils.update_timer:
|
||
utils.update_timer.add_callback(self._ensure_topmost)
|
||
self._is_topmost_callback_added = True
|
||
self._ensure_topmost() # 立即执行一次确保初始置顶
|
||
# logger.debug("已添加置顶定时回调。")
|
||
else:
|
||
logger.warning("utils.update_timer 不可用，无法添加置顶回调。")
|
||
except Exception as e:
|
||
logger.error(f"添加置顶回调时出错: {e}")
|
||
|
||
elif config_center.read_conf('General', 'pin_on_top') == '2': # 置底
|
||
# 避免使用WindowStaysOnBottomHint,防止争夺底层
|
||
self.setWindowFlags(
|
||
Qt.WindowType.FramelessWindowHint |
|
||
Qt.WindowType.WindowDoesNotAcceptFocus
|
||
)
|
||
if os.name == 'nt':
|
||
def set_window_pos():
|
||
hwnd = self.winId().__int__()
|
||
# 稍高于最底层的值
|
||
ctypes.windll.user32.SetWindowPos(hwnd, 2, 0, 0, 0, 0, 0x0214)
|
||
QTimer.singleShot(100, set_window_pos)
|
||
else:
|
||
QTimer.singleShot(100, self.lower)
|
||
else:
|
||
self.setWindowFlags(
|
||
Qt.WindowType.FramelessWindowHint
|
||
)
|
||
|
||
if sys.platform == 'darwin':
|
||
self.setWindowFlag(Qt.WindowType.Widget, True)
|
||
else:
|
||
self.setWindowFlag(Qt.WindowType.Tool, True)
|
||
|
||
def _ensure_topmost(self):
|
||
# 突然忘记写移除了,不写了,应该没事(
|
||
if active_windows:
|
||
return
|
||
if os.name == 'nt':
|
||
try:
|
||
hwnd = self.winId().__int__()
|
||
if ctypes.windll.user32.IsWindow(hwnd):
|
||
HWND_TOPMOST = -1
|
||
SWP_NOMOVE = 0x0002
|
||
SWP_NOSIZE = 0x0001
|
||
SWP_SHOWWINDOW = 0x0040
|
||
SWP_NOACTIVATE = 0x0010
|
||
ctypes.windll.user32.SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOSIZE | SWP_SHOWWINDOW)
|
||
self.raise_()
|
||
else:
|
||
if self._is_topmost_callback_added:
|
||
try:
|
||
utils.update_timer.remove_callback(self._ensure_topmost)
|
||
except ValueError:
|
||
pass # 可能已经被移除了
|
||
self._is_topmost_callback_added = False
|
||
logger.debug(f"窗口句柄 {hwnd} 无效，已自动移除置顶回调。")
|
||
except RuntimeError as e:
|
||
if 'Internal C++ object' in str(e) and 'already deleted' in str(e):
|
||
logger.debug(f"尝试访问已删除的 DesktopWidget 时出错，移除回调: {e}")
|
||
if self._is_topmost_callback_added:
|
||
try:
|
||
utils.update_timer.remove_callback(self._ensure_topmost)
|
||
except ValueError:
|
||
pass # 可能已经被移除了
|
||
self._is_topmost_callback_added = False
|
||
else:
|
||
logger.error(f"检查或设置窗口置顶时发生运行时错误: {e}")
|
||
except Exception as e:
|
||
logger.error(f"检查或设置窗口置顶时出错: {e}")
|
||
if self._is_topmost_callback_added:
|
||
try:
|
||
utils.update_timer.remove_callback(self._ensure_topmost)
|
||
except ValueError:
|
||
pass
|
||
self._is_topmost_callback_added = False
|
||
logger.debug(f"因错误 {e} 移除置顶回调。")
|
||
|
||
def closeEvent(self, event):
|
||
if self._is_topmost_callback_added:
|
||
try:
|
||
utils.update_timer.remove_callback(self._ensure_topmost)
|
||
self._is_topmost_callback_added = False
|
||
# logger.debug("窗口关闭，已移除置顶回调。")
|
||
except ValueError:
|
||
logger.debug("尝试移除不存在的置顶回调。")
|
||
except Exception as e:
|
||
logger.error(f"关闭窗口时移除置顶回调出错: {e}")
|
||
super().closeEvent(event)
|
||
|
||
self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
|
||
|
||
# 添加阴影效果
|
||
if conf.load_theme_config(theme)['shadow']: # 修改阴影问题
|
||
shadow_effect = QGraphicsDropShadowEffect(self)
|
||
shadow_effect.setBlurRadius(28)
|
||
shadow_effect.setXOffset(0)
|
||
shadow_effect.setYOffset(6)
|
||
shadow_effect.setColor(QColor(0, 0, 0, 75))
|
||
|
||
self.backgnd.setGraphicsEffect(shadow_effect)
|
||
|
||
def init_font(self):
|
||
font_path = f'{base_directory}/font/HarmonyOS_Sans_SC_Bold.ttf'
|
||
font_id = QFontDatabase.addApplicationFont(font_path)
|
||
if font_id != -1:
|
||
font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
|
||
|
||
self.setStyleSheet(f"""
|
||
QLabel, QPushButton{{
|
||
font-family: "{font_family}";
|
||
}}
|
||
""")
|
||
|
||
def animate_expand(self, target_geometry):
|
||
self.animation = QPropertyAnimation(self, b"geometry")
|
||
self.animation.setDuration(400)
|
||
self.animation.setStartValue(QRect(target_geometry.x(), -self.height(),
|
||
self.width(), self.height()))
|
||
self.animation.setEndValue(target_geometry)
|
||
self.animation.setEasingCurve(QEasingCurve.Type.OutBack)
|
||
self.raise_()
|
||
self.show()
|
||
|
||
def init_tray_menu(self):
|
||
if not first_start:
|
||
return
|
||
|
||
utils.tray_icon = utils.TrayIcon(self)
|
||
utils.tray_icon.setToolTip(f"Class Widgets - {config_center.schedule_name[:-5]}")
|
||
self.tray_menu = SystemTrayMenu(title='Class Widgets', parent=self)
|
||
self.tray_menu.addActions([
|
||
Action(fIcon.HIDE, '完全隐藏/显示小组件', triggered=lambda: self.hide_show_widgets()),
|
||
Action(fIcon.BACK_TO_WINDOW, '最小化为浮窗', triggered=lambda: self.minimize_to_floating()),
|
||
])
|
||
self.tray_menu.addSeparator()
|
||
self.tray_menu.addActions([
|
||
Action(fIcon.SHOPPING_CART, '插件广场', triggered=open_plaza),
|
||
Action(fIcon.DEVELOPER_TOOLS, '额外选项', triggered=self.open_extra_menu),
|
||
Action(fIcon.SETTING, '设置', triggered=open_settings)
|
||
])
|
||
self.tray_menu.addSeparator()
|
||
self.tray_menu.addAction(Action(fIcon.SYNC, '重新启动', triggered=restart))
|
||
self.tray_menu.addAction(Action(fIcon.CLOSE, '退出', triggered=stop))
|
||
utils.tray_icon.setContextMenu(self.tray_menu)
|
||
|
||
utils.tray_icon.activated.connect(self.on_tray_icon_clicked)
|
||
utils.tray_icon.show()
|
||
|
||
@staticmethod
|
||
def on_tray_icon_clicked(reason): # 点击托盘图标隐藏
|
||
if config_center.read_conf('General', 'hide') == '0':
|
||
if reason == QSystemTrayIcon.ActivationReason.Trigger:
|
||
if mgr.state:
|
||
mgr.decide_to_hide()
|
||
else:
|
||
mgr.show_windows()
|
||
elif config_center.read_conf('General', 'hide') == '3':
|
||
if reason == QSystemTrayIcon.ActivationReason.Trigger:
|
||
if mgr.state:
|
||
mgr.decide_to_hide()
|
||
mgr.hide_status = (current_state, 1)
|
||
else:
|
||
mgr.show_windows()
|
||
mgr.hide_status = (current_state, 0)
|
||
|
||
|
||
|
||
def rightReleaseEvent(self, event): # 右键事件
|
||
event.ignore()
|
||
if event.button() == Qt.MouseButton.RightButton:
|
||
self.open_extra_menu()
|
||
|
||
def update_data(self, path=''):
|
||
global current_time, current_week, start_y, time_offset, today
|
||
|
||
today = dt.date.today()
|
||
current_time = dt.datetime.now().strftime('%H:%M:%S')
|
||
time_offset = conf.get_time_offset()
|
||
|
||
get_start_time()
|
||
get_current_lessons()
|
||
get_current_lesson_name()
|
||
get_excluded_lessons()
|
||
get_next_lessons()
|
||
hide_status = get_hide_status()
|
||
|
||
if (hide_mode:=config_center.read_conf('General', 'hide')) in ['1','2']: # 上课自动隐藏
|
||
if hide_status:
|
||
mgr.decide_to_hide()
|
||
else:
|
||
mgr.show_windows()
|
||
elif hide_mode == '3': # 灵活隐藏
|
||
if mgr.hide_status is None:
|
||
mgr.hide_status = (-1, hide_status)
|
||
elif mgr.hide_status[0] != current_state:
|
||
mgr.hide_status = (-1, hide_status)
|
||
if mgr.hide_status[1]:
|
||
mgr.decide_to_hide()
|
||
else:
|
||
mgr.show_windows()
|
||
|
||
|
||
|
||
if conf.is_temp_week(): # 调休日
|
||
current_week = config_center.read_conf('Temp', 'set_week')
|
||
else:
|
||
current_week = dt.datetime.now().weekday()
|
||
|
||
cd_list = get_countdown()
|
||
|
||
if path == 'widget-time.ui': # 日期显示
|
||
self.date_text.setText(f'{today.year} 年 {today.month} 月')
|
||
self.day_text.setText(f'{today.day} 日 {list_.week[today.weekday()]}')
|
||
|
||
if path == 'widget-current-activity.ui': # 当前活动
|
||
self.current_subject.setText(f' {current_lesson_name}')
|
||
|
||
if current_state != 2: # 非休息段
|
||
render = QSvgRenderer(list_.get_subject_icon(current_lesson_name))
|
||
self.blur_effect_label.setStyleSheet(
|
||
f'background-color: rgba{list_.subject_color(current_lesson_name)}, 200);'
|
||
)
|
||
else: # 休息段
|
||
render = QSvgRenderer(list_.get_subject_icon('课间'))
|
||
self.blur_effect_label.setStyleSheet(
|
||
f'background-color: rgba{list_.subject_color("课间")}, 200);'
|
||
)
|
||
pixmap = QPixmap(render.defaultSize())
|
||
pixmap.fill(Qt.GlobalColor.transparent)
|
||
|
||
painter = QPainter(pixmap)
|
||
render.render(painter)
|
||
if (isDarkTheme() and conf.load_theme_config(theme)['support_dark_mode']
|
||
or isDarkTheme() and conf.load_theme_config(theme)['default_theme'] == 'dark'): # 在暗色模式显示亮色图标
|
||
painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_SourceIn)
|
||
painter.fillRect(pixmap.rect(), QColor("#FFFFFF"))
|
||
painter.end()
|
||
|
||
self.current_subject.setIcon(QIcon(pixmap))
|
||
self.blur_effect.setBlurRadius(25) # 模糊半径
|
||
self.blur_effect_label.setGraphicsEffect(self.blur_effect)
|
||
|
||
elif path == 'widget-next-activity.ui': # 接下来的活动
|
||
self.nl_text.setText(get_next_lessons_text())
|
||
|
||
if path == 'widget-countdown.ui': # 活动倒计时
|
||
if cd_list:
|
||
if config_center.read_conf('General', 'blur_countdown') == '1': # 模糊倒计时
|
||
if cd_list[1] == '00:00':
|
||
self.activity_countdown.setText(f"< - 分钟")
|
||
else:
|
||
self.activity_countdown.setText(f"< {int(cd_list[1].split(':')[0]) + 1} 分钟")
|
||
else:
|
||
self.activity_countdown.setText(cd_list[1])
|
||
self.ac_title.setText(cd_list[0])
|
||
self.countdown_progress_bar.setValue(cd_list[2])
|
||
|
||
if path == 'widget-countdown-day.ui': # 自定义倒计时
|
||
conf.update_countdown(self.cnt)
|
||
self.custom_title.setText(f'距离 {conf.get_cd_text_custom()} 还有')
|
||
self.custom_countdown.setText(conf.get_custom_countdown())
|
||
self.update()
|
||
|
||
def get_weather_data(self):
|
||
logger.info('获取天气数据')
|
||
self.weather_thread = weatherReportThread()
|
||
self.weather_thread.weather_signal.connect(self.update_weather_data)
|
||
self.weather_thread.start()
|
||
|
||
def detect_weather_code_changed(self):
|
||
current_code = config_center.read_conf('Weather')
|
||
if current_code != self.last_code:
|
||
self.last_code = current_code
|
||
self.get_weather_data()
|
||
|
||
def toggle_weather_alert(self):
|
||
if not hasattr(self, 'weather_alert_level') or not self.weather_alert_level:
|
||
# logger.warning("未获取到天气预警等级")
|
||
return
|
||
if not hasattr(self, 'weather_alert_text') or not self.weather_alert_text.text():
|
||
# logger.warning("未获取到天气预警文本")
|
||
return
|
||
if self.showing_temperature:
|
||
# 切换预警
|
||
self.weather_alert_animation.setStartValue(0.0)
|
||
self.weather_alert_animation.setEndValue(1.0)
|
||
self.alert_icon_animation.setStartValue(0.0)
|
||
self.alert_icon_animation.setEndValue(1.0)
|
||
# 渐隐
|
||
self.weather_opacity = QGraphicsOpacityEffect(self.weather_icon)
|
||
self.temperature_opacity = QGraphicsOpacityEffect(self.temperature)
|
||
self.weather_icon.setGraphicsEffect(self.weather_opacity)
|
||
self.temperature.setGraphicsEffect(self.temperature_opacity)
|
||
weather_fade_out = QPropertyAnimation(self.weather_opacity, b'opacity')
|
||
temp_fade_out = QPropertyAnimation(self.temperature_opacity, b'opacity')
|
||
weather_fade_out.setDuration(700)
|
||
temp_fade_out.setDuration(700)
|
||
weather_fade_out.setEasingCurve(QEasingCurve.Type.OutCubic)
|
||
temp_fade_out.setEasingCurve(QEasingCurve.Type.OutCubic)
|
||
weather_fade_out.setStartValue(1.0)
|
||
weather_fade_out.setEndValue(0.0)
|
||
temp_fade_out.setStartValue(1.0)
|
||
temp_fade_out.setEndValue(0.0)
|
||
# 重置不透明度
|
||
self.fade_out_group = QParallelAnimationGroup(self)
|
||
self.fade_out_group.addAnimation(weather_fade_out)
|
||
self.fade_out_group.addAnimation(temp_fade_out)
|
||
if not hasattr(self, 'weather_alert_opacity') or not self.weather_alert_opacity:
|
||
self.weather_alert_opacity = QGraphicsOpacityEffect(self.weather_alert_text)
|
||
self.weather_alert_text.setGraphicsEffect(self.weather_alert_opacity)
|
||
if not hasattr(self, 'alert_icon_opacity') or not self.alert_icon_opacity:
|
||
self.alert_icon_opacity = QGraphicsOpacityEffect(self.alert_icon)
|
||
self.alert_icon.setGraphicsEffect(self.alert_icon_opacity)
|
||
|
||
alert_text_fade_in = QPropertyAnimation(self.weather_alert_opacity, b'opacity')
|
||
alert_icon_fade_in = QPropertyAnimation(self.alert_icon_opacity, b'opacity')
|
||
alert_text_fade_in.setDuration(700)
|
||
alert_icon_fade_in.setDuration(700)
|
||
alert_text_fade_in.setEasingCurve(QEasingCurve.Type.OutCubic)
|
||
alert_icon_fade_in.setEasingCurve(QEasingCurve.Type.OutCubic)
|
||
alert_text_fade_in.setStartValue(0.0)
|
||
alert_text_fade_in.setEndValue(1.0)
|
||
alert_icon_fade_in.setStartValue(0.0)
|
||
alert_icon_fade_in.setEndValue(1.0)
|
||
|
||
self.fade_in_group = QParallelAnimationGroup(self)
|
||
self.fade_in_group.addAnimation(alert_text_fade_in)
|
||
self.fade_in_group.addAnimation(alert_icon_fade_in)
|
||
try: self.fade_out_group.finished.disconnect()
|
||
except TypeError: pass
|
||
|
||
def _start_alert_fade_in():
|
||
if hasattr(self, 'alert_icon') and isinstance(self.alert_icon, IconWidget) and self.alert_icon.icon() is not None and not self.alert_icon.icon().isNull():
|
||
self.weather_icon.hide()
|
||
self.temperature.hide()
|
||
self.weather_alert_opacity.setOpacity(0.0)
|
||
self.alert_icon_opacity.setOpacity(0.0)
|
||
self.weather_alert_text.show()
|
||
self.alert_icon.show()
|
||
self.fade_in_group.start()
|
||
self.weather_info_timer.start(3000)
|
||
else:
|
||
self.weather_icon.show()
|
||
self.temperature.show()
|
||
if hasattr(self, 'weather_opacity'): self.weather_opacity.setOpacity(1.0)
|
||
if hasattr(self, 'temperature_opacity'): self.temperature_opacity.setOpacity(1.0)
|
||
self.showing_temperature = True
|
||
|
||
self.fade_out_group.finished.connect(_start_alert_fade_in)
|
||
|
||
self.fade_out_group.start()
|
||
else:
|
||
# 切换到气温
|
||
self.weather_alert_animation.setStartValue(1.0)
|
||
self.weather_alert_animation.setEndValue(0.0)
|
||
self.alert_icon_animation.setStartValue(1.0)
|
||
self.alert_icon_animation.setEndValue(0.0)
|
||
if not hasattr(self, 'weather_alert_opacity') or not self.weather_alert_opacity:
|
||
self.weather_alert_opacity = QGraphicsOpacityEffect(self.weather_alert_text)
|
||
self.weather_alert_text.setGraphicsEffect(self.weather_alert_opacity)
|
||
if not hasattr(self, 'alert_icon_opacity') or not self.alert_icon_opacity:
|
||
self.alert_icon_opacity = QGraphicsOpacityEffect(self.alert_icon)
|
||
self.alert_icon.setGraphicsEffect(self.alert_icon_opacity)
|
||
|
||
alert_text_fade_out = QPropertyAnimation(self.weather_alert_opacity, b'opacity')
|
||
alert_icon_fade_out = QPropertyAnimation(self.alert_icon_opacity, b'opacity')
|
||
alert_text_fade_out.setDuration(500)
|
||
alert_icon_fade_out.setDuration(500)
|
||
alert_text_fade_out.setEasingCurve(QEasingCurve.Type.OutCubic)
|
||
alert_icon_fade_out.setEasingCurve(QEasingCurve.Type.OutCubic)
|
||
alert_text_fade_out.setStartValue(1.0)
|
||
alert_text_fade_out.setEndValue(0.0)
|
||
alert_icon_fade_out.setStartValue(1.0)
|
||
alert_icon_fade_out.setEndValue(0.0)
|
||
|
||
self.fade_out_group = QParallelAnimationGroup(self)
|
||
self.fade_out_group.addAnimation(alert_text_fade_out)
|
||
self.fade_out_group.addAnimation(alert_icon_fade_out)
|
||
if not hasattr(self, 'weather_opacity') or not self.weather_opacity:
|
||
self.weather_opacity = QGraphicsOpacityEffect(self.weather_icon)
|
||
self.weather_icon.setGraphicsEffect(self.weather_opacity)
|
||
if not hasattr(self, 'temperature_opacity') or not self.temperature_opacity:
|
||
self.temperature_opacity = QGraphicsOpacityEffect(self.temperature)
|
||
self.temperature.setGraphicsEffect(self.temperature_opacity)
|
||
|
||
weather_fade_in = QPropertyAnimation(self.weather_opacity, b'opacity')
|
||
temp_fade_in = QPropertyAnimation(self.temperature_opacity, b'opacity')
|
||
weather_fade_in.setDuration(500)
|
||
temp_fade_in.setDuration(500)
|
||
weather_fade_in.setEasingCurve(QEasingCurve.Type.OutCubic)
|
||
temp_fade_in.setEasingCurve(QEasingCurve.Type.OutCubic)
|
||
weather_fade_in.setStartValue(0.0)
|
||
weather_fade_in.setEndValue(1.0)
|
||
temp_fade_in.setStartValue(0.0)
|
||
temp_fade_in.setEndValue(1.0)
|
||
|
||
self.fade_in_group = QParallelAnimationGroup(self)
|
||
self.fade_in_group.addAnimation(weather_fade_in)
|
||
self.fade_in_group.addAnimation(temp_fade_in)
|
||
try: self.fade_out_group.finished.disconnect()
|
||
except TypeError: pass
|
||
|
||
def _start_temperature_fade_in():
|
||
self.weather_alert_text.hide()
|
||
self.alert_icon.hide()
|
||
self.weather_opacity.setOpacity(0.0)
|
||
self.temperature_opacity.setOpacity(0.0)
|
||
self.weather_icon.show()
|
||
self.temperature.show()
|
||
self.fade_in_group.start()
|
||
# 连接淡出组完成信号
|
||
self.fade_out_group.finished.connect(_start_temperature_fade_in)
|
||
self.fade_out_group.start()
|
||
|
||
self.showing_temperature = not self.showing_temperature
|
||
|
||
def detect_theme_changed(self):
|
||
theme_ = config_center.read_conf('General', 'theme')
|
||
color_mode = config_center.read_conf('General', 'color_mode')
|
||
widgets = list_.get_widget_config()
|
||
if theme_ != self.last_theme or color_mode != self.last_color_mode or widgets != self.last_widgets:
|
||
self.last_theme = theme_
|
||
self.last_color_mode = color_mode
|
||
self.last_widgets = widgets
|
||
logger.info(f'切换主题：{theme_}，颜色模式{color_mode}')
|
||
mgr.clear_widgets()
|
||
|
||
def update_weather_data(self, weather_data): # 更新天气数据(已兼容多api)
|
||
global weather_name, temperature, weather_data_temp
|
||
if type(weather_data) is dict and hasattr(self, 'weather_icon') and 'error' not in weather_data:
|
||
logger.success('已获取天气数据')
|
||
alert_data = weather_data.get('alert')
|
||
weather_data = weather_data.get('now')
|
||
weather_data_temp = weather_data
|
||
|
||
weather_name = db.get_weather_by_code(db.get_weather_data('icon', weather_data))
|
||
current_city = self.findChild(QLabel, 'current_city')
|
||
try: # 天气组件
|
||
self.weather_icon.setPixmap(
|
||
QPixmap(db.get_weather_icon_by_code(db.get_weather_data('icon', weather_data)))
|
||
)
|
||
self.alert_icon.hide()
|
||
if db.is_supported_alert():
|
||
alert_type = db.get_weather_data('alert', alert_data if alert_data else weather_data)
|
||
if alert_type:
|
||
self.alert_icon.setIcon(
|
||
db.get_alert_image(alert_type)
|
||
)
|
||
self.alert_icon.hide()
|
||
try:
|
||
alert_title = db.get_weather_data('alert_title', alert_data if alert_data else weather_data)
|
||
if alert_title:
|
||
alert_type_match = re.search(r'发布(\w+)(蓝|黄|橙|红)色预警', alert_title)
|
||
if alert_type_match:
|
||
alert_type = alert_type_match.group(1) # 类型
|
||
logger.success(f'天气预警: {alert_title} --> {alert_type}预警')
|
||
alert_text = alert_type + '预警'
|
||
else:
|
||
logger.success(f'天气预警: {alert_title} --> {alert_title}')
|
||
alert_text = alert_title
|
||
self.weather_alert_text.setFixedWidth(80)
|
||
self.weather_alert_text.setFixedHeight(40)
|
||
# 调整字体大小
|
||
font = self.weather_alert_text.font()
|
||
if len(alert_text) <= 4:
|
||
font.setPointSize(14)
|
||
elif len(alert_text) <= 6:
|
||
font.setPointSize(12)
|
||
else:
|
||
font.setPointSize(10)
|
||
|
||
self.weather_alert_text.setFont(font)
|
||
self.weather_alert_text.setText(alert_text)
|
||
self.weather_alert_text.setAlignment(Qt.AlignCenter)
|
||
if not self.weather_alert_timer:
|
||
self.weather_alert_timer = QTimer(self)
|
||
self.weather_alert_timer.timeout.connect(self.toggle_weather_alert)
|
||
self.weather_alert_timer.start(6000)
|
||
self.weather_info_timer = QTimer(self)
|
||
self.weather_info_timer.timeout.connect(self.toggle_weather_alert)
|
||
self.weather_info_timer.setSingleShot(True)
|
||
except Exception as e:
|
||
logger.warning(f'获取天气预警标题失败：{e}')
|
||
self.weather_alert_text.setText('暂无预警信息')
|
||
|
||
self.temperature.setText(f"{db.get_weather_data('temp', weather_data)}")
|
||
current_city.setText(f"{db.search_by_num(config_center.read_conf('Weather', 'city'))} · "
|
||
f"{weather_name}")
|
||
update_stylesheet = re.sub(
|
||
r'border-image: url\((.*?)\);',
|
||
f"border-image: url({db.get_weather_stylesheet(db.get_weather_data('icon', weather_data))});",
|
||
self.backgnd.styleSheet()
|
||
)
|
||
self.backgnd.setStyleSheet(update_stylesheet)
|
||
except Exception as e:
|
||
logger.error(f'天气组件出错：{e}')
|
||
else:
|
||
logger.error(f'获取天气数据出错：{weather_data}')
|
||
try:
|
||
if hasattr(self, 'weather_icon'):
|
||
self.weather_icon.setPixmap(QPixmap(f'{base_directory}/img/weather/99.svg'))
|
||
self.alert_icon.hide()
|
||
self.weather_alert_text.hide()
|
||
self.temperature.setText('--°')
|
||
current_city = self.findChild(QLabel, 'current_city')
|
||
if current_city:
|
||
current_city.setText(f"{db.search_by_num(config_center.read_conf('Weather', 'city'))} · 未知")
|
||
if hasattr(self, 'backgnd'):
|
||
update_stylesheet = re.sub(
|
||
r'border-image: url\((.*?)\);',
|
||
f"border-image: url({db.get_weather_stylesheet('99')});",
|
||
self.backgnd.styleSheet()
|
||
)
|
||
self.backgnd.setStyleSheet(update_stylesheet)
|
||
except Exception as e:
|
||
logger.error(f'天气图标设置失败：{e}')
|
||
|
||
def open_extra_menu(self):
|
||
global ex_menu
|
||
if ex_menu is None or not ex_menu.isVisible():
|
||
ex_menu = ExtraMenu()
|
||
ex_menu.show()
|
||
ex_menu.destroyed.connect(self.cleanup_extra_menu)
|
||
logger.info('打开“额外选项”')
|
||
else:
|
||
ex_menu.raise_()
|
||
ex_menu.activateWindow()
|
||
|
||
@staticmethod
|
||
def cleanup_extra_menu():
|
||
global ex_menu
|
||
ex_menu = None
|
||
|
||
@staticmethod
|
||
def hide_show_widgets(): # 隐藏/显示主界面（全部隐藏）
|
||
hide_mode = config_center.read_conf('General', 'hide')
|
||
if hide_mode == '1' or hide_mode == '2':
|
||
hide_mode_text = "上课时自动隐藏" if hide_mode == '1' else "窗口最大化时隐藏"
|
||
w = Dialog(
|
||
"暂时无法变更“状态”",
|
||
f"您正在使用 {hide_mode_text} 模式，无法变更隐藏状态\n"
|
||
"若变更状态，将修改隐藏模式“灵活隐藏” (您稍后可以在“设置”中更改此选项)\n"
|
||
"您确定要隐藏组件吗?",
|
||
None
|
||
)
|
||
w.yesButton.setText("确定")
|
||
w.yesButton.clicked.connect(lambda: config_center.write_conf('General', 'hide', '3'))
|
||
w.cancelButton.setText("取消")
|
||
w.buttonLayout.insertStretch(1)
|
||
w.setFixedWidth(550)
|
||
if w.exec():
|
||
if mgr.state:
|
||
mgr.full_hide_windows()
|
||
else:
|
||
mgr.show_windows()
|
||
else:
|
||
if mgr.state:
|
||
mgr.full_hide_windows()
|
||
else:
|
||
mgr.show_windows()
|
||
|
||
@staticmethod
|
||
def minimize_to_floating(): # 最小化到浮窗
|
||
hide_mode = config_center.read_conf('General', 'hide')
|
||
if hide_mode == '1' or hide_mode == '2':
|
||
hide_mode_text = "上课时自动隐藏" if hide_mode == '1' else "窗口最大化时隐藏"
|
||
w = Dialog(
|
||
"暂时无法变更“状态”",
|
||
f"您正在使用 {hide_mode_text} 模式，无法变更隐藏状态\n"
|
||
"若变更状态，将修改隐藏模式“灵活隐藏” (您可以在“设置”中更改此选项)\n"
|
||
"您确定要隐藏组件吗?",
|
||
None
|
||
)
|
||
w.yesButton.setText("确定")
|
||
w.yesButton.clicked.connect(lambda: config_center.write_conf('General', 'hide', '3'))
|
||
w.cancelButton.setText("取消")
|
||
w.buttonLayout.insertStretch(1)
|
||
w.setFixedWidth(550)
|
||
if w.exec():
|
||
if mgr.state:
|
||
fw.show()
|
||
mgr.full_hide_windows()
|
||
else:
|
||
mgr.show_windows()
|
||
else:
|
||
if mgr.state:
|
||
fw.show()
|
||
mgr.full_hide_windows()
|
||
else:
|
||
mgr.show_windows()
|
||
|
||
def clear_animation(self): # 清除动画
|
||
self.animation = None
|
||
|
||
def animate_window(self, target_pos): # **初次**启动动画
|
||
# 创建位置动画
|
||
self.animation = QPropertyAnimation(self, b"geometry")
|
||
self.animation.setDuration(300) # 持续时间
|
||
if os.name == 'nt':
|
||
self.animation.setStartValue(QRect(target_pos[0], -self.height(), self.w, self.h))
|
||
else:
|
||
self.animation.setStartValue(QRect(target_pos[0], 0, self.w, self.h))
|
||
self.animation.setEndValue(QRect(target_pos[0], target_pos[1], self.w, self.h))
|
||
self.animation.setEasingCurve(QEasingCurve.Type.InOutCirc) # 设置动画效果
|
||
self.animation.start()
|
||
self.animation.finished.connect(self.clear_animation)
|
||
|
||
def animate_hide(self, full=False): # 隐藏窗口
|
||
self.animation = QPropertyAnimation(self, b"geometry")
|
||
self.animation.setDuration(625) # 持续时间
|
||
height = self.height()
|
||
self.setFixedHeight(height) # 防止连续打断窗口高度变小
|
||
|
||
if full and os.name == 'nt':
|
||
'''全隐藏 windows'''
|
||
self.animation.setEndValue(QRect(self.x(), -height, self.width(), self.height()))
|
||
elif os.name == 'nt':
|
||
'''半隐藏 windows'''
|
||
self.animation.setEndValue(QRect(self.x(), -height + 40, self.width(), self.height()))
|
||
else:
|
||
'''其他系统'''
|
||
self.animation.setEndValue(QRect(self.x(), 0, self.width(), self.height()))
|
||
self.animation.finished.connect(lambda: self.hide())
|
||
|
||
self.animation.setEasingCurve(QEasingCurve.Type.OutExpo) # 设置动画效果
|
||
self.animation.start()
|
||
self.animation.finished.connect(self.clear_animation)
|
||
|
||
def animate_hide_opacity(self): # 隐藏窗口透明度
|
||
self.animation = QPropertyAnimation(self, b"windowOpacity")
|
||
self.animation.setDuration(300) # 持续时间
|
||
self.animation.setStartValue(int(config_center.read_conf('General', 'opacity')) / 100)
|
||
self.animation.setEndValue(0)
|
||
self.animation.setEasingCurve(QEasingCurve.Type.InOutCirc) # 设置动画效果
|
||
self.animation.start()
|
||
self.animation.finished.connect(self.close)
|
||
|
||
def animate_show_opacity(self): # 显示窗口透明度
|
||
self.animation = QPropertyAnimation(self, b"windowOpacity")
|
||
self.animation.setDuration(350) # 持续时间
|
||
self.animation.setStartValue(0)
|
||
self.animation.setEndValue(int(config_center.read_conf('General', 'opacity')) / 100)
|
||
self.animation.setEasingCurve(QEasingCurve.Type.InOutCirc) # 设置动画效果
|
||
self.animation.start()
|
||
self.animation.finished.connect(self.clear_animation)
|
||
|
||
def animate_show(self): # 显示窗口
|
||
self.animation = QPropertyAnimation(self, b"geometry")
|
||
self.animation.setDuration(525) # 持续时间
|
||
# 获取当前窗口的宽度和高度，确保动画过程中保持一致
|
||
self.animation.setEndValue(
|
||
QRect(self.x(), int(config_center.read_conf('General', 'margin')), self.width(), self.height()))
|
||
self.animation.setEasingCurve(QEasingCurve.Type.InOutCirc) # 设置动画效果
|
||
self.animation.finished.connect(self.clear_animation)
|
||
|
||
if os.name != 'nt':
|
||
self.show()
|
||
|
||
self.animation.start()
|
||
|
||
def widget_transition(self, pos_x, width, height, opacity=1): # 窗口形变
|
||
self.animation = QPropertyAnimation(self, b"geometry")
|
||
self.animation.setDuration(525) # 持续时间
|
||
self.animation.setStartValue(QRect(self.x(), self.y(), self.width(), self.height()))
|
||
self.animation.setEndValue(QRect(pos_x, self.y(), width, height))
|
||
self.animation.setEasingCurve(QEasingCurve.Type.OutCubic) # 设置动画效果
|
||
self.animation.start()
|
||
|
||
self.opacity_animation = QPropertyAnimation(self, b"windowOpacity")
|
||
self.opacity_animation.setDuration(525) # 持续时间
|
||
self.opacity_animation.setStartValue(self.windowOpacity())
|
||
self.opacity_animation.setEndValue(opacity)
|
||
self.opacity_animation.setEasingCurve(QEasingCurve.Type.InOutCirc) # 设置动画效果
|
||
self.opacity_animation.start()
|
||
|
||
self.animation.finished.connect(self.clear_animation)
|
||
|
||
# 点击自动隐藏
|
||
def mouseReleaseEvent(self, event):
|
||
if event.button() == Qt.MouseButton.RightButton:
|
||
return # 右键不执行
|
||
if config_center.read_conf('General', 'pin_on_top') == '2': # 置底
|
||
return # 置底不执行
|
||
if config_center.read_conf('General', 'hide') == '0': # 置顶
|
||
if mgr.state:
|
||
mgr.decide_to_hide()
|
||
else:
|
||
mgr.show_windows()
|
||
elif config_center.read_conf('General', 'hide') == '3': # 隐藏
|
||
if mgr.state:
|
||
mgr.decide_to_hide()
|
||
mgr.hide_status = (current_state, 1)
|
||
else:
|
||
mgr.show_windows()
|
||
mgr.hide_status = (current_state, 0)
|
||
else:
|
||
event.ignore()
|
||
|
||
def stop(self):
|
||
if mgr:
|
||
mgr.cleanup_resources()
|
||
for widget in self.widgets:
|
||
widget.stop()
|
||
if self.animation:
|
||
self.animation.stop()
|
||
if self.opacity_animation:
|
||
self.opacity_animation.stop()
|
||
self.close()
|
||
|
||
|
||
def check_windows_maximize(): # 检查窗口是否最大化
|
||
if os.name != 'nt' or not pygetwindow:
|
||
# logger.debug("非Windows NT系统或pygetwindow未加载, 无法检查最大化.")
|
||
return False
|
||
# 需要排除的特定窗口标题 (全字匹配, 大小写不敏感)
|
||
excluded_titles_exact_lower = {
|
||
'residentsidebar', # 希沃侧边栏
|
||
'program manager', # Windows桌面
|
||
'desktop', # Windows桌面 (备用)
|
||
'snippingtool', # 系统截图工具
|
||
# '' 空标题不再默认排除
|
||
}
|
||
# 需要排除的标题中包含的关键词 (大小写不敏感)
|
||
excluded_keywords_in_title_lower = {
|
||
'overlay',
|
||
'snipping',
|
||
'sidebar',
|
||
'flyout' # qfluentwidgets的浮出控件
|
||
}
|
||
# 需要排除的进程名 (全字或部分匹配, 大小写不敏感)
|
||
excluded_process_names_lower = {
|
||
'shellexperiencehost.exe',
|
||
'searchui.exe',
|
||
'startmenuexperiencehost.exe',
|
||
'applicationframehost.exe',
|
||
'systemsettings.exe',
|
||
'taskmgr.exe'
|
||
}
|
||
# 用户自定义的忽略进程列表 (全字匹配, 大小写不敏感)
|
||
# 例：easinote.exe 每行一个，用逗号分隔
|
||
ignored_process_names_for_maximize_lower = {
|
||
'easinote.exe'
|
||
}
|
||
|
||
current_pid = os.getpid()
|
||
|
||
try:
|
||
all_windows = pygetwindow.getAllWindows()
|
||
except Exception as e:
|
||
logger.warning(f"获取窗口列表时发生错误 (pygetwindow): {str(e)}")
|
||
# logger.debug("获取窗口列表失败.")
|
||
return False
|
||
|
||
for window in all_windows:
|
||
try:
|
||
if not window._hWnd:
|
||
# logger.debug(f"窗口 '{getattr(window, 'title', 'N/A')}' 无效句柄, 跳过.")
|
||
continue
|
||
if not window.visible:
|
||
# logger.debug(f"窗口 '{window.title}' 不可见, 跳过.")
|
||
continue
|
||
if not window.isMaximized:
|
||
# logger.debug(f"窗口 '{window.title}' 未最大化, 跳过.")
|
||
continue
|
||
# logger.debug(f"发现可见且已最大化的窗口: '{window.title}' (句柄: {window._hWnd})")
|
||
try:
|
||
hwnd_int = window._hWnd
|
||
pid_val = ctypes.c_ulong()
|
||
ctypes.windll.user32.GetWindowThreadProcessId(hwnd_int, ctypes.byref(pid_val))
|
||
win_pid = pid_val.value
|
||
if win_pid == 0:
|
||
continue # 无效PID
|
||
process_name = psutil.Process(win_pid).name().lower()
|
||
except (psutil.NoSuchProcess, psutil.AccessDenied, AttributeError, ValueError, OSError) :
|
||
# logger.debug(f"无法获取窗口 '{title}' 的进程信息,跳过.")
|
||
continue
|
||
|
||
if win_pid == current_pid:
|
||
# logger.debug(f"窗口 '{title}' (PID: {win_pid}, 进程: {process_name}) 是自身进程, 排除.")
|
||
continue
|
||
|
||
title = window.title.strip()
|
||
title_lower = title.lower()
|
||
|
||
if process_name in ignored_process_names_for_maximize_lower:
|
||
# logger.debug(f"窗口 '{title}' (进程: {process_name}) 在忽略列表, 排除.")
|
||
continue
|
||
|
||
if process_name in excluded_process_names_lower:
|
||
# logger.debug(f"窗口 '{title}' (进程: {process_name}) 在排除的进程名列表, 排除.")
|
||
continue
|
||
|
||
if title_lower in excluded_titles_exact_lower:
|
||
# logger.debug(f"窗口标题 '{title_lower}' 在排除列表, 排除.")
|
||
continue
|
||
|
||
if any(keyword in title_lower for keyword in excluded_keywords_in_title_lower):
|
||
# logger.debug(f"窗口标题 '{title_lower}' 包含排除的关键词, 排除.")
|
||
continue
|
||
|
||
# 如果进程是 explorer.exe,但不是“资源管理器”则认为是特殊explorer(应该是桌面)
|
||
if process_name == 'explorer.exe':
|
||
if title_lower in excluded_titles_exact_lower or \
|
||
any(keyword in title_lower for keyword in excluded_keywords_in_title_lower):
|
||
# logger.debug(f"explorer.exe 窗口 '{title_lower}' 命中标题排除规则, 排除.")
|
||
continue
|
||
# logger.debug(f"找到有效最大化窗口: '{title}' (PID: {win_pid}, 进程: {process_name}). 返回 True.")
|
||
return True
|
||
|
||
except Exception as e:
|
||
if window and hasattr(window, 'title'):
|
||
logger.debug(f"处理窗口 '{getattr(window, 'title', 'N/A')}' 时发生错误: {str(e)}")
|
||
else:
|
||
logger.debug(f"处理一个未知窗口时发生错误: {str(e)}")
|
||
continue
|
||
return False
|
||
|
||
|
||
|
||
def init_config(): # 重设配置文件
|
||
config_center.write_conf('Temp', 'set_week', '')
|
||
config_center.write_conf('Temp', 'set_schedule', '')
|
||
if config_center.read_conf('Temp', 'temp_schedule') != '': # 修复换课重置
|
||
copy(f'{base_directory}/config/schedule/backup.json',
|
||
f'{base_directory}/config/schedule/{config_center.schedule_name}')
|
||
config_center.write_conf('Temp', 'temp_schedule', '')
|
||
schedule_center.update_schedule()
|
||
|
||
|
||
def init():
|
||
global theme, radius, mgr, screen_width, first_start, fw, was_floating_mode
|
||
update_timer.remove_all_callbacks()
|
||
|
||
theme = config_center.read_conf('General', 'theme') # 主题
|
||
if not os.path.exists(f'{base_directory}/ui/{theme}/theme.json'):
|
||
logger.warning(f'主题 {theme} 不存在，使用默认主题')
|
||
theme = 'default'
|
||
logger.info(f'应用主题：{theme}')
|
||
|
||
mgr = WidgetsManager()
|
||
fw = FloatingWidget()
|
||
|
||
# 获取屏幕横向分辨率
|
||
screen_geometry = app.primaryScreen().availableGeometry()
|
||
screen_width = screen_geometry.width()
|
||
|
||
widgets = list_.get_widget_config()
|
||
|
||
for widget in widgets: # 检查组件
|
||
if widget not in list_.widget_name:
|
||
widgets.remove(widget) # 移除不存在的组件(确保移除插件后不会出错)
|
||
|
||
mgr.init_widgets()
|
||
if not first_start and was_floating_mode:
|
||
if fw:
|
||
fw.show()
|
||
mgr.full_hide_windows()
|
||
|
||
update_timer.add_callback(mgr.update_widgets)
|
||
update_timer.start()
|
||
|
||
logger.info(f'Class Widgets 初始化完成。版本: {config_center.read_conf("Other", "version")}')
|
||
p_loader.run_plugins() # 运行插件
|
||
|
||
first_start = False
|
||
|
||
|
||
def setup_signal_handlers_optimized(app):
|
||
"""退出信号处理器"""
|
||
def signal_handler(signum, frame):
|
||
logger.debug(f'收到信号 {signal.Signals(signum).name},退出...')
|
||
# utils.stop 处理退出
|
||
utils.stop(0)
|
||
|
||
signal.signal(signal.SIGTERM, signal_handler) # taskkill
|
||
signal.signal(signal.SIGINT, signal_handler) # Ctrl+C
|
||
if os.name == 'posix':
|
||
signal.signal(signal.SIGQUIT, signal_handler) # 终端退出
|
||
signal.signal(signal.SIGHUP, signal_handler) # 终端挂起
|
||
|
||
if __name__ == '__main__':
|
||
if share.attach() and config_center.read_conf('Other', 'multiple_programs') != '1':
|
||
logger.debug('不允许多开实例')
|
||
from qfluentwidgets import Dialog
|
||
app = QApplication.instance() or QApplication(sys.argv)
|
||
dlg = Dialog(
|
||
'Class Widgets 正在运行',
|
||
'Class Widgets 正在运行！请勿打开多个实例，否则将会出现不可预知的问题。'
|
||
'\n(若您需要打开多个实例，请在“设置”->“高级选项”中启用“允许程序多开”)'
|
||
)
|
||
dlg.yesButton.setText('好')
|
||
dlg.cancelButton.hide()
|
||
dlg.buttonLayout.insertStretch(0, 1)
|
||
dlg.setFixedWidth(550)
|
||
dlg.exec()
|
||
sys.exit(0)
|
||
if not share.create(1):
|
||
print(f'无法创建共享内存: {share.errorString()}') # logger 可能还没准备好
|
||
sys.exit(1)
|
||
|
||
scale_factor = float(config_center.read_conf('General', 'scale'))
|
||
os.environ['QT_SCALE_FACTOR'] = str(scale_factor)
|
||
logger.info(f"当前缩放系数：{scale_factor * 100}%")
|
||
|
||
app = QApplication(sys.argv)
|
||
app.setQuitOnLastWindowClosed(False)
|
||
share.create(1) # 创建共享内存
|
||
logger.info(
|
||
f"共享内存：{share.isAttached()} 是否允许多开实例：{config_center.read_conf('Other', 'multiple_programs')}")
|
||
try:
|
||
dark_mode_watcher = DarkModeWatcher(parent=app)
|
||
dark_mode_watcher.darkModeChanged.connect(handle_dark_mode_change) # 连接信号
|
||
# 初始主题设置依赖于 darkModeChanged 信号
|
||
except Exception as e:
|
||
logger.error(f"初始化颜色模式监测器时出错: {e}")
|
||
dark_mode_watcher = None
|
||
|
||
if scale_factor > 1.8 or scale_factor < 1.0:
|
||
logger.warning("当前缩放系数可能导致显示异常，建议使缩放系数在 100% 到 180% 之间")
|
||
msg_box = Dialog('缩放系数过大',
|
||
f"当前缩放系数为 {scale_factor * 100}%，可能导致显示异常。\n建议将缩放系数设置为 100% 到 180% 之间。")
|
||
msg_box.yesButton.setText('好')
|
||
msg_box.cancelButton.hide()
|
||
msg_box.buttonLayout.insertStretch(0, 1)
|
||
msg_box.setFixedWidth(550)
|
||
msg_box.exec()
|
||
|
||
# 优化操作系统和版本输出
|
||
system = platform.system()
|
||
if system == 'Darwin':
|
||
system = 'macOS'
|
||
osRelease = platform.release()
|
||
if system == 'Windows':
|
||
osRelease = 'Windows ' + osRelease
|
||
if system == 'macOS':
|
||
osRelease = 'Darwin Kernel Version ' + osRelease
|
||
osVersion = platform.version()
|
||
if system == 'macOS':
|
||
osVersion = 'macOS ' + platform.mac_ver()[0]
|
||
|
||
logger.info(f"操作系统：{system}，版本：{osRelease}/{osVersion}")
|
||
|
||
# list_pyttsx3_voices()
|
||
|
||
if share.attach() and config_center.read_conf('Other', 'multiple_programs') != '1':
|
||
msg_box = Dialog(
|
||
'Class Widgets 正在运行',
|
||
'Class Widgets 正在运行！请勿打开多个实例，否则将会出现不可预知的问题。'
|
||
'\n(若您需要打开多个实例，请在“设置”->“高级选项”中启用“允许程序多开”)'
|
||
)
|
||
msg_box.yesButton.setText('好')
|
||
msg_box.cancelButton.hide()
|
||
msg_box.buttonLayout.insertStretch(0, 1)
|
||
msg_box.setFixedWidth(550)
|
||
msg_box.exec()
|
||
stop(-1)
|
||
else:
|
||
mgr = WidgetsManager()
|
||
app.aboutToQuit.connect(mgr.cleanup_resources)
|
||
setup_signal_handlers_optimized(app)
|
||
|
||
if config_center.read_conf('Other', 'initialstartup') == '1': # 首次启动
|
||
try:
|
||
conf.add_shortcut('ClassWidgets.exe', f'{base_directory}/img/favicon.ico')
|
||
conf.add_shortcut_to_startmenu(f'{base_directory}/ClassWidgets.exe',
|
||
f'{base_directory}/img/favicon.ico')
|
||
config_center.write_conf('Other', 'initialstartup', '')
|
||
except Exception as e:
|
||
logger.error(f'添加快捷方式失败：{e}')
|
||
try:
|
||
list_.create_new_profile('新课表 - 1.json')
|
||
except Exception as e:
|
||
logger.error(f'创建新课表失败：{e}')
|
||
|
||
p_mgr = PluginManager()
|
||
p_loader.set_manager(p_mgr)
|
||
p_loader.load_plugins()
|
||
|
||
init()
|
||
get_start_time()
|
||
get_current_lessons()
|
||
get_current_lesson_name()
|
||
get_next_lessons()
|
||
|
||
# 如果在全屏或最大化模式下启动，首先折叠主组件后显示浮动窗口动画。
|
||
if check_windows_maximize() or check_fullscreen():
|
||
mgr.decide_to_hide() # 折叠动画,其实这里可用`mgr.full_hide_windows()`但是播放动画似乎更好()
|
||
|
||
if current_state == 1:
|
||
setThemeColor(f"#{config_center.read_conf('Color', 'attend_class')}")
|
||
else:
|
||
setThemeColor(f"#{config_center.read_conf('Color', 'finish_class')}")
|
||
|
||
# w = ErrorDialog()
|
||
# w.exec()
|
||
if config_center.read_conf('Other', 'auto_check_update') == '1':
|
||
check_update()
|
||
|
||
status = app.exec()
|
||
|
||
utils.stop(status)
|