597 lines
24 KiB
Python
597 lines
24 KiB
Python
"""
|
|
Wallpaper plugin for the launcher.
|
|
Provides wallpaper management with search, random selection, matugen integration, and hex color support.
|
|
"""
|
|
|
|
import os
|
|
import random
|
|
import hashlib
|
|
import colorsys
|
|
import re
|
|
from typing import List, Dict
|
|
from PIL import Image
|
|
from gi.repository import GdkPixbuf
|
|
from modules.launcher.plugin_base import PluginBase
|
|
from modules.launcher.result import Result
|
|
from fabric.utils.helpers import exec_shell_command_async
|
|
import config.data as data
|
|
import utils.icons as icons
|
|
|
|
|
|
class WallpaperPlugin(PluginBase):
|
|
"""
|
|
Plugin for wallpaper management with search, random selection, and matugen integration.
|
|
"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.wallpapers = []
|
|
self.cache_dir = f"{data.CACHE_DIR}/thumbs"
|
|
self.schemes = {
|
|
"scheme-tonal-spot": "Tonal Spot",
|
|
"scheme-content": "Content",
|
|
"scheme-expressive": "Expressive",
|
|
"scheme-fidelity": "Fidelity",
|
|
"scheme-fruit-salad": "Fruit Salad",
|
|
"scheme-monochrome": "Monochrome",
|
|
"scheme-neutral": "Neutral",
|
|
"scheme-rainbow": "Rainbow",
|
|
}
|
|
|
|
def initialize(self):
|
|
"""Initialize the wallpaper plugin."""
|
|
self.set_triggers(["wall", "wall "])
|
|
self._load_wallpapers()
|
|
os.makedirs(self.cache_dir, exist_ok=True)
|
|
|
|
def cleanup(self):
|
|
"""Cleanup the wallpaper plugin."""
|
|
pass
|
|
|
|
def _load_wallpapers(self):
|
|
"""Load available wallpapers from the wallpapers directory."""
|
|
try:
|
|
if os.path.exists(data.WALLPAPERS_DIR):
|
|
self.wallpapers = sorted(
|
|
[f for f in os.listdir(data.WALLPAPERS_DIR) if self._is_image(f)]
|
|
)
|
|
else:
|
|
print(f"Wallpapers directory not found: {data.WALLPAPERS_DIR}")
|
|
except Exception as e:
|
|
print(f"Error loading wallpapers: {e}")
|
|
|
|
def _is_image(self, filename: str) -> bool:
|
|
"""Check if file is a supported image format."""
|
|
return filename.lower().endswith(
|
|
(".png", ".jpg", ".jpeg", ".bmp", ".gif", ".webp")
|
|
)
|
|
|
|
def _get_matugen_state(self) -> bool:
|
|
"""Get current matugen state from file."""
|
|
try:
|
|
if os.path.exists(data.MATUGEN_STATE_FILE):
|
|
with open(data.MATUGEN_STATE_FILE, "r") as f:
|
|
content = f.read().strip().lower()
|
|
return content == "true"
|
|
return True # Default to True
|
|
except Exception as e:
|
|
print(f"Error reading matugen state: {e}")
|
|
return True
|
|
|
|
def _set_matugen_state(self, enabled: bool):
|
|
"""Set matugen state to file."""
|
|
try:
|
|
os.makedirs(os.path.dirname(data.MATUGEN_STATE_FILE), exist_ok=True)
|
|
with open(data.MATUGEN_STATE_FILE, "w") as f:
|
|
f.write("true" if enabled else "false")
|
|
# Show notification for immediate feedback
|
|
status = "enabled" if enabled else "disabled"
|
|
exec_shell_command_async(
|
|
f"notify-send '🎨 Matugen' 'Dynamic colors {status}' -a '{
|
|
data.APP_NAME_CAP
|
|
}' -e"
|
|
)
|
|
except Exception as e:
|
|
print(f"Error setting matugen state: {e}")
|
|
|
|
def _get_cache_path(self, filename: str) -> str:
|
|
"""Get cache path for wallpaper thumbnail."""
|
|
file_hash = hashlib.md5(filename.encode("utf-8")).hexdigest()
|
|
return os.path.join(self.cache_dir, f"{file_hash}.png")
|
|
|
|
def _create_thumbnail(self, filename: str) -> str:
|
|
"""Create thumbnail for wallpaper if it doesn't exist."""
|
|
full_path = os.path.join(data.WALLPAPERS_DIR, filename)
|
|
cache_path = self._get_cache_path(filename)
|
|
|
|
if not os.path.exists(cache_path):
|
|
try:
|
|
with Image.open(full_path) as img:
|
|
# Use faster thumbnail creation
|
|
img.thumbnail((48, 48), Image.Resampling.LANCZOS)
|
|
img.save(cache_path, "PNG")
|
|
except Exception as e:
|
|
print(f"Error creating thumbnail for {filename}: {e}")
|
|
return None
|
|
|
|
return cache_path
|
|
|
|
def _set_wallpaper(self, filename: str, scheme: str = None):
|
|
"""Set wallpaper with optional matugen integration."""
|
|
full_path = os.path.join(data.WALLPAPERS_DIR, filename)
|
|
current_wall = os.path.expanduser("~/.current.wall")
|
|
|
|
if scheme is None:
|
|
scheme = self._get_current_scheme()
|
|
|
|
# Update current wallpaper symlink
|
|
if os.path.isfile(current_wall) or os.path.islink(current_wall):
|
|
os.remove(current_wall)
|
|
os.symlink(full_path, current_wall)
|
|
|
|
# Apply wallpaper with or without matugen
|
|
matugen_enabled = self._get_matugen_state()
|
|
if matugen_enabled:
|
|
exec_shell_command_async(f'matugen image "{full_path}" -t {scheme}')
|
|
else:
|
|
exec_shell_command_async(
|
|
f'swww img "{
|
|
full_path
|
|
}" -t outer --transition-duration 1.5 --transition-step 255 --transition-fps 60 -f Nearest'
|
|
)
|
|
|
|
def _set_random_wallpaper(self):
|
|
"""Set a random wallpaper."""
|
|
if not self.wallpapers:
|
|
return
|
|
|
|
filename = random.choice(self.wallpapers)
|
|
self._set_wallpaper(filename)
|
|
# Show notification for immediate feedback
|
|
exec_shell_command_async(
|
|
f"notify-send '🎲 Random Wallpaper' 'Applied: {filename}' -a '{
|
|
data.APP_NAME_CAP
|
|
}' -e"
|
|
)
|
|
return filename
|
|
|
|
def _hsl_to_rgb_hex(self, h: float, s: float = 1.0, l: float = 0.5) -> str:
|
|
"""Convert HSL color value to RGB HEX string."""
|
|
# colorsys uses HLS, not HSL, and expects values between 0.0 and 1.0
|
|
hue = h / 360.0
|
|
r, g, b = colorsys.hls_to_rgb(hue, l, s) # Note the order: H, L, S
|
|
r_int, g_int, b_int = int(r * 255), int(g * 255), int(b * 255)
|
|
return f"#{r_int:02X}{g_int:02X}{b_int:02X}"
|
|
|
|
def _is_valid_hex_color(self, hex_color: str) -> bool:
|
|
"""Check if string is a valid hex color."""
|
|
if not hex_color.startswith("#"):
|
|
hex_color = "#" + hex_color
|
|
return bool(re.match(r"^#[0-9A-Fa-f]{6}$", hex_color))
|
|
|
|
def _get_current_scheme(self) -> str:
|
|
"""Get current color scheme (default to tonal-spot)."""
|
|
# You could store this in a config file, for now use default
|
|
return "scheme-tonal-spot"
|
|
|
|
def _set_current_scheme(self, scheme: str):
|
|
"""Set current color scheme."""
|
|
# For now, just use it immediately. Could be stored in config later.
|
|
scheme_name = self.schemes.get(scheme, scheme)
|
|
matugen_enabled = self._get_matugen_state()
|
|
|
|
# Show notification with matugen status
|
|
if matugen_enabled:
|
|
exec_shell_command_async(
|
|
f"notify-send '🎨 Color Scheme' 'Set to {
|
|
scheme_name
|
|
}\\nMatugen: Enabled' -a '{data.APP_NAME_CAP}' -e"
|
|
)
|
|
else:
|
|
exec_shell_command_async(
|
|
f"notify-send '⚠️ Color Scheme' 'Set to {
|
|
scheme_name
|
|
}\\nMatugen: Disabled (enable for effect)' -a '{data.APP_NAME_CAP}' -e"
|
|
)
|
|
|
|
def _apply_hex_color(self, hex_color: str, scheme: str = None):
|
|
"""Apply hex color using matugen."""
|
|
if not hex_color.startswith("#"):
|
|
hex_color = "#" + hex_color
|
|
|
|
if scheme is None:
|
|
scheme = self._get_current_scheme()
|
|
|
|
exec_shell_command_async(f'matugen color hex "{hex_color}" -t {scheme}')
|
|
scheme_name = self.schemes.get(scheme, scheme)
|
|
exec_shell_command_async(
|
|
f"notify-send '🎨 Hex Color Applied' 'Color: {hex_color}\\nScheme: {
|
|
scheme_name
|
|
}' -a '{data.APP_NAME_CAP}' -e"
|
|
)
|
|
|
|
def _generate_random_hex_color(self) -> str:
|
|
"""Generate a random hex color."""
|
|
hue = random.randint(0, 360)
|
|
return self._hsl_to_rgb_hex(hue)
|
|
|
|
def _get_status_indicators(self) -> tuple:
|
|
"""Get current status indicators for display."""
|
|
current_scheme = self._get_current_scheme()
|
|
matugen_enabled = self._get_matugen_state()
|
|
scheme_name = self.schemes.get(current_scheme, current_scheme)
|
|
|
|
indicators = []
|
|
if not matugen_enabled:
|
|
indicators.append("⚠ Matugen Off")
|
|
|
|
indicator_text = " • " + " • ".join(indicators) if indicators else ""
|
|
status_text = f"Matugen: {
|
|
'Enabled' if matugen_enabled else 'Disabled'
|
|
} • Scheme: {scheme_name}"
|
|
|
|
return indicator_text, status_text, current_scheme, matugen_enabled
|
|
|
|
def query(self, query_string: str) -> List[Result]:
|
|
"""Search wallpapers and provide management options."""
|
|
results = []
|
|
query = query_string.lower().strip()
|
|
|
|
# Get status indicators for consistent display
|
|
indicator_text, status_text, current_scheme, matugen_enabled = (
|
|
self._get_status_indicators()
|
|
)
|
|
|
|
# Special commands
|
|
if query == "random" or query.startswith("random"):
|
|
# Execute immediately when this result is created/selected
|
|
self._set_random_wallpaper()
|
|
results.append(
|
|
Result(
|
|
title=f"Random Wallpaper Applied{indicator_text}",
|
|
subtitle=f"A random wallpaper has been set • {status_text}",
|
|
icon_markup=random.choice(
|
|
[
|
|
icons.dice_1,
|
|
icons.dice_2,
|
|
icons.dice_3,
|
|
icons.dice_4,
|
|
icons.dice_5,
|
|
icons.dice_6,
|
|
]
|
|
),
|
|
action=lambda: None, # No action needed since already executed
|
|
relevance=1.0,
|
|
plugin_name=self.display_name,
|
|
data={
|
|
"action": "random",
|
|
"executed": True,
|
|
"bypass_max_results": True,
|
|
},
|
|
)
|
|
)
|
|
|
|
# Hex color commands
|
|
if "color" in query or "hex" in query or query.startswith("#"):
|
|
# Check for scheme specification in the query
|
|
scheme = self._get_current_scheme()
|
|
for scheme_id, scheme_name in self.schemes.items():
|
|
if (
|
|
scheme_name.lower() in query.lower()
|
|
or scheme_id.lower() in query.lower()
|
|
):
|
|
scheme = scheme_id
|
|
break
|
|
|
|
# Check for hex color patterns
|
|
hex_match = re.search(r"#?([0-9A-Fa-f]{6})", query)
|
|
if hex_match:
|
|
hex_color = "#" + hex_match.group(1)
|
|
# Execute immediately
|
|
self._apply_hex_color(hex_color, scheme)
|
|
scheme_name = self.schemes.get(scheme, scheme)
|
|
results.append(
|
|
Result(
|
|
title=f"Hex Color Applied: {hex_color}{indicator_text}",
|
|
subtitle=f"Applied with {scheme_name} scheme • {status_text}",
|
|
icon_markup=icons.palette,
|
|
action=lambda: None, # No action needed since already executed
|
|
relevance=1.0,
|
|
plugin_name=self.display_name,
|
|
data={
|
|
"action": "hex_color",
|
|
"color": hex_color,
|
|
"scheme": scheme,
|
|
"executed": True,
|
|
"bypass_max_results": True,
|
|
},
|
|
)
|
|
)
|
|
elif "random" in query:
|
|
# Random hex color
|
|
hex_color = self._generate_random_hex_color()
|
|
self._apply_hex_color(hex_color, scheme)
|
|
scheme_name = self.schemes.get(scheme, scheme)
|
|
results.append(
|
|
Result(
|
|
title=f"Random Color Applied: {hex_color}{indicator_text}",
|
|
subtitle=f"Applied with {scheme_name} scheme • {status_text}",
|
|
icon_markup=icons.palette,
|
|
action=lambda: None, # No action needed since already executed
|
|
relevance=1.0,
|
|
plugin_name=self.display_name,
|
|
data={
|
|
"action": "random_hex",
|
|
"color": hex_color,
|
|
"scheme": scheme,
|
|
"executed": True,
|
|
"bypass_max_results": True,
|
|
},
|
|
)
|
|
)
|
|
else:
|
|
# Show hex color help
|
|
results.append(
|
|
Result(
|
|
title="Hex Color Commands",
|
|
subtitle="Use: color #FF5733, hex #00FF00, color random, or add scheme name",
|
|
icon_markup=icons.palette,
|
|
action=lambda: None,
|
|
relevance=0.8,
|
|
plugin_name=self.display_name,
|
|
data={"action": "hex_help", "bypass_max_results": True},
|
|
)
|
|
)
|
|
|
|
# Color scheme commands
|
|
if "scheme" in query:
|
|
current_scheme = self._get_current_scheme()
|
|
matugen_enabled = self._get_matugen_state()
|
|
|
|
# Show all available schemes
|
|
for scheme_id, scheme_name in self.schemes.items():
|
|
# Check if this scheme matches the query (for filtering)
|
|
if (
|
|
query.strip() == "scheme"
|
|
or scheme_name.lower() in query.lower()
|
|
or scheme_id.lower() in query.lower()
|
|
):
|
|
# Create indicators
|
|
indicators = []
|
|
if scheme_id == current_scheme:
|
|
indicators.append("● Current")
|
|
if not matugen_enabled:
|
|
indicators.append("⚠ Matugen Off")
|
|
|
|
indicator_text = (
|
|
" • " + " • ".join(indicators) if indicators else ""
|
|
)
|
|
|
|
results.append(
|
|
Result(
|
|
title=f"{scheme_name}{indicator_text}",
|
|
subtitle=f"Set color scheme to {scheme_name}"
|
|
+ (
|
|
" (requires matugen enabled)"
|
|
if not matugen_enabled
|
|
else ""
|
|
),
|
|
icon_markup=icons.palette,
|
|
action=lambda s=scheme_id: self._set_current_scheme(s),
|
|
relevance=1.0 if scheme_id == current_scheme else 0.8,
|
|
plugin_name=self.display_name,
|
|
data={
|
|
"action": "scheme_select",
|
|
"scheme": scheme_id,
|
|
"bypass_max_results": True,
|
|
},
|
|
)
|
|
)
|
|
|
|
# Matugen controls
|
|
if "matugen" in query:
|
|
current_state = self._get_matugen_state()
|
|
if "on" in query or "enable" in query:
|
|
# Execute immediately
|
|
self._set_matugen_state(True)
|
|
# Get updated status after change
|
|
new_indicator_text, new_status_text, _, _ = (
|
|
self._get_status_indicators()
|
|
)
|
|
results.append(
|
|
Result(
|
|
title=f"Matugen Enabled{new_indicator_text}",
|
|
subtitle=f"Dynamic color generation is now enabled • {
|
|
new_status_text
|
|
}",
|
|
icon_markup=icons.palette,
|
|
action=lambda: None, # No action needed since already executed
|
|
relevance=0.9,
|
|
plugin_name=self.display_name,
|
|
data={
|
|
"action": "matugen_on",
|
|
"executed": True,
|
|
"bypass_max_results": True,
|
|
},
|
|
)
|
|
)
|
|
elif "off" in query or "disable" in query:
|
|
# Execute immediately
|
|
self._set_matugen_state(False)
|
|
# Get updated status after change
|
|
new_indicator_text, new_status_text, _, _ = (
|
|
self._get_status_indicators()
|
|
)
|
|
results.append(
|
|
Result(
|
|
title=f"Matugen Disabled{new_indicator_text}",
|
|
subtitle=f"Dynamic color generation is now disabled • {
|
|
new_status_text
|
|
}",
|
|
icon_markup=icons.palette,
|
|
action=lambda: None, # No action needed since already executed
|
|
relevance=0.9,
|
|
plugin_name=self.display_name,
|
|
data={
|
|
"action": "matugen_off",
|
|
"executed": True,
|
|
"bypass_max_results": True,
|
|
},
|
|
)
|
|
)
|
|
elif "toggle" in query:
|
|
# Execute toggle immediately
|
|
new_state = not current_state
|
|
self._set_matugen_state(new_state)
|
|
# Get updated status after change
|
|
new_indicator_text, new_status_text, _, _ = (
|
|
self._get_status_indicators()
|
|
)
|
|
results.append(
|
|
Result(
|
|
title=f"Matugen {'Enabled' if new_state else 'Disabled'}{
|
|
new_indicator_text
|
|
}",
|
|
subtitle=f"Dynamic color generation is now {
|
|
'enabled' if new_state else 'disabled'
|
|
} • {new_status_text}",
|
|
icon_markup=icons.palette,
|
|
action=lambda: None, # No action needed since already executed
|
|
relevance=0.9,
|
|
plugin_name=self.display_name,
|
|
data={
|
|
"action": "matugen_toggle",
|
|
"executed": True,
|
|
"bypass_max_results": True,
|
|
},
|
|
)
|
|
)
|
|
else:
|
|
# Show current state with scheme info
|
|
results.append(
|
|
Result(
|
|
title=f"Matugen: {'Enabled' if current_state else 'Disabled'}{
|
|
indicator_text
|
|
}",
|
|
subtitle=f"Dynamic colors • {status_text}",
|
|
icon_markup=icons.palette,
|
|
action=lambda: None,
|
|
relevance=0.8,
|
|
plugin_name=self.display_name,
|
|
data={"action": "matugen_status", "bypass_max_results": True},
|
|
)
|
|
)
|
|
|
|
# Status command
|
|
if query == "status" or query == "info":
|
|
results.append(
|
|
Result(
|
|
title=f"Wallpaper System Status{indicator_text}",
|
|
subtitle=status_text,
|
|
icon_markup=icons.palette,
|
|
action=lambda: None,
|
|
relevance=1.0,
|
|
plugin_name=self.display_name,
|
|
data={"action": "status", "bypass_max_results": True},
|
|
)
|
|
)
|
|
|
|
# Handle empty query (just trigger keywords: wall, wallpaper, wp)
|
|
if not query:
|
|
# Show status and quick actions when just typing trigger keywords
|
|
results.append(
|
|
Result(
|
|
title=f"Wallpaper System{indicator_text}",
|
|
subtitle=f"{
|
|
status_text
|
|
} • Type commands: random, scheme, status, matugen",
|
|
icon_markup=icons.wallpapers,
|
|
action=lambda: None,
|
|
relevance=1.0,
|
|
plugin_name=self.display_name,
|
|
data={"action": "overview", "bypass_max_results": True},
|
|
)
|
|
)
|
|
|
|
# Show quick actions
|
|
results.append(
|
|
Result(
|
|
title=f"Random Wallpaper{indicator_text}",
|
|
subtitle=f"Set a random wallpaper • {status_text}",
|
|
icon_markup=random.choice(
|
|
[
|
|
icons.dice_1,
|
|
icons.dice_2,
|
|
icons.dice_3,
|
|
icons.dice_4,
|
|
icons.dice_5,
|
|
icons.dice_6,
|
|
]
|
|
),
|
|
action=lambda: self._set_random_wallpaper(),
|
|
relevance=0.9,
|
|
plugin_name=self.display_name,
|
|
data={"action": "random_quick", "bypass_max_results": True},
|
|
)
|
|
)
|
|
|
|
# Search wallpapers by filename
|
|
if not query or (
|
|
query
|
|
and "matugen" not in query
|
|
and "random" not in query
|
|
and "scheme" not in query
|
|
and "status" not in query
|
|
and "info" not in query
|
|
and "color" not in query
|
|
and "hex" not in query
|
|
):
|
|
matching_wallpapers = []
|
|
for wallpaper in self.wallpapers:
|
|
if not query or query in wallpaper.lower():
|
|
# Calculate relevance
|
|
relevance = 1.0 if query == wallpaper.lower() else 0.7
|
|
if query and query in wallpaper.lower():
|
|
relevance = 0.8
|
|
matching_wallpapers.append((wallpaper, relevance))
|
|
|
|
# Sort by relevance - no limit since we use bypass_max_results
|
|
matching_wallpapers.sort(key=lambda x: x[1], reverse=True)
|
|
|
|
for wallpaper, relevance in matching_wallpapers:
|
|
# Only create thumbnails for displayed results
|
|
cache_path = self._get_cache_path(wallpaper)
|
|
icon = None
|
|
|
|
# Try to load existing thumbnail first
|
|
if os.path.exists(cache_path):
|
|
try:
|
|
icon = GdkPixbuf.Pixbuf.new_from_file_at_scale(
|
|
cache_path, 32, 32, True
|
|
)
|
|
except Exception as e:
|
|
print(f"Error loading existing thumbnail: {e}")
|
|
|
|
results.append(
|
|
Result(
|
|
title=f"{wallpaper}{indicator_text if not query else ''}",
|
|
subtitle=f"Set as wallpaper{
|
|
' • ' + status_text if not query else ''
|
|
}",
|
|
icon=icon,
|
|
icon_markup=icons.wallpapers if not icon else None,
|
|
action=lambda w=wallpaper: self._set_wallpaper(w),
|
|
relevance=relevance,
|
|
plugin_name=self.display_name,
|
|
data={
|
|
"wallpaper": wallpaper,
|
|
"action": "set",
|
|
"bypass_max_results": True,
|
|
},
|
|
)
|
|
)
|
|
|
|
# Sort by relevance - no limit since we use bypass_max_results
|
|
results.sort(key=lambda x: x.relevance, reverse=True)
|
|
return results
|