zapret-kvn/xray_fluent/ui/notifications.py
loop-uh d816306e91
Some checks failed
Windows project source guards / test (push) Failing after 36s
Уведомления: один модуль, пауза под мышью; понятные DNS-предупреждения
Уведомления (xray_fluent/ui/notifications.py). Раньше каждое место звало
InfoBar со своим сроком от 2,2 до 30 с, и уведомление гасло по таймеру
библиотеки, даже когда его читали с мышью над ним или окно было свёрнуто.
Теперь все идут через Notifier окна:
- срок по уровню и длине текста (успех от 3 с, предупреждение от 6 с,
  ошибка от 8 с, длинный текст дольше, не больше 30 с);
- отсчёт стоит под мышью и пока окно неактивно или свёрнуто; ушла мышь —
  ещё 2,5 с; гаснущее уведомление мышь возвращает;
- одинаковое не дублируется, а продлевается; на экране не больше четырёх;
- прогресс пинга и теста скорости — «липкое» уведомление, итог висит 4 с
  вместо 1 с.

DNS. «Защищённый DNS недоступен. Адрес сервера взят из запомненных…»
всплывало почти при каждом подключении и ничего не просило от
пользователя: sequential-цепочка app-node-bootstrap делила 4 с поровну, и
DoH получал 2 с — первого TLS-рукопожатия через провайдера не хватало.
Срок цепочки 6 с (DoH получает свои 3 с). Переход на запомненный адрес
больше не уведомление: при неудачном подключении того же перехода к
ошибке дописывается, что адрес мог устареть и подписку стоит обновить.
Два других DNS-предупреждения переписаны: что случилось и что VPN
работает, делать ничего не нужно.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 11:52:39 -04:00

310 lines
12 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""Уведомления окна: одно место, где решается, как и сколько их показывать.
Раньше каждое место звало ``InfoBar`` со своим сроком (от 2,2 до 30 с), и
уведомление гасло по таймеру библиотеки, даже если его читали с мышью над ним
или окно было свёрнуто. Теперь:
* срок зависит от уровня и длины текста — на чтение есть время;
* отсчёт стоит, пока над уведомлением мышь, и пока окно не активно или
свёрнуто: уведомление не исчезает, пока его не увидели;
* увёл мышь — после неё есть ещё несколько секунд;
* одинаковое уведомление не складывается стопкой — висящее продлевается;
* на экране одновременно не больше ``MAX_VISIBLE``, старые уходят первыми;
* «липкие» уведомления (прогресс пинга, теста скорости) живут, пока их не
закроют или не переведут в обычный отсчёт (:meth:`Notification.expire_in`).
Показывать уведомления только через :func:`notify` / :class:`Notifier`;
``InfoBar`` напрямую в окнах не создаётся.
"""
from __future__ import annotations
from dataclasses import dataclass
from typing import Callable
from PyQt6.QtCore import QElapsedTimer, QObject, Qt, QTimer
from PyQt6.QtWidgets import QWidget
from qfluentwidgets import InfoBar, InfoBarIcon, InfoBarPosition
LEVELS = ("info", "success", "warning", "error")
# Минимальный срок по уровню: ошибку и предупреждение надо успеть прочесть и
# понять, что делать, успех — только заметить.
_MIN_MS = {"success": 3_000, "info": 4_000, "warning": 6_000, "error": 8_000}
# Уведомления с пометкой «-long» несут то, что надо дочитать (итог проверки
# подписки с предупреждениями, ссылка): не меньше этого.
LONG_MIN_MS = 12_000
# Время чтения: секунда на то, чтобы заметить, и ~15 знаков в секунду.
_NOTICE_MS = 1_000
_PER_CHAR_MS = 65
MAX_MS = 30_000
# После того как мышь ушла с уведомления, оно ещё столько живёт.
LEAVE_GRACE_MS = 2_500
MAX_VISIBLE = 4
_TICK_MS = 200
_TITLES = {"info": "Инфо", "success": "Готово", "warning": "Внимание", "error": "Ошибка"}
_ICONS = {
"info": InfoBarIcon.INFORMATION,
"success": InfoBarIcon.SUCCESS,
"warning": InfoBarIcon.WARNING,
"error": InfoBarIcon.ERROR,
}
@dataclass(frozen=True)
class Level:
"""Разобранный уровень: ``"warning-long"`` → ``Level("warning", True)``."""
name: str
long: bool = False
@classmethod
def parse(cls, raw: str) -> "Level":
text = str(raw or "").strip().lower()
long = text.endswith("-long")
if long:
text = text[: -len("-long")]
return cls(text if text in LEVELS else "info", long)
def display_duration_ms(level: str, title: str, message: str, *, min_ms: int = 0) -> int:
"""Сколько уведомление видно при отсчёте (паузы под мышью не входят)."""
parsed = Level.parse(level)
chars = len(str(title or "")) + len(str(message or ""))
reading = _NOTICE_MS + chars * _PER_CHAR_MS
floor = max(_MIN_MS[parsed.name], LONG_MIN_MS if parsed.long else 0, int(min_ms or 0))
return min(max(reading, floor), max(MAX_MS, int(min_ms or 0)))
class Notification(InfoBar):
"""``InfoBar`` со своим отсчётом: пауза под мышью и в неактивном окне.
Таймер библиотеки выключен (``duration=-1``); вместо него тикает свой
таймер и вычитает время только тогда, когда уведомление действительно
можно прочесть.
"""
def __init__(self, level: str, title: str, content: str, *, duration_ms: int | None, parent: QWidget):
parsed = Level.parse(level)
super().__init__(
icon=_ICONS[parsed.name],
title=title,
content=content,
isClosable=True,
duration=-1,
position=InfoBarPosition.TOP_RIGHT,
parent=parent,
)
self.level = parsed.name
self._remaining: int | None = duration_ms
self._closing = False
self._clock = QElapsedTimer()
self._ticker = QTimer(self)
self._ticker.setInterval(_TICK_MS)
self._ticker.timeout.connect(self._tick)
self.setMouseTracking(True)
# --- публичное -------------------------------------------------------
@property
def sticky(self) -> bool:
return self._remaining is None
@property
def closing(self) -> bool:
return self._closing
@property
def remaining_ms(self) -> int | None:
return self._remaining
def set_content(self, content: str) -> None:
self.content = str(content or "")
self._adjustText()
def expire_in(self, duration_ms: int) -> None:
"""Начать (или заново начать) отсчёт; липкое становится обычным."""
self._remaining = max(0, int(duration_ms))
self._closing = False
if self.isVisible():
self._start_ticking()
def extend(self, duration_ms: int) -> None:
"""Продлить до ``duration_ms``, если осталось меньше (повтор того же)."""
if self._remaining is None:
return
self.expire_in(max(self._remaining, int(duration_ms)))
def dismiss(self) -> None:
"""Плавно убрать (как по истечении срока)."""
if self._closing:
return
self._closing = True
self._ticker.stop()
try:
self.opacityAni.stop()
self.opacityAni.setDuration(200)
self.opacityAni.setStartValue(self.opacityEffect.opacity())
self.opacityAni.setEndValue(0)
self.opacityAni.finished.connect(self.close)
self.opacityAni.start()
except RuntimeError:
# Окно уже разрушается вместе с уведомлением.
pass
def counting(self) -> bool:
"""Идёт ли сейчас отсчёт: видно, мышь не над ним, окно активно."""
if self._remaining is None or self._closing or not self.isVisible():
return False
if self.underMouse():
return False
window = self.window()
if window is None or window.isMinimized() or not window.isActiveWindow():
return False
return True
# --- события ---------------------------------------------------------
def showEvent(self, e) -> None:
super().showEvent(e)
if self._remaining is not None:
self._start_ticking()
def enterEvent(self, e) -> None:
super().enterEvent(e)
self._restore_opacity()
def leaveEvent(self, e) -> None:
super().leaveEvent(e)
if self._remaining is not None and not self._closing:
self._remaining = max(self._remaining, LEAVE_GRACE_MS)
def _restore_opacity(self) -> None:
# Мышь поймала уже гаснущее уведомление — вернуть его.
if not self._closing or self._remaining is None:
return
try:
self.opacityAni.stop()
self.opacityAni.finished.disconnect(self.close)
except (RuntimeError, TypeError):
pass
self.opacityEffect.setOpacity(1)
self._closing = False
self._remaining = max(self._remaining, LEAVE_GRACE_MS)
self._start_ticking()
def _start_ticking(self) -> None:
self._clock.start()
if not self._ticker.isActive():
self._ticker.start()
def _tick(self) -> None:
elapsed = self._clock.restart()
if self._remaining is None:
self._ticker.stop()
return
if not self.counting():
return
self._remaining -= elapsed
if self._remaining <= 0:
self._remaining = 0
self.dismiss()
class Notifier(QObject):
"""Очередь уведомлений одного окна: дубли, лимит, сроки."""
def __init__(self, window: QWidget):
super().__init__(window)
self._window = window
self._live: list[tuple[tuple[str, str, str], Notification]] = []
def show(
self,
level: str,
message: str,
*,
title: str | None = None,
min_ms: int = 0,
sticky: bool = False,
on_closed: Callable[[], None] | None = None,
) -> Notification:
parsed = Level.parse(level)
title = _TITLES[parsed.name] if title is None else str(title)
message = str(message or "")
duration = None if sticky else display_duration_ms(level, title, message, min_ms=min_ms)
key = (parsed.name, title, message)
if not sticky:
existing = self._find(key)
if existing is not None:
existing.extend(duration)
return existing
self._trim(MAX_VISIBLE - 1)
bar = Notification(level, title, message, duration_ms=duration, parent=self._window)
self._live.append((key, bar))
bar.closedSignal.connect(lambda bar=bar: self._forget(bar))
if on_closed is not None:
bar.closedSignal.connect(on_closed)
bar.show()
return bar
def visible(self) -> list[Notification]:
return [bar for _key, bar in self._live]
def _find(self, key: tuple[str, str, str]) -> Notification | None:
for live_key, bar in self._live:
if live_key == key and not bar.closing:
return bar
return None
def _trim(self, keep: int) -> None:
# Липкие (прогресс) не вытесняются: их закрывает владелец.
active = [bar for _key, bar in self._live if not bar.closing]
removable = [bar for bar in active if not bar.sticky]
while len(active) > keep and removable:
oldest = removable.pop(0)
active.remove(oldest)
oldest.dismiss()
def _forget(self, bar: Notification) -> None:
self._live = [(key, live) for key, live in self._live if live is not bar]
def notifier_for(widget: QWidget) -> Notifier:
"""Очередь окна, которому принадлежит ``widget`` (создаётся при первом зове)."""
window = widget.window() if widget is not None else None
if window is None:
raise ValueError("notification needs a widget")
notifier = window.findChild(Notifier, options=Qt.FindChildOption.FindDirectChildrenOnly)
if notifier is None:
notifier = Notifier(window)
return notifier
def notify(widget: QWidget, level: str, message: str, **kwargs) -> Notification:
"""Показать уведомление в окне ``widget``; см. :meth:`Notifier.show`."""
return notifier_for(widget).show(level, message, **kwargs)
__all__ = [
"LEAVE_GRACE_MS",
"LONG_MIN_MS",
"MAX_MS",
"MAX_VISIBLE",
"Level",
"Notification",
"Notifier",
"display_duration_ms",
"notifier_for",
"notify",
]