578 lines
19 KiB
Python
578 lines
19 KiB
Python
"""
|
||
EU-Utility - Widget System (Core Framework Component)
|
||
|
||
Rainmeter-inspired overlay widgets for plugins.
|
||
Widgets can be positioned, styled, and configured by users.
|
||
"""
|
||
|
||
import json
|
||
from pathlib import Path
|
||
from typing import Dict, List, Optional, Callable, Any
|
||
from dataclasses import dataclass, asdict
|
||
from enum import Enum
|
||
|
||
from PyQt6.QtWidgets import (
|
||
QWidget, QVBoxLayout, QHBoxLayout, QLabel,
|
||
QPushButton, QFrame, QMenu, QInputDialog
|
||
)
|
||
from PyQt6.QtCore import Qt, QPoint, QSize, QTimer, pyqtSignal, QObject
|
||
from PyQt6.QtGui import QMouseEvent, QPainter, QColor, QFont
|
||
|
||
|
||
class WidgetAnchor(Enum):
|
||
"""Widget positioning anchor."""
|
||
TOP_LEFT = "top_left"
|
||
TOP_RIGHT = "top_right"
|
||
BOTTOM_LEFT = "bottom_left"
|
||
BOTTOM_RIGHT = "bottom_right"
|
||
CENTER = "center"
|
||
FREE = "free" # User positioned
|
||
|
||
|
||
@dataclass
|
||
class WidgetConfig:
|
||
"""Widget configuration."""
|
||
x: int = 0
|
||
y: int = 0
|
||
width: int = 200
|
||
height: int = 100
|
||
anchor: WidgetAnchor = WidgetAnchor.TOP_RIGHT
|
||
opacity: float = 1.0
|
||
scale: float = 1.0
|
||
visible: bool = True
|
||
locked: bool = False # If True, can't be moved
|
||
style: Dict[str, Any] = None
|
||
|
||
def __post_init__(self):
|
||
if self.style is None:
|
||
self.style = {}
|
||
|
||
|
||
class BaseWidget(QFrame):
|
||
"""Base class for all overlay widgets.
|
||
|
||
Similar to Rainmeter skins - draggable, resizable, stylable.
|
||
"""
|
||
|
||
# Signals
|
||
moved = pyqtSignal(int, int) # x, y
|
||
resized = pyqtSignal(int, int) # width, height
|
||
closed = pyqtSignal()
|
||
settings_requested = pyqtSignal()
|
||
|
||
def __init__(self, widget_id: str, name: str, config: Optional[WidgetConfig] = None, parent=None):
|
||
super().__init__(parent)
|
||
|
||
self.widget_id = widget_id
|
||
self.name = name
|
||
self.config = config or WidgetConfig()
|
||
|
||
# Window flags for overlay
|
||
self.setWindowFlags(
|
||
Qt.WindowType.FramelessWindowHint |
|
||
Qt.WindowType.WindowStaysOnTopHint |
|
||
Qt.WindowType.Tool |
|
||
Qt.WindowType.WindowDoesNotAcceptFocus
|
||
)
|
||
|
||
# Transparent background
|
||
self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
|
||
self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
|
||
|
||
# Dragging state
|
||
self._dragging = False
|
||
self._drag_offset = QPoint()
|
||
self._resizing = False
|
||
self._resize_start = QPoint()
|
||
self._start_size = QSize()
|
||
|
||
# Setup UI
|
||
self._setup_base_ui()
|
||
self._apply_style()
|
||
self._apply_geometry()
|
||
|
||
# Context menu
|
||
self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
|
||
self.customContextMenuRequested.connect(self._show_context_menu)
|
||
|
||
def _setup_base_ui(self):
|
||
"""Setup the base widget UI."""
|
||
# Main layout
|
||
self.main_layout = QVBoxLayout(self)
|
||
self.main_layout.setContentsMargins(8, 8, 8, 8)
|
||
self.main_layout.setSpacing(4)
|
||
|
||
# Header (draggable area)
|
||
self.header = QFrame()
|
||
self.header.setFixedHeight(24)
|
||
self.header.setCursor(Qt.CursorShape.OpenHandCursor)
|
||
self.header.setStyleSheet("""
|
||
QFrame {
|
||
background-color: rgba(255, 140, 66, 200);
|
||
border-radius: 4px;
|
||
}
|
||
""")
|
||
|
||
header_layout = QHBoxLayout(self.header)
|
||
header_layout.setContentsMargins(8, 2, 8, 2)
|
||
header_layout.setSpacing(4)
|
||
|
||
# Title
|
||
self.title_label = QLabel(self.name)
|
||
self.title_label.setStyleSheet("color: white; font-weight: bold; font-size: 11px;")
|
||
header_layout.addWidget(self.title_label)
|
||
|
||
header_layout.addStretch()
|
||
|
||
# Settings button
|
||
self.settings_btn = QPushButton("⚙")
|
||
self.settings_btn.setFixedSize(18, 18)
|
||
self.settings_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background-color: transparent;
|
||
color: white;
|
||
border: none;
|
||
font-size: 10px;
|
||
}
|
||
QPushButton:hover {
|
||
background-color: rgba(255, 255, 255, 50);
|
||
border-radius: 2px;
|
||
}
|
||
""")
|
||
self.settings_btn.clicked.connect(self.settings_requested.emit)
|
||
header_layout.addWidget(self.settings_btn)
|
||
|
||
# Close button
|
||
self.close_btn = QPushButton("×")
|
||
self.close_btn.setFixedSize(18, 18)
|
||
self.close_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background-color: transparent;
|
||
color: white;
|
||
border: none;
|
||
font-size: 14px;
|
||
font-weight: bold;
|
||
}
|
||
QPushButton:hover {
|
||
background-color: rgba(255, 71, 71, 200);
|
||
border-radius: 2px;
|
||
}
|
||
""")
|
||
self.close_btn.clicked.connect(self.hide)
|
||
header_layout.addWidget(self.close_btn)
|
||
|
||
self.main_layout.addWidget(self.header)
|
||
|
||
# Content area (subclasses add widgets here)
|
||
self.content = QFrame()
|
||
self.content.setStyleSheet("""
|
||
QFrame {
|
||
background-color: rgba(35, 40, 55, 220);
|
||
border-radius: 4px;
|
||
}
|
||
""")
|
||
self.content_layout = QVBoxLayout(self.content)
|
||
self.content_layout.setContentsMargins(8, 8, 8, 8)
|
||
self.main_layout.addWidget(self.content, 1)
|
||
|
||
# Resize handle
|
||
self.resize_handle = QLabel("⟲")
|
||
self.resize_handle.setFixedSize(16, 16)
|
||
self.resize_handle.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
self.resize_handle.setStyleSheet("""
|
||
QLabel {
|
||
color: rgba(255, 255, 255, 150);
|
||
font-size: 10px;
|
||
}
|
||
QLabel:hover {
|
||
color: white;
|
||
background-color: rgba(255, 255, 255, 30);
|
||
border-radius: 2px;
|
||
}
|
||
""")
|
||
self.resize_handle.setCursor(Qt.CursorShape.SizeFDiagCursor)
|
||
|
||
handle_container = QHBoxLayout()
|
||
handle_container.addStretch()
|
||
handle_container.addWidget(self.resize_handle)
|
||
self.main_layout.addLayout(handle_container)
|
||
|
||
def _apply_style(self):
|
||
"""Apply widget styling."""
|
||
style = self.config.style or {}
|
||
|
||
# Background color
|
||
bg_color = style.get('background_color', 'rgba(35, 40, 55, 220)')
|
||
border_color = style.get('border_color', 'rgba(100, 110, 130, 100)')
|
||
border_width = style.get('border_width', 1)
|
||
border_radius = style.get('border_radius', 8)
|
||
|
||
self.setStyleSheet(f"""
|
||
BaseWidget {{
|
||
background-color: {bg_color};
|
||
border: {border_width}px solid {border_color};
|
||
border-radius: {border_radius}px;
|
||
}}
|
||
""")
|
||
|
||
# Opacity
|
||
self.setWindowOpacity(self.config.opacity)
|
||
|
||
def _apply_geometry(self):
|
||
"""Apply widget geometry."""
|
||
self.setGeometry(
|
||
self.config.x,
|
||
self.config.y,
|
||
int(self.config.width * self.config.scale),
|
||
int(self.config.height * self.config.scale)
|
||
)
|
||
|
||
def mousePressEvent(self, event: QMouseEvent):
|
||
"""Handle mouse press for dragging."""
|
||
if event.button() == Qt.MouseButton.LeftButton:
|
||
# Check if clicking resize handle
|
||
if self.resize_handle.geometry().contains(event.pos()):
|
||
self._resizing = True
|
||
self._resize_start = event.globalPosition().toPoint()
|
||
self._start_size = self.size()
|
||
event.accept()
|
||
return
|
||
|
||
# Check if clicking header
|
||
if self.header.geometry().contains(event.pos()) and not self.config.locked:
|
||
self._dragging = True
|
||
self._drag_offset = event.globalPosition().toPoint() - self.frameGeometry().topLeft()
|
||
self.header.setCursor(Qt.CursorShape.ClosedHandCursor)
|
||
event.accept()
|
||
return
|
||
|
||
super().mousePressEvent(event)
|
||
|
||
def mouseMoveEvent(self, event: QMouseEvent):
|
||
"""Handle mouse move for dragging/resizing."""
|
||
if self._dragging:
|
||
new_pos = event.globalPosition().toPoint() - self._drag_offset
|
||
self.move(new_pos)
|
||
self.config.x = new_pos.x()
|
||
self.config.y = new_pos.y()
|
||
self.moved.emit(self.config.x, self.config.y)
|
||
event.accept()
|
||
return
|
||
|
||
if self._resizing:
|
||
delta = event.globalPosition().toPoint() - self._resize_start
|
||
new_size = QSize(
|
||
max(100, self._start_size.width() + delta.x()),
|
||
max(50, self._start_size.height() + delta.y())
|
||
)
|
||
self.resize(new_size)
|
||
self.config.width = int(new_size.width() / self.config.scale)
|
||
self.config.height = int(new_size.height() / self.config.scale)
|
||
self.resized.emit(self.config.width, self.config.height)
|
||
event.accept()
|
||
return
|
||
|
||
super().mouseMoveEvent(event)
|
||
|
||
def mouseReleaseEvent(self, event: QMouseEvent):
|
||
"""Handle mouse release."""
|
||
if event.button() == Qt.MouseButton.LeftButton:
|
||
if self._dragging:
|
||
self._dragging = False
|
||
self.header.setCursor(Qt.CursorShape.OpenHandCursor)
|
||
event.accept()
|
||
return
|
||
|
||
if self._resizing:
|
||
self._resizing = False
|
||
event.accept()
|
||
return
|
||
|
||
super().mouseReleaseEvent(event)
|
||
|
||
def _show_context_menu(self, pos):
|
||
"""Show context menu."""
|
||
menu = QMenu(self)
|
||
menu.setStyleSheet("""
|
||
QMenu {
|
||
background-color: #232837;
|
||
color: white;
|
||
border: 1px solid rgba(100, 110, 130, 100);
|
||
}
|
||
QMenu::item:selected {
|
||
background-color: #4a9eff;
|
||
}
|
||
""")
|
||
|
||
# Opacity submenu
|
||
opacity_menu = menu.addMenu("Opacity")
|
||
for opacity in [0.25, 0.5, 0.75, 1.0]:
|
||
action = opacity_menu.addAction(f"{int(opacity * 100)}%")
|
||
action.triggered.connect(lambda checked, o=opacity: self.set_opacity(o))
|
||
|
||
# Scale submenu
|
||
scale_menu = menu.addMenu("Scale")
|
||
for scale in [0.5, 0.75, 1.0, 1.25, 1.5, 2.0]:
|
||
action = scale_menu.addAction(f"{int(scale * 100)}%")
|
||
action.triggered.connect(lambda checked, s=scale: self.set_scale(s))
|
||
|
||
menu.addSeparator()
|
||
|
||
# Lock position
|
||
lock_action = menu.addAction("🔒 Lock Position" if not self.config.locked else "🔓 Unlock Position")
|
||
lock_action.triggered.connect(self.toggle_lock)
|
||
|
||
menu.addSeparator()
|
||
|
||
# Settings
|
||
settings_action = menu.addAction("⚙ Settings...")
|
||
settings_action.triggered.connect(self.settings_requested.emit)
|
||
|
||
menu.exec(self.mapToGlobal(pos))
|
||
|
||
def set_opacity(self, opacity: float):
|
||
"""Set widget opacity."""
|
||
self.config.opacity = opacity
|
||
self.setWindowOpacity(opacity)
|
||
|
||
def set_scale(self, scale: float):
|
||
"""Set widget scale."""
|
||
self.config.scale = scale
|
||
self._apply_geometry()
|
||
|
||
def toggle_lock(self):
|
||
"""Toggle position lock."""
|
||
self.config.locked = not self.config.locked
|
||
|
||
def save_config(self) -> dict:
|
||
"""Save widget configuration."""
|
||
return {
|
||
'widget_id': self.widget_id,
|
||
'name': self.name,
|
||
'config': asdict(self.config)
|
||
}
|
||
|
||
@classmethod
|
||
def load_config(cls, data: dict) -> 'BaseWidget':
|
||
"""Load widget from configuration."""
|
||
config = WidgetConfig(**data.get('config', {}))
|
||
return cls(data['widget_id'], data['name'], config)
|
||
|
||
|
||
class ClockWidget(BaseWidget):
|
||
"""Example clock widget - demonstrates the system."""
|
||
|
||
def __init__(self, parent=None):
|
||
super().__init__("clock", "Clock", parent=parent)
|
||
|
||
self.time_label = QLabel("--:--:--")
|
||
self.time_label.setStyleSheet("""
|
||
QLabel {
|
||
color: white;
|
||
font-size: 24px;
|
||
font-weight: bold;
|
||
font-family: monospace;
|
||
}
|
||
""")
|
||
self.time_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
self.content_layout.addWidget(self.time_label)
|
||
|
||
self.date_label = QLabel("----/--/--")
|
||
self.date_label.setStyleSheet("color: rgba(255,255,255,150); font-size: 12px;")
|
||
self.date_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
self.content_layout.addWidget(self.date_label)
|
||
|
||
# Update timer
|
||
self.timer = QTimer(self)
|
||
self.timer.timeout.connect(self._update)
|
||
self.timer.start(1000) # Update every second
|
||
self._update()
|
||
|
||
def _update(self):
|
||
"""Update clock display."""
|
||
from datetime import datetime
|
||
now = datetime.now()
|
||
self.time_label.setText(now.strftime("%H:%M:%S"))
|
||
self.date_label.setText(now.strftime("%Y-%m-%d"))
|
||
|
||
|
||
class SystemMonitorWidget(BaseWidget):
|
||
"""Example system monitor widget."""
|
||
|
||
def __init__(self, parent=None):
|
||
super().__init__("system", "System Monitor", parent=parent)
|
||
|
||
self.cpu_label = QLabel("CPU: --%")
|
||
self.cpu_label.setStyleSheet("color: #4ecdc4; font-size: 14px;")
|
||
self.content_layout.addWidget(self.cpu_label)
|
||
|
||
self.ram_label = QLabel("RAM: --%")
|
||
self.ram_label.setStyleSheet("color: #ff8c42; font-size: 14px;")
|
||
self.content_layout.addWidget(self.ram_label)
|
||
|
||
# Update timer
|
||
self.timer = QTimer(self)
|
||
self.timer.timeout.connect(self._update)
|
||
self.timer.start(2000) # Update every 2 seconds
|
||
self._update()
|
||
|
||
def _update(self):
|
||
"""Update system stats."""
|
||
try:
|
||
import psutil
|
||
cpu = psutil.cpu_percent()
|
||
ram = psutil.virtual_memory().percent
|
||
|
||
self.cpu_label.setText(f"CPU: {cpu:.1f}%")
|
||
self.ram_label.setText(f"RAM: {ram:.1f}%")
|
||
except ImportError:
|
||
self.cpu_label.setText("CPU: N/A")
|
||
self.ram_label.setText("RAM: N/A")
|
||
|
||
|
||
class WidgetManager(QObject):
|
||
"""Manager for overlay widgets.
|
||
|
||
Handles widget lifecycle, positioning, and persistence.
|
||
"""
|
||
|
||
WIDGETS_FILE = Path("config/widgets.json")
|
||
|
||
def __init__(self, parent=None):
|
||
super().__init__(parent)
|
||
|
||
self.widgets: Dict[str, BaseWidget] = {}
|
||
self.WIDGETS_FILE.parent.mkdir(parents=True, exist_ok=True)
|
||
|
||
# Load saved widgets
|
||
self._load_widgets()
|
||
|
||
def register_widget_type(self, widget_id: str, widget_class: type, name: str):
|
||
"""Register a widget type that plugins can create.
|
||
|
||
Args:
|
||
widget_id: Unique identifier for this widget type
|
||
widget_class: Class inheriting from BaseWidget
|
||
name: Human-readable name
|
||
"""
|
||
self._widget_types[widget_id] = {
|
||
'class': widget_class,
|
||
'name': name
|
||
}
|
||
|
||
def create_widget(self, widget_id: str, instance_id: Optional[str] = None, config: Optional[WidgetConfig] = None) -> BaseWidget:
|
||
"""Create a new widget instance.
|
||
|
||
Args:
|
||
widget_id: Type of widget to create
|
||
instance_id: Optional unique instance ID
|
||
config: Optional configuration
|
||
|
||
Returns:
|
||
Created widget
|
||
"""
|
||
if instance_id is None:
|
||
instance_id = f"{widget_id}_{len(self.widgets)}"
|
||
|
||
# Create widget (for now, just create built-in types)
|
||
if widget_id == "clock":
|
||
widget = ClockWidget()
|
||
elif widget_id == "system":
|
||
widget = SystemMonitorWidget()
|
||
else:
|
||
# For plugin-created widgets, they'd pass their own class
|
||
widget = BaseWidget(instance_id, widget_id, config)
|
||
|
||
widget.widget_id = instance_id
|
||
self.widgets[instance_id] = widget
|
||
|
||
# Connect signals
|
||
widget.moved.connect(lambda x, y, wid=instance_id: self._on_widget_moved(wid, x, y))
|
||
widget.closed.connect(lambda wid=instance_id: self._on_widget_closed(wid))
|
||
|
||
return widget
|
||
|
||
def show_widget(self, widget_id: str):
|
||
"""Show a widget by ID."""
|
||
if widget_id in self.widgets:
|
||
self.widgets[widget_id].show()
|
||
|
||
def hide_widget(self, widget_id: str):
|
||
"""Hide a widget by ID."""
|
||
if widget_id in self.widgets:
|
||
self.widgets[widget_id].hide()
|
||
|
||
def remove_widget(self, widget_id: str):
|
||
"""Remove and destroy a widget."""
|
||
if widget_id in self.widgets:
|
||
self.widgets[widget_id].close()
|
||
del self.widgets[widget_id]
|
||
self._save_widgets()
|
||
|
||
def _on_widget_moved(self, widget_id: str, x: int, y: int):
|
||
"""Handle widget moved."""
|
||
self._save_widgets()
|
||
|
||
def _on_widget_closed(self, widget_id: str):
|
||
"""Handle widget closed."""
|
||
if widget_id in self.widgets:
|
||
del self.widgets[widget_id]
|
||
self._save_widgets()
|
||
|
||
def _save_widgets(self):
|
||
"""Save widget configurations."""
|
||
data = {
|
||
'widgets': [
|
||
widget.save_config()
|
||
for widget in self.widgets.values()
|
||
]
|
||
}
|
||
|
||
with open(self.WIDGETS_FILE, 'w') as f:
|
||
json.dump(data, f, indent=2)
|
||
|
||
def _load_widgets(self):
|
||
"""Load widget configurations."""
|
||
self._widget_types = {}
|
||
|
||
if not self.WIDGETS_FILE.exists():
|
||
return
|
||
|
||
try:
|
||
with open(self.WIDGETS_FILE, 'r') as f:
|
||
data = json.load(f)
|
||
|
||
# Recreate widgets (would need widget type registry for full implementation)
|
||
for widget_data in data.get('widgets', []):
|
||
# For now, skip loading - plugins would recreate their widgets
|
||
pass
|
||
|
||
except Exception as e:
|
||
print(f"[WidgetManager] Failed to load widgets: {e}")
|
||
|
||
def get_all_widgets(self) -> List[BaseWidget]:
|
||
"""Get all managed widgets."""
|
||
return list(self.widgets.values())
|
||
|
||
def show_all(self):
|
||
"""Show all widgets."""
|
||
for widget in self.widgets.values():
|
||
widget.show()
|
||
|
||
def hide_all(self):
|
||
"""Hide all widgets."""
|
||
for widget in self.widgets.values():
|
||
widget.hide()
|
||
|
||
|
||
# Global widget manager instance
|
||
_widget_manager: Optional[WidgetManager] = None
|
||
|
||
|
||
def get_widget_manager() -> WidgetManager:
|
||
"""Get the global widget manager instance."""
|
||
global _widget_manager
|
||
if _widget_manager is None:
|
||
_widget_manager = WidgetManager()
|
||
return _widget_manager
|