feat(update): huge changes

This commit is contained in:
sankalp committed 2025-04-25 06:33:51 +05:45
1 parent 53c077106f
commit 6b9b419aa9
98 files changed
+9636 -5575

No files matched your search

+454 -151
View File
@@ -1,201 +1,504 @@
import os
import subprocess
from typing import List
from fabric import Fabricator
from fabric.widgets.box import Box
from fabric.widgets.label import Label
from fabric.widgets.button import Button
from fabric.widgets.entry import Entry
from fabric.widgets.label import Label
from fabric.widgets.image import Image
from fabric.widgets.scrolledwindow import ScrolledWindow
from gi.repository import GLib
from fabric.utils import idle_add, remove_handler
from fabric.utils.helpers import get_relative_path
from gi.repository import GLib, Gdk, GdkPixbuf
import subprocess
import os
import re
import sys
import tempfile
import utils.icons as icons
class Cliphist(Box):
class ClipHistory(Box):
def __init__(self, **kwargs):
super().__init__(
name="cliphist-launcher",
all_visible=False,
name="clip-history",
visible=False,
all_visible=False,
**kwargs,
)
self._arranger_handler = 0
self.cliphist_manager = CliphistManager(self)
self.viewport = None
self.launcher = kwargs["launcher"]
# Create a temporary directory for image icons
self.tmp_dir = tempfile.mkdtemp(prefix="cliphist-")
self.image_cache = {} # Cache for image previews
self.launcher = kwargs["launcher"]
self.selected_index = -1 # Track the selected item index
self._arranger_handler = 0
self.clipboard_items = []
self._loading = False
self._pending_updates = False
self.viewport = Box(name="viewport", spacing=4, orientation="v")
self.search_entry = Entry(
name="search-entry",
placeholder="Search Clipboard History...",
h_expand=True,
on_activate=self._on_search_activate,
notify_text=self.filter_items,
on_activate=lambda entry, *_: self.use_selected_item(),
on_key_press_event=self.on_search_entry_key_press,
)
self.search_entry.props.xalign = 0.5
self.scrolled_window = ScrolledWindow(
name="scrolled-window",
spacing=10,
min_content_size=(450, 105),
max_content_size=(450, 105),
child=self.viewport,
)
self.header_box = Box(
name="header-box",
name="header_box",
spacing=10,
orientation="h",
children=[
self.search_entry,
Button(
name="clear-button",
child=Label(name="cliphist-clear-button", markup=icons.clear),
tooltip_text="Clear Clipboard History",
on_clicked=self.handle_clear_history,
child=Label(name="clear-label", markup=icons.trash),
on_clicked=lambda *_: self.clear_history(),
),
self.search_entry,
],
)
self.launcher_box = Box(
name="cliphist-launcher-box",
self.history_box = Box(
name="launcher-box",
spacing=10,
orientation="v",
h_expand=True,
children=[self.header_box],
orientation="v",
children=[
self.header_box,
self.scrolled_window,
],
)
self.add(self.launcher_box)
def _on_search_activate(self, entry, *args):
self.handle_search(entry.get_text())
def open_launcher(self):
if not self.viewport:
self.viewport = Box(name="viewport", spacing=4, orientation="v")
self.scrolled_window = ScrolledWindow(
name="scrolled-window",
spacing=10,
min_content_size=(-1, -1),
h_scrollbar_policy="never",
child=self.viewport,
)
self.launcher_box.add(self.scrolled_window)
self.add(self.history_box)
self.show_all()
def close(self):
"""Close the clipboard history panel"""
self.viewport.children = []
self.cliphist_manager.update_cliphist_history()
self.viewport.show()
self.search_entry.grab_focus()
def handle_search(self, text: str):
self.cliphist_manager.arrange_viewport(query=text)
def close_launcher(self):
self.selected_index = -1 # Reset selection
self.launcher.close()
def handle_clear_history(self, *_):
GLib.spawn_command_line_async("cliphist wipe")
self.cliphist_manager.update_cliphist_history()
def open(self):
"""Open the clipboard history panel and load items"""
self.viewport.set_visible(True)
if self._loading:
return
self._loading = True
self.search_entry.set_text("") # Clear search
self.search_entry.grab_focus()
# Start loading in background using GLib.idle_add
GLib.idle_add(self._load_clipboard_items_thread)
class CliphistManager:
def __init__(self, launcher):
self.launcher = launcher
self.cliphist_history = []
self.wl_paste_watcher = Fabricator(
poll_from="wl-paste --watch echo", stream=True, interval=-1
)
self.wl_paste_watcher.connect("changed", self._on_wl_paste_changed)
def _on_wl_paste_changed(self, *args):
self.update_cliphist_history()
def get_clip_history(self) -> List[dict]:
def _load_clipboard_items_thread(self):
"""Worker for loading clipboard items, now runs in main loop via idle_add"""
try:
result = subprocess.run(
["cliphist", "list"], capture_output=True, text=True, check=True
)
return self._parse_clip_history(result.stdout)
lines = result.stdout.strip().split("\n")
new_items = []
for line in lines:
if not line or "<meta http-equiv" in line:
continue
new_items.append(line)
self._update_items(new_items)
except subprocess.CalledProcessError as e:
print(f"Error fetching cliphist history: {e}")
return []
print(f"Error loading clipboard history: {e}", file=sys.stderr)
except Exception as e:
print(f"Unexpected error: {e}", file=sys.stderr)
finally:
self._loading = False
if self._pending_updates:
self._pending_updates = False
GLib.idle_add(self._load_clipboard_items_thread)
return False # Ensure idle_add does not repeat
def _parse_clip_history(self, output: str) -> List[dict]:
items = []
for line in output.splitlines():
if line.strip():
parts = line.strip().split(maxsplit=1)
if len(parts) == 2:
items.append({"id": parts[0], "content": parts[1]})
return items
def _update_items(self, new_items):
"""Update the items list from main thread"""
self.clipboard_items = new_items
self.display_clipboard_items()
def copy_clip(self, clip_id: str):
try:
decode_result = subprocess.run(
["cliphist", "decode", clip_id], capture_output=True, check=True
)
subprocess.run(["wl-copy"], input=decode_result.stdout, check=True)
self.launcher.close_launcher()
except subprocess.CalledProcessError as e:
print(f"Error copying clip {clip_id}: {e}")
def display_clipboard_items(self, filter_text=""):
"""Display clipboard items in the viewport"""
remove_handler(self._arranger_handler) if self._arranger_handler else None
self.viewport.children = []
self.selected_index = -1 # Reset selection
def save_image_file(self, clip_id: str) -> str:
output_file = f"/tmp/cliphist-{clip_id}.png"
os.makedirs("/tmp", exist_ok=True)
try:
decode_result = subprocess.run(
["cliphist", "decode", clip_id], capture_output=True, check=True
)
with open(output_file, "wb") as f:
f.write(decode_result.stdout)
return output_file
except (subprocess.CalledProcessError, IOError) as e:
print(f"Error saving image file for clip {clip_id}: {e}")
return ""
# Filter items if search text is provided
filtered_items = []
for item in self.clipboard_items:
# Extract just the content part (after the first tab)
content = item.split("\t", 1)[1] if "\t" in item else item
if filter_text.lower() in content.lower():
filtered_items.append(item)
def update_cliphist_history(self):
self.cliphist_history = self.get_clip_history()
self.arrange_viewport()
def query_clips(self, query: str = "") -> List[dict]:
if not query.strip():
return self.cliphist_history
return [
clip
for clip in self.cliphist_history
if query.lower() in clip["content"].lower()
]
def _on_clip_clicked(self, clip_id: str, *args):
self.copy_clip(clip_id)
def bake_clip_slot(self, item: dict) -> Button:
if "[[ binary data" in item["content"].lower():
return self._create_image_button(item)
return self._create_text_button(item)
def _create_image_button(self, item: dict) -> Button:
output_file = self.save_image_file(item["id"])
if output_file and os.path.exists(output_file):
button = Button(
h_align="start",
name="clip-img-item",
on_clicked=lambda _, clip_id=item["id"]: self.copy_clip(clip_id),
)
button.set_style(
f"background-image: url('{output_file}'); background-size: cover; background-position: center;"
)
return button
return None
def _create_text_button(self, item: dict) -> Button:
return Button(
child=Label(
label=item["content"][:35]
+ ("..." if len(item["content"]) > 35 else ""),
h_expand=True,
# Show message if no items are found
if not filtered_items:
# Create a container box to better center the message
container = Box(
name="no-clip-container",
orientation="v",
h_align="center",
v_align="center",
h_align="start",
),
on_clicked=lambda _, clip_id=item["id"]: self.copy_clip(clip_id),
name="clip-item",
h_expand=True,
v_expand=True,
)
# Show a message if no clipboard items
label = Label(
name="no-clip",
markup=icons.clipboard,
h_align="center",
v_align="center",
)
container.add(label)
self.viewport.add(container)
return
# Display items in batches to prevent UI freeze
self._display_items_batch(filtered_items, 0, 10)
def _display_items_batch(self, items, start, batch_size):
"""Display items in batches to keep UI responsive"""
end = min(start + batch_size, len(items))
for i in range(start, end):
item = items[i]
self.viewport.add(self.create_clipboard_item(item))
# Schedule next batch if there are more items
if end < len(items):
GLib.idle_add(self._display_items_batch, items, end, batch_size)
else:
# Auto-select first item if we have filter text
if self.search_entry.get_text() and self.viewport.get_children():
self.update_selection(0)
def create_clipboard_item(self, item):
"""Create a button for a clipboard item"""
# Extract ID and content
parts = item.split("\t", 1)
item_id = parts[0] if len(parts) > 1 else "0"
content = parts[1] if len(parts) > 1 else item
# Truncate content for display
display_text = content.strip()
if len(display_text) > 100:
display_text = display_text[:97] + "..."
# Check if this is an image by examining the content
is_image = self.is_image_data(content)
if is_image:
# For images, create item with image preview
button = Button(
name="slot-button",
child=Box(
name="slot-box",
orientation="h",
spacing=10,
children=[
Image(name="clip-icon", h_align="start"), # Placeholder
Label(
name="clip-label",
label="[Image]",
ellipsization="end",
v_align="center",
h_align="start",
h_expand=True,
),
],
),
tooltip_text="Image in clipboard",
on_clicked=lambda *_, id=item_id: self.paste_item(id),
)
# Load image preview in background
self._load_image_preview_async(item_id, button)
else:
# For text, create regular item
button = self.create_text_item_button(item_id, display_text)
# Add key press event handler for Enter key
button.connect(
"key-press-event",
lambda widget, event, id=item_id: self.on_item_key_press(widget, event, id),
)
def arrange_viewport(self, query: str = ""):
if not self.launcher.viewport:
# Make sure button can receive focus and key events
button.set_can_focus(True)
button.add_events(Gdk.EventMask.KEY_PRESS_MASK)
return button
def _load_image_preview_async(self, item_id, button):
"""Load image preview using GLib.idle_add instead of threads"""
def load_image():
try:
if item_id in self.image_cache:
pixbuf = self.image_cache[item_id]
else:
result = subprocess.run(
["cliphist", "decode", item_id], capture_output=True, check=True
)
loader = GdkPixbuf.PixbufLoader()
loader.write(result.stdout)
loader.close()
pixbuf = loader.get_pixbuf()
width, height = pixbuf.get_width(), pixbuf.get_height()
max_size = 72
if width > height:
new_width = max_size
new_height = int(height * (max_size / width))
else:
new_height = max_size
new_width = int(width * (max_size / height))
pixbuf = pixbuf.scale_simple(
new_width, new_height, GdkPixbuf.InterpType.BILINEAR
)
self.image_cache[item_id] = pixbuf
self._update_image_button(button, pixbuf)
except Exception as e:
print(f"Error loading image preview: {e}", file=sys.stderr)
return False
GLib.idle_add(load_image)
def _update_image_button(self, button, pixbuf):
"""Update the button with the loaded image preview"""
box = button.get_child()
if box and len(box.get_children()) > 0:
image_widget = box.get_children()[0]
if isinstance(image_widget, Image):
image_widget.set_from_pixbuf(pixbuf)
def create_text_item_button(self, item_id, display_text):
"""Create a button for a text clipboard item"""
return Button(
name="slot-button",
child=Box(
name="slot-box",
orientation="h",
spacing=10,
children=[
Label(
name="clip-icon",
markup=icons.clip_text,
h_align="start",
),
Label(
name="clip-label",
label=display_text,
ellipsization="end",
v_align="center",
h_align="start",
h_expand=True,
),
],
),
tooltip_text=display_text,
on_clicked=lambda *_: self.paste_item(item_id),
)
def is_image_data(self, content):
"""Determine if clipboard content is likely an image"""
# Check for common image data patterns
return (
content.startswith("data:image/")
or content.startswith("\x89PNG")
or content.startswith("GIF8")
or content.startswith("\xff\xd8\xff") # JPEG
or re.match(r"^\s*<img\s+", content) is not None # HTML image tag
or "binary" in content.lower()
and any(
ext in content.lower() for ext in ["jpg", "jpeg", "png", "bmp", "gif"]
)
)
def paste_item(self, item_id):
"""Copy the selected item to the clipboard and close (GLib.idle_add)"""
def paste():
try:
result = subprocess.run(
["cliphist", "decode", item_id], capture_output=True, check=True
)
subprocess.run(["wl-copy"], input=result.stdout, check=True)
GLib.idle_add(self.close)
except subprocess.CalledProcessError as e:
print(f"Error pasting clipboard item: {e}", file=sys.stderr)
return False
GLib.idle_add(paste)
def delete_item(self, item_id):
"""Delete the selected clipboard item (GLib.idle_add)"""
def delete():
try:
subprocess.run(["cliphist", "delete", item_id], check=True)
self._pending_updates = True
if not self._loading:
GLib.idle_add(self._load_clipboard_items_thread)
except subprocess.CalledProcessError as e:
print(f"Error deleting clipboard item: {e}", file=sys.stderr)
return False
GLib.idle_add(delete)
def clear_history(self):
"""Clear all clipboard history (GLib.idle_add)"""
def clear():
try:
subprocess.run(["cliphist", "wipe"], check=True)
self._pending_updates = True
if not self._loading:
GLib.idle_add(self._load_clipboard_items_thread)
except subprocess.CalledProcessError as e:
print(f"Error clearing clipboard history: {e}", file=sys.stderr)
return False
GLib.idle_add(clear)
def filter_items(self, entry, *_):
"""Filter clipboard items based on search text"""
self.display_clipboard_items(entry.get_text())
def on_search_entry_key_press(self, widget, event):
"""Handle key presses in the search entry"""
if event.keyval == Gdk.KEY_Down:
self.move_selection(1)
return True
elif event.keyval == Gdk.KEY_Up:
self.move_selection(-1)
return True
elif event.keyval in (Gdk.KEY_Return, Gdk.KEY_KP_Enter):
self.use_selected_item()
return True
elif event.keyval == Gdk.KEY_Delete:
self.delete_selected_item()
return True
elif event.keyval == Gdk.KEY_Escape:
self.close()
return True
return False
def update_selection(self, new_index):
"""Update the selected item in the viewport"""
children = self.viewport.get_children()
# Unselect current
if self.selected_index != -1 and self.selected_index < len(children):
current_button = children[self.selected_index]
current_button.get_style_context().remove_class("selected")
# Select new
if new_index != -1 and new_index < len(children):
new_button = children[new_index]
new_button.get_style_context().add_class("selected")
self.selected_index = new_index
self.scroll_to_selected(new_button)
else:
self.selected_index = -1
def move_selection(self, delta):
"""Move the selection up or down"""
children = self.viewport.get_children()
if not children:
return
self.launcher.viewport.children = []
filtered_clips = self.query_clips(query)
for clip in filtered_clips:
button = self.bake_clip_slot(clip)
if button:
self.launcher.viewport.add(button)
# Allow starting selection from nothing
if self.selected_index == -1 and delta == 1:
new_index = 0
else:
new_index = self.selected_index + delta
new_index = max(0, min(new_index, len(children) - 1))
self.update_selection(new_index)
def scroll_to_selected(self, button):
"""Scroll to ensure the selected item is visible"""
def scroll():
adj = self.scrolled_window.get_vadjustment()
alloc = button.get_allocation()
if alloc.height == 0:
return False # Retry if allocation isn't ready
y = alloc.y
height = alloc.height
page_size = adj.get_page_size()
current_value = adj.get_value()
# Calculate visible boundaries
visible_top = current_value
visible_bottom = current_value + page_size
if y < visible_top:
# Item above viewport - align to top
adj.set_value(y)
elif y + height > visible_bottom:
# Item below viewport - align to bottom
new_value = y + height - page_size
adj.set_value(new_value)
return False
GLib.idle_add(scroll)
def use_selected_item(self):
"""Use (paste) the selected clipboard item"""
children = self.viewport.get_children()
if (
not children
or self.selected_index == -1
or self.selected_index >= len(self.clipboard_items)
):
return
# Get the item ID from the first part before the tab
item_line = self.clipboard_items[self.selected_index]
item_id = item_line.split("\t", 1)[0]
self.paste_item(item_id)
def delete_selected_item(self):
"""Delete the selected clipboard item"""
children = self.viewport.get_children()
if not children or self.selected_index == -1:
return
# Get the item ID from the first part before the tab
item_line = self.clipboard_items[self.selected_index]
item_id = item_line.split("\t", 1)[0]
self.delete_item(item_id)
def on_item_key_press(self, widget, event, item_id):
"""Handle key press events on clipboard items"""
if event.keyval in (Gdk.KEY_Return, Gdk.KEY_KP_Enter):
# Copy item to clipboard and close
self.paste_item(item_id)
return True
return False
def __del__(self):
"""Clean up temporary files on destruction"""
try:
if hasattr(self, "tmp_dir") and os.path.exists(self.tmp_dir):
import shutil
shutil.rmtree(self.tmp_dir)
self.image_cache.clear()
except Exception as e:
print(f"Error cleaning up temporary files: {e}", file=sys.stderr)