bubbleUI 0.4.4a1__py3-none-any.whl

bubble/glasskit/__init__.py

@@ -0,0 +1,94 @@
+"""Core frosted-glass toolkit for PySide6.
+
+The package contains the reusable pieces only:
+
+* :class:`FrostStyle` / :func:`paint_frost_overlay` -- material model and paint
+  helper.  All material controls, including the vignette, live here.  Every
+  field is also exposed as a QSS ``qproperty-frost*`` on the painting widgets
+  (:class:`GlassBackdrop`, :class:`GlassMenuBar`, :class:`GlassPanel`), so the
+  four presets in :mod:`.config` can be tuned from the theme style sheet; see
+  :func:`apply_glass_style` for the ``"thin"`` variants.
+* :class:`BlurredGlassPanel` -- blur the content underneath one widget.
+* :class:`DesktopSource` -- capture the screen and supply blurred regions for
+  live window-level glass.
+* :class:`WallpaperSource` -- static system-wallpaper backdrop that reloads
+  only when the wallpaper changes (Mica-like idle behaviour).
+* :class:`GlassRuntimeSettings` -- background source, FPS, GPU, energy saving
+  and focus-loss behaviour.
+* :class:`GpuSurface` -- optional QOpenGLWidget painting surface.
+* :class:`EnergyModeController` -- standard/energy switching with an animated
+  cross-fade, including automatic switching on focus loss.
+
+Window chrome, parameter panels and demo styling belong to the application,
+not to this library.
+"""
+
+from .energy import EnergyModeController
+from .glass import (
+    BlurSource,
+    BlurredGlassPanel,
+    FrostStyle,
+    apply_glass_style,
+    mix,
+    paint_frost_overlay,
+    qcolor,
+    rounded_path,
+    GlassMainWindow,
+    GlassDialog,
+    GlassMenuBar,
+    GlassPanel,
+    GlassBackdrop
+)
+from .gpu import GpuBackdrop, GpuSurface
+from .imaging import (
+    DesktopSource,
+    WallpaperSource,
+    blur_qimage,
+    clear_texture_cache,
+    exclude_window_from_capture,
+    noise_texture,
+    pil_to_qimage,
+    qimage_to_pil,
+    system_wallpaper_path,
+)
+from .settings import (
+    BACKGROUND_SCREEN,
+    BACKGROUND_WALLPAPER,
+    GlassRuntimeSettings,
+)
+from .config import * # noqa: F403
+
+__all__ = [
+    "BACKGROUND_SCREEN",
+    "BACKGROUND_WALLPAPER",
+    "BlurSource",
+    "BlurredGlassPanel",
+    "DesktopSource",
+    "EnergyModeController",
+    "FrostStyle",
+    "GlassRuntimeSettings",
+    "GpuBackdrop",
+    "GpuSurface",
+    "WallpaperSource",
+    "blur_qimage",
+    "clear_texture_cache",
+    "exclude_window_from_capture",
+    "mix",
+    "noise_texture",
+    "paint_frost_overlay",
+    "pil_to_qimage",
+    "qcolor",
+    "qimage_to_pil",
+    "rounded_path",
+    "system_wallpaper_path",
+    "BUBBLE_BACKGROUND_NORMAL",
+    "BUBBLE_BACKGROUND_THIN",
+    "BUBBLE_SIDEBAR_NORMAL",
+    "BUBBLE_SIDEBAR_THIN",
+    "GlassMainWindow",
+    "GlassDialog",
+    "GlassMenuBar",
+    "GlassPanel",
+    "FROST_PRESETS",
+    "apply_glass_style"
+]

bubble/glasskit/config.py

@@ -0,0 +1,77 @@
+from .settings import (
+    BACKGROUND_WALLPAPER,
+    GlassRuntimeSettings,
+    FrostStyle
+)
+
+RUNTIME = GlassRuntimeSettings(
+    background_mode=BACKGROUND_WALLPAPER,
+    fps=24,
+    gpu=False,
+    auto_energy_on_focus_loss=True,
+    transition_ms=250,
+)
+CAPTURE_SCALE = 0.5         # region capture scale; 1.0 = sharper, more CPU
+
+# Whole-window desktop glass material.
+BUBBLE_BACKGROUND_THIN = FrostStyle(
+    tint="#4c4c4c",
+    opacity=60,
+    blur=24,
+    frost=20,
+    noise=5,
+    sheen=15,
+    saturation=100,
+    brightness=100,
+) # 透明模式
+
+# Whole-window desktop glass material.
+BUBBLE_BACKGROUND_NORMAL = FrostStyle(
+    tint="#272727",
+    opacity=90,
+    blur=48,
+    frost=3,
+    noise=3,
+    sheen=0,
+    saturation=75,
+    brightness=60,
+) # 透明模式
+
+# Whole-window desktop glass material.
+BUBBLE_SIDEBAR_NORMAL = FrostStyle(
+    tint="#202020",
+    opacity=70,
+    blur=48,
+    frost=5,
+    noise=0,
+    sheen=40,
+    saturation=80,
+    brightness=55,
+) # 透明模式
+
+# Whole-window desktop glass material.
+BUBBLE_SIDEBAR_THIN = FrostStyle(
+    tint="#545454",
+    opacity=30,
+    blur=24,
+    frost=5,
+    noise=0,
+    sheen=10,
+    saturation=130,
+    brightness=120,
+) # 透明模式
+#: The four built-in materials.  The same values are written to the theme
+#: style sheets (`res/styles/dark.qss` / `light.qss`) as
+#: `qproperty-frost*` rules; those QSS rules are applied at runtime and are
+#: the recommended place to tune the material.  The presets below remain the
+#: code-level defaults (what a standalone glasskit app gets without a style
+#: sheet).  Widget mapping used by the theme style sheets:
+#:
+#: * `background_normal` / `background_thin` -> :class:GlassBackdrop
+#: * `sidebar_normal` / `sidebar_thin` -> :class:GlassMenuBar
+FROST_PRESETS = {
+    "background_normal": BUBBLE_BACKGROUND_NORMAL,
+    "background_thin": BUBBLE_BACKGROUND_THIN,
+    "sidebar_normal": BUBBLE_SIDEBAR_NORMAL,
+    "sidebar_thin": BUBBLE_SIDEBAR_THIN,
+}

bubble/glasskit/energy.py

@@ -0,0 +1,202 @@
+"""Standard <-> energy-saving mode switching for glass windows.
+
+The controller owns:
+
+* explicit energy-saving state and optional automatic switching on focus loss
+* a 0.25s cross-fade between the standard and energy backgrounds
+* the paint hook for that transition
+
+The host supplies a ``render_background(energy: bool) -> QPixmap`` callback and
+reacts to ``energyChanged`` / ``transitionFinished`` to pause its desktop
+source, hide/show a GPU surface, or update its controls.
+"""
+
+from __future__ import annotations
+
+from typing import Callable
+
+from PySide6.QtCore import (
+    QEasingCurve,
+    QEvent,
+    QObject,
+    QTimer,
+    Qt,
+    QVariantAnimation,
+    Signal,
+)
+from PySide6.QtGui import QPainter, QPixmap
+from PySide6.QtWidgets import QWidget
+
+
+class EnergyModeController(QObject):
+    """Drive standard/energy mode with an animated cross-fade."""
+
+    energyChanged = Signal(bool)
+    transitionFinished = Signal(bool)
+
+    def __init__(self, window: QWidget,
+                 render_background: Callable[[bool], QPixmap],
+                 *, duration_ms: int = 250,
+                 auto_on_focus_loss: bool = True,
+                 parent: QObject | None = None):
+        super().__init__(parent if parent is not None else window)
+        self._window = window
+        self._render_background = render_background
+        self._duration_ms = max(0, int(duration_ms))
+        self._auto = bool(auto_on_focus_loss)
+        self._explicit = False
+        self._energy_active = False
+        self._transition_active = False
+        self._transition_t = 0.0
+        self._transition_from: QPixmap | None = None
+        self._transition_to: QPixmap | None = None
+
+        self._anim = QVariantAnimation(self)
+        self._anim.setDuration(self._duration_ms)
+        self._anim.setEasingCurve(QEasingCurve.Type.InOutCubic)
+        self._anim.valueChanged.connect(self._on_anim_value)
+        self._anim.finished.connect(self._on_anim_finished)
+
+        self._window.installEventFilter(self)
+
+    # -- public state ------------------------------------------------------
+    @property
+    def active(self) -> bool:
+        """Whether the energy configuration is the current target."""
+        return self._energy_active
+
+    @property
+    def transitioning(self) -> bool:
+        return self._transition_active
+
+    @property
+    def progress(self) -> float:
+        return self._transition_t
+
+    @property
+    def explicit(self) -> bool:
+        return self._explicit
+
+    @property
+    def auto_on_focus_loss(self) -> bool:
+        return self._auto
+
+    @property
+    def duration_ms(self) -> int:
+        return self._duration_ms
+
+    def set_explicit(self, enabled: bool) -> None:
+        self._explicit = bool(enabled)
+        self._refresh()
+
+    def set_auto_on_focus_loss(self, enabled: bool) -> None:
+        self._auto = bool(enabled)
+        self._refresh()
+
+    def set_duration(self, duration_ms: int) -> None:
+        self._duration_ms = max(0, int(duration_ms))
+        self._anim.setDuration(self._duration_ms)
+
+    # -- painting ----------------------------------------------------------
+    def paint(self, painter: QPainter) -> bool:
+        """Draw the cross-fade.  Returns True while a transition is active."""
+        if not self._transition_active:
+            return False
+        if self._transition_from is not None:
+            painter.drawPixmap(0, 0, self._transition_from)
+        if self._transition_to is not None:
+            painter.setOpacity(self._transition_t)
+            painter.drawPixmap(0, 0, self._transition_to)
+        return True
+
+    # -- internal state ----------------------------------------------------
+    def _refresh(self) -> None:
+        if not self._window.isVisible():
+            return
+        target = bool(self._explicit or (self._auto and not self._window.isActiveWindow()))
+        if target == self._energy_active:
+            return
+        self._start_transition(target)
+
+    def _start_transition(self, target: bool) -> None:
+        if self._transition_active:
+            from_pixmap = self._render_transition_frame()
+            self._transition_active = False
+            self._anim.stop()
+        else:
+            from_pixmap = self._render_background(self._energy_active)
+
+        self._energy_active = bool(target)
+        self.energyChanged.emit(self._energy_active)
+
+        if self._duration_ms <= 0:
+            self._transition_active = False
+            self.transitionFinished.emit(self._energy_active)
+            self._window.update()
+            return
+
+        to_pixmap = self._render_background(self._energy_active)
+        self._transition_from = from_pixmap
+        self._transition_to = to_pixmap
+        self._transition_t = 0.0
+        self._transition_active = True
+        self._anim.stop()
+        self._anim.setStartValue(0.0)
+        self._anim.setEndValue(1.0)
+        self._anim.start()
+        self._window.update()
+
+    def _on_anim_value(self, value) -> None:
+        if not self._transition_active:
+            return
+        self._transition_t = float(value)
+        self._window.update()
+
+    def _on_anim_finished(self) -> None:
+        if not self._transition_active:
+            return
+        self._transition_active = False
+        self._transition_from = None
+        self._transition_to = None
+        self._transition_t = 1.0
+        self.transitionFinished.emit(self._energy_active)
+        self._window.update()
+
+    def _render_transition_frame(self) -> QPixmap:
+        pixmap = QPixmap(self._window.size())
+        pixmap.fill(Qt.GlobalColor.transparent)
+        painter = QPainter(pixmap)
+        if self._transition_from is not None:
+            painter.drawPixmap(0, 0, self._transition_from)
+        if self._transition_to is not None:
+            painter.setOpacity(self._transition_t)
+            painter.drawPixmap(0, 0, self._transition_to)
+        painter.end()
+        return pixmap
+
+    def _scale_snapshots(self) -> None:
+        size = self._window.size()
+        if self._transition_from is not None:
+            self._transition_from = self._transition_from.scaled(
+                size, Qt.AspectRatioMode.IgnoreAspectRatio,
+                Qt.TransformationMode.SmoothTransformation,
+            )
+        if self._transition_to is not None:
+            self._transition_to = self._transition_to.scaled(
+                size, Qt.AspectRatioMode.IgnoreAspectRatio,
+                Qt.TransformationMode.SmoothTransformation,
+            )
+
+    # -- focus / resize ----------------------------------------------------
+    def eventFilter(self, obj, event) -> bool:  # noqa: N802
+        if obj is self._window:
+            event_type = event.type()
+            if event_type == QEvent.Type.Show:
+                QTimer.singleShot(0, self._refresh)
+            elif event_type in (QEvent.Type.WindowActivate,
+                                QEvent.Type.WindowDeactivate,
+                                QEvent.Type.ActivationChange):
+                self._refresh()
+            elif event_type == QEvent.Type.Resize and self._transition_active:
+                self._scale_snapshots()
+        return super().eventFilter(obj, event)