feat: enhance clipboard history with fuzzy search and paste simulation

d7omdev · d7omdev · commit cc3b35781ccd · 2025-05-06T21:35:09.000+03:00
- Introduced `fuzzy_search` utility for improved search functionality.
- Replaced manual filtering logic in `update_filtered_items` with
`fuzzy_search`.
- Added `with_paste_simulation` parameter to
`copy_selected_item_to_clipboard` and `on_row_activated` for optional
paste simulation.
- Improved keyboard navigation logic for list rows, including support
for Page Up/Down.
- Updated help window to include "Shift + Enter" for copy and paste
functionality.
- Adjusted logging levels for better debugging and reduced verbosity.
- Enhanced error handling and user feedback during copy operations.
diff --git a/clipse_gui/controller.py b/clipse_gui/controller.py
@@ -24,6 +24,7 @@
 from .image_handler import ImageHandler
 from .ui_components import create_list_row_widget, show_help_window, show_preview_window
 from .ui_builder import build_main_window_content
+from .utils import fuzzy_search
 
 from gi.repository import Gdk, GLib, Gtk, Pango  # noqa: E402
 
@@ -48,7 +49,7 @@ def __init__(self, application_window: Gtk.ApplicationWindow):
         self._search_timer_id = None
         self._vadjustment_handler_id = None
         self._is_wayland = "wayland" in os.environ.get("XDG_SESSION_TYPE", "").lower()
-        log.info(f"Detected session type: {'Wayland' if self._is_wayland else 'X11'}")
+        log.debug(f"Detected session type: {'Wayland' if self._is_wayland else 'X11'}")
 
         self.data_manager = DataManager(update_callback=self._on_history_updated)
         self.image_handler = ImageHandler(IMAGE_CACHE_MAX_SIZE or 50)
@@ -151,24 +152,15 @@ def _focus_first_item(self):
 
     def update_filtered_items(self):
         """Filters master list based on search and pin status, then updates UI."""
-        self.filtered_items = []
-        search_term_lower = self.search_term.lower()
-
-        for index, item in enumerate(self.items):
-            is_pinned = item.get("pinned", False)
-            if self.show_only_pinned and not is_pinned:
-                continue
-
-            if search_term_lower:
-                item_value = item.get("value", "").lower()
-                match = search_term_lower in item_value
-                if not match and item.get("filePath"):
-                    match = search_term_lower in item.get("filePath", "").lower()
-                if not match:
-                    continue
-
-            self.filtered_items.append({"original_index": index, "item": item})
 
+        self.filtered_items = fuzzy_search(
+            items=self.items,
+            search_term=self.search_term,
+            value_key="value",
+            path_key="filePath",
+            pinned_key="pinned",
+            show_only_pinned=self.show_only_pinned,
+        )
         self.populate_list_view()
         self.update_status_label()
         GLib.idle_add(self.check_load_more)
@@ -716,7 +708,7 @@ def copy_image_to_clipboard(self, image_path):
             self.flash_status(f"Error copying image: {str(e)[:100]}")
             return False
 
-    def copy_selected_item_to_clipboard(self):
+    def copy_selected_item_to_clipboard(self, with_paste_simulation=False):
         """Copies the selected item to the system clipboard and closes the window."""
         selected_row = self.list_box.get_selected_row()
         exit_timeout = 150
@@ -768,15 +760,19 @@ def close_window_callback(window):
                     self.flash_status("Cannot copy null text value.")
 
             if copy_successful:
-                if ENTER_TO_PASTE:
+                if ENTER_TO_PASTE or with_paste_simulation:
                     log.debug("Hiding window and scheduling paste simulation.")
                     self.window.hide()
-                GLib.timeout_add(
-                    PASTE_SIMULATION_DELAY_MS or 150,
-                    self._trigger_paste_simulation_and_quit,
-                )
+                    GLib.timeout_add(
+                        PASTE_SIMULATION_DELAY_MS or 150,
+                        self._trigger_paste_simulation_and_quit,
+                    )
+                else:
+                    GLib.timeout_add(100, self._quit_application)
             else:
-                GLib.timeout_add(100, self._quit_application)
+                log.error("Copy operation failed.")
+                self.flash_status("Error: Copy operation failed.")
+                GLib.timeout_add(exit_timeout, close_window_callback, self.window)
 
         except Exception as e:
             log.error(f"Unexpected error during copy selection: {e}", exc_info=True)
@@ -808,7 +804,6 @@ def _quit_application(self):
 
     def paste_from_clipboard_simulated(self):
         """Pastes FROM the clipboard by simulating key presses (Ctrl+V)."""
-        print(self._is_wayland, "Is Wayland")
         if self._is_wayland:
             cmd_str = str(PASTE_SIMULATION_CMD_WAYLAND)
             tool_name = "wtype"
@@ -1030,49 +1025,80 @@ def on_key_press(self, widget, event):
                 return True
 
             if keyval in [Gdk.KEY_Up, Gdk.KEY_Down, Gdk.KEY_Page_Up, Gdk.KEY_Page_Down]:
-                if len(self.list_box.get_children()) > 0:
-                    self.list_box.grab_focus()
+                focusable_elements = self.list_box.get_children()
+                if not focusable_elements:
+                    return False
 
-                    if keyval == Gdk.KEY_Down:
-                        current = self.list_box.get_selected_row()
-                        if current:
-                            index = current.get_index()
-                            next_row = self.list_box.get_row_at_index(index + 1)
-                            if next_row:
-                                self.list_box.select_row(next_row)
-                        else:
-                            first_row = self.list_box.get_row_at_index(0)
-                            if first_row:
-                                self.list_box.select_row(first_row)
-                    elif keyval == Gdk.KEY_Up:
-                        current = self.list_box.get_selected_row()
-                        if current:
-                            index = current.get_index()
-                            if index > 0:
-                                prev_row = self.list_box.get_row_at_index(index - 1)
-                                if prev_row:
-                                    self.list_box.select_row(prev_row)
-
-                    if keyval in [Gdk.KEY_Up, Gdk.KEY_Down]:
-                        return True
+                current_focus = self.window.get_focus()
+                current_index = (
+                    focusable_elements.index(current_focus)
+                    if current_focus in focusable_elements
+                    else -1
+                )
 
-                    return False
-                return True
+                target_index = current_index
+                if keyval == Gdk.KEY_Down:
+                    target_index = 0 if current_index == -1 else current_index + 1
+                elif keyval == Gdk.KEY_Up:
+                    target_index = (
+                        len(focusable_elements) - 1
+                        if current_index == -1
+                        else current_index - 1
+                    )
+                elif keyval == Gdk.KEY_Page_Down:
+                    target_index = (
+                        0
+                        if current_index == -1
+                        else min(current_index + 5, len(focusable_elements) - 1)
+                    )
+                elif keyval == Gdk.KEY_Page_Up:
+                    target_index = (
+                        len(focusable_elements) - 1
+                        if current_index == -1
+                        else max(current_index - 5, 0)
+                    )
+
+                if 0 <= target_index < len(focusable_elements):
+                    row = focusable_elements[target_index]
+                    self.list_box.select_row(row)
+                    row.grab_focus()
+                    allocation = row.get_allocation()
+                    adj = self.scrolled_window.get_vadjustment()
+                    if adj:
+                        adj.set_value(
+                            min(allocation.y, adj.get_upper() - adj.get_page_size())
+                        )
+                    return True
+
+                return False
 
         selected_row = self.list_box.get_selected_row()
 
+        if keyval == Gdk.KEY_Return:
+            if selected_row:
+                self.on_row_activated(self.list_box, shift and not ENTER_TO_PASTE)
+            elif self.list_box.get_children():
+                first_row = self.list_box.get_row_at_index(0)
+                if first_row:
+                    self.list_box.select_row(first_row)
+                    first_row.grab_focus()
+                    self.on_row_activated(self.list_box)
+            else:
+                self.search_entry.grab_focus()
+            return True
+
         # Navigation Aliases
         if keyval == Gdk.KEY_k:
-            return self.list_box.emit(
-                "move-cursor", Gtk.MovementStep.DISPLAY_LINES, -1, False
-            )
+            return self.list_box.emit("move-cursor", Gtk.MovementStep.DISPLAY_LINES, -1)
         if keyval == Gdk.KEY_j:
-            return self.list_box.emit(
-                "move-cursor", Gtk.MovementStep.DISPLAY_LINES, 1, False
-            )
+            return self.list_box.emit("move-cursor", Gtk.MovementStep.DISPLAY_LINES, 1)
 
         # Actions
-        if keyval == Gdk.KEY_slash or keyval == Gdk.KEY_f:
+        if (
+            keyval == Gdk.KEY_slash
+            or keyval == Gdk.KEY_f
+            and not self.search_entry.has_focus()
+        ):
             self.search_entry.grab_focus()
             self.search_entry.select_region(0, -1)
             return True
@@ -1128,19 +1154,12 @@ def on_key_press(self, widget, event):
             self.update_zoom()
             return True
 
-        # Enter/Activation (let row-activated signal handle)
-        if keyval == Gdk.KEY_Return or keyval == Gdk.KEY_KP_Enter:
-            if selected_row:
-                return False
-            else:
-                return True
-
         return False
 
-    def on_row_activated(self, list_box, row):
+    def on_row_activated(self, row, with_paste_simulation=False):
         """Handles double-click or Enter on a list row."""
         log.debug(f"Row activated: original_index={getattr(row, 'item_index', 'N/A')}")
-        self.copy_selected_item_to_clipboard()
+        self.copy_selected_item_to_clipboard(with_paste_simulation)
 
     def on_search_changed(self, entry):
         """Handles changes in the search entry, debounced."""
diff --git a/clipse_gui/data_manager.py b/clipse_gui/data_manager.py
@@ -158,7 +158,7 @@ def check_for_changes():
                     changed = True
 
                 if changed:
-                    log.info(
+                    log.debug(
                         f"History file change detected ({self.file_path}). Reloading..."
                     )
                     self._last_mtime = current_mtime
diff --git a/clipse_gui/ui_components.py b/clipse_gui/ui_components.py
@@ -150,6 +150,7 @@ def show_help_window(parent_window, close_cb):
         ("Home", "Go to Top"),
         ("End", "Go to Bottom (of loaded items)"),
         ("Enter", "Copy selected item to clipboard"),
+        ("Shift + Enter", "Copy & Paste selected item in current app"),
         ("Space", "Show full item preview"),
         ("p", "Toggle pin status for selected item"),
         ("x / Del", "Delete selected item"),
diff --git a/clipse_gui/utils.py b/clipse_gui/utils.py
@@ -36,3 +36,120 @@ def format_date(date_str):
     except Exception as e:
         print(f"Date formatting error for '{date_str}': {e}")
         return date_str  # Return original string if format fails
+
+
+def fuzzy_search(
+    items,
+    search_term,
+    value_key="value",
+    path_key="filePath",
+    pinned_key="pinned",
+    show_only_pinned=False,
+):
+    """
+    Performs a fuzzy search on a list of dictionary items.
+
+    Args:
+        items (list): List of dictionaries containing items to search
+        search_term (str): The search query string
+        value_key (str): Dictionary key for the primary text to search within items
+        path_key (str): Dictionary key for secondary text to search (like file paths)
+        pinned_key (str): Dictionary key for pinned status
+        show_only_pinned (bool): Whether to show only pinned items
+
+    Returns:
+        list: Filtered items as dicts with format {"original_index": index, "item": item, "match_quality": score}
+    """
+    filtered_items = []
+    search_term_lower = search_term.lower() if search_term else ""
+
+    if not search_term_lower or (show_only_pinned and not search_term_lower):
+        for index, item in enumerate(items):
+            is_pinned = item.get(pinned_key, False)
+            if show_only_pinned and not is_pinned:
+                continue
+            filtered_items.append({"original_index": index, "item": item})
+    else:
+        search_tokens = search_term_lower.split()
+
+        for index, item in enumerate(items):
+            is_pinned = item.get(pinned_key, False)
+            if show_only_pinned and not is_pinned:
+                continue
+
+            item_value = item.get(value_key, "").lower()
+            file_path = item.get(path_key, "").lower()
+
+            # Simple token matching
+            all_tokens_match = True
+            match_quality = 0
+
+            for token in search_tokens:
+                # Perfect match gets highest score
+                if token in item_value or token in file_path:
+                    match_quality += 100
+                    continue
+
+                # Check for partial matches (beginning of words)
+                words_in_value = item_value.split()
+                words_in_path = file_path.split() if file_path else []
+
+                partial_match = False
+                for word in words_in_value + words_in_path:
+                    if word.startswith(token):
+                        match_quality += 75
+                        partial_match = True
+                        break
+                    elif token.startswith(word) and len(word) >= 3:
+                        match_quality += 60
+                        partial_match = True
+                        break
+
+                # Check for close matches (levenshtein-like approach)
+                if not partial_match:
+                    # Simple character-level similarity
+                    best_similarity = 0
+                    for word in words_in_value + words_in_path:
+                        if len(word) > 2:  # Only consider meaningful words
+                            # Calculate similarity by checking character overlap
+                            similarity = _calculate_similarity(word, token)
+                            best_similarity = max(best_similarity, similarity)
+
+                    if best_similarity > 0.7:  # 70% similarity threshold
+                        match_quality += int(best_similarity * 50)
+                        partial_match = True
+
+                # If this token doesn't match at all, item doesn't match search
+                if not partial_match:
+                    all_tokens_match = False
+                    break
+
+            if all_tokens_match and match_quality > 0:
+                filtered_items.append(
+                    {
+                        "original_index": index,
+                        "item": item,
+                        "match_quality": match_quality,
+                    }
+                )
+
+        # Sort results by match quality
+        filtered_items.sort(key=lambda x: x.get("match_quality", 0), reverse=True)
+
+    return filtered_items
+
+
+def _calculate_similarity(str1, str2):
+    """Calculate a simple character-based similarity between two strings."""
+    set1, set2 = set(str1), set(str2)
+    intersection = set1.intersection(set2)
+    union = set1.union(set2)
+    if not union:
+        return 0.0
+    basic_score = len(intersection) / len(union)
+    len_ratio = (
+        min(len(str1), len(str2)) / max(len(str1), len(str2))
+        if max(len(str1), len(str2)) > 0
+        else 0
+    )
+    return (basic_score * 0.7) + (len_ratio * 0.3)

Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,7 @@ def check_for_changes():`
`158`	`158`	`changed = True`
`159`	`159`
`160`	`160`	`if changed:`
`161`		`- log.info(`
	`161`	`+ log.debug(`
`162`	`162`	`f"History file change detected ({self.file_path}). Reloading..."`
`163`	`163`	`)`
`164`	`164`	`self._last_mtime = current_mtime`