pomera-ai-commander 0.1.0

package/tools/diff_viewer.py

@@ -0,0 +1,1072 @@
+"""
+Diff Viewer Tool Module
+
+This module provides a comprehensive text comparison tool with multiple diff algorithms
+and preprocessing options. It supports side-by-side comparison with synchronized scrolling
+and word-level highlighting of differences.
+
+Features:
+- Multiple comparison modes (ignore case, match case, ignore whitespace)
+- Side-by-side text comparison with synchronized scrolling
+- Word-level difference highlighting
+- Tab-based interface for multiple comparisons
+- Integration with optimized text widgets when available
+
+Author: Promera AI Commander
+"""
+
+import tkinter as tk
+from tkinter import ttk
+import re
+import platform
+import logging
+import subprocess
+import os
+import sys
+from typing import Dict, Any, List, Optional
+
+# Import optimized components when available
+try:
+    from core.efficient_line_numbers import OptimizedTextWithLineNumbers
+    EFFICIENT_LINE_NUMBERS_AVAILABLE = True
+except ImportError:
+    EFFICIENT_LINE_NUMBERS_AVAILABLE = False
+
+try:
+    from core.memory_efficient_text_widget import MemoryEfficientTextWidget
+    MEMORY_EFFICIENT_TEXT_AVAILABLE = True
+except ImportError:
+    MEMORY_EFFICIENT_TEXT_AVAILABLE = False
+
+
+class TextWithLineNumbers(tk.Frame):
+    """Fallback implementation of TextWithLineNumbers when optimized components are not available."""
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.text = tk.Text(self, wrap=tk.WORD, height=15, width=50, undo=True)
+        self.linenumbers = tk.Canvas(self, width=40, bg='#f0f0f0', highlightthickness=0)
+        
+        self.linenumbers.pack(side=tk.LEFT, fill=tk.Y)
+        self.text.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)
+
+        # Basic event bindings
+        self.text.bind("<<Modified>>", self._on_text_modified)
+        self.text.bind("<Configure>", self._on_text_modified)
+        self._on_text_modified()
+
+    def _on_text_modified(self, event=None):
+        """Update line numbers when text is modified."""
+        self.linenumbers.delete("all")
+        line_info_cache = []
+        i = self.text.index("@0,0")
+        while True:
+            dline = self.text.dlineinfo(i)
+            if dline is None: 
+                break
+            line_info_cache.append((i, dline[1]))
+            i = self.text.index("%s+1line" % i)
+        
+        for i, y in line_info_cache:
+            linenum = str(i).split(".")[0]
+            self.linenumbers.create_text(20, y, anchor="n", text=linenum, fill="gray")
+        
+        if event and hasattr(event.widget, 'edit_modified') and event.widget.edit_modified():
+            event.widget.edit_modified(False)
+
+
+class DiffViewerWidget:
+    """
+    A comprehensive diff viewer widget that provides side-by-side text comparison
+    with multiple comparison algorithms and preprocessing options.
+    """
+    
+    def __init__(self, parent, tab_count=7, logger=None, parent_callback=None, dialog_manager=None):
+        """
+        Initialize the diff viewer widget.
+        
+        Args:
+            parent: Parent tkinter widget
+            tab_count: Number of tabs to create (default: 7)
+            logger: Logger instance for debugging
+            parent_callback: Callback function to notify parent of changes
+            dialog_manager: DialogManager instance for consistent dialog handling
+        """
+        self.parent = parent
+        self.tab_count = tab_count
+        self.logger = logger or logging.getLogger(__name__)
+        self.parent_callback = parent_callback
+        self.dialog_manager = dialog_manager
+        
+        # Settings for diff comparison
+        self.settings = {
+            "option": "ignore_case"  # Default comparison mode
+        }
+        
+        # Create the main frame
+        self.diff_frame = ttk.Frame(parent, padding="10")
+        self.diff_frame.grid_columnconfigure(0, weight=1)
+        self.diff_frame.grid_columnconfigure(1, weight=1)
+        self.diff_frame.grid_rowconfigure(1, weight=1)
+        
+        # Statistics bars
+        self.input_stats_bar = None
+        self.output_stats_bar = None
+        
+        # Initialize UI components
+        self._create_ui()
+        self._setup_event_bindings()
+    
+    def _show_error(self, title, message):
+        """Show error dialog using DialogManager if available, otherwise use messagebox."""
+        if self.dialog_manager:
+            return self.dialog_manager.show_error(title, message, parent=self.parent)
+        else:
+            try:
+                from tkinter import messagebox
+                messagebox.showerror(title, message, parent=self.parent)
+                return True
+            except:
+                return False
+    
+    def _show_warning(self, title, message, category="warning"):
+        """Show warning dialog using DialogManager if available, otherwise use messagebox."""
+        if self.dialog_manager:
+            return self.dialog_manager.show_warning(title, message, category, parent=self.parent)
+        else:
+            try:
+                import tkinter.messagebox as messagebox
+                messagebox.showwarning(title, message, parent=self.parent)
+                return True
+            except:
+                return False
+        
+    def _create_ui(self):
+        """Create the user interface components."""
+        self._create_title_rows()
+        self._create_notebooks()
+        self._create_tabs()
+        self._create_statistics_bars()
+        self._configure_text_tags()
+        
+    def _create_title_rows(self):
+        """Create the title rows with buttons and controls."""
+        # Input title row
+        input_title_row = ttk.Frame(self.diff_frame)
+        input_title_row.grid(row=0, column=0, sticky="ew", padx=(0, 5))
+        
+        # Input label and buttons
+        input_controls = ttk.Frame(input_title_row)
+        input_controls.pack(side=tk.TOP, fill=tk.X)
+        ttk.Label(input_controls, text="Input", font=("Helvetica", 12, "bold")).pack(side=tk.LEFT)
+        
+        # Load from file button
+        load_file_btn = ttk.Button(input_controls, text="📁", command=self.load_file_to_input, width=3)
+        load_file_btn.pack(side=tk.LEFT, padx=(10, 0))
+        
+        # Erase button
+        ttk.Button(input_controls, text="⌫", command=self.clear_all_input_tabs, width=3).pack(side=tk.LEFT, padx=(5, 0))
+        
+        # Input line filter
+        input_filter_frame = ttk.Frame(input_title_row)
+        input_filter_frame.pack(side=tk.TOP, fill=tk.X, pady=(5, 0))
+        ttk.Label(input_filter_frame, text="Filter:").pack(side=tk.LEFT)
+        self.input_filter_var = tk.StringVar()
+        self.input_filter_entry = ttk.Entry(input_filter_frame, textvariable=self.input_filter_var, width=25)
+        self.input_filter_entry.pack(side=tk.LEFT, padx=(5, 5), fill=tk.X, expand=True)
+        self.input_filter_var.trace_add("write", self._on_input_filter_changed)
+        ttk.Button(input_filter_frame, text="✕", command=self._clear_input_filter, width=3).pack(side=tk.LEFT)
+        
+        # Output title row
+        output_title_row = ttk.Frame(self.diff_frame)
+        output_title_row.grid(row=0, column=1, sticky="ew", padx=(5, 0))
+        
+        # Output label and buttons
+        output_controls = ttk.Frame(output_title_row)
+        output_controls.pack(side=tk.TOP, fill=tk.X)
+        ttk.Label(output_controls, text="Output", font=("Helvetica", 12, "bold")).pack(side=tk.LEFT)
+        
+        # Send to Input dropdown
+        self.send_to_input_var = tk.StringVar(value="Send to Input")
+        send_to_input_menu = ttk.Menubutton(output_controls, textvariable=self.send_to_input_var, direction="below")
+        send_to_input_menu.pack(side=tk.LEFT, padx=(10, 6))
+        
+        # Create the dropdown menu
+        dropdown_menu = tk.Menu(send_to_input_menu, tearoff=0)
+        send_to_input_menu.config(menu=dropdown_menu)
+        for i in range(self.tab_count):
+            dropdown_menu.add_command(label=f"Tab {i+1}", command=lambda tab=i: self.copy_to_specific_input_tab(tab))
+        
+        # Copy to clipboard button
+        ttk.Button(output_controls, text="⎘", command=self.copy_to_clipboard, width=3).pack(side=tk.LEFT, padx=(0, 6))
+        
+        # Erase button
+        ttk.Button(output_controls, text="⌫", command=self.clear_all_output_tabs, width=3).pack(side=tk.LEFT)
+        
+        # Output line filter
+        output_filter_frame = ttk.Frame(output_title_row)
+        output_filter_frame.pack(side=tk.TOP, fill=tk.X, pady=(5, 0))
+        ttk.Label(output_filter_frame, text="Filter:").pack(side=tk.LEFT)
+        self.output_filter_var = tk.StringVar()
+        self.output_filter_entry = ttk.Entry(output_filter_frame, textvariable=self.output_filter_var, width=25)
+        self.output_filter_entry.pack(side=tk.LEFT, padx=(5, 5), fill=tk.X, expand=True)
+        self.output_filter_var.trace_add("write", self._on_output_filter_changed)
+        ttk.Button(output_filter_frame, text="✕", command=self._clear_output_filter, width=3).pack(side=tk.LEFT)
+        
+        # Store original content for filtering
+        self.input_original_content = {}
+        self.output_original_content = {}
+
+    def _create_notebooks(self):
+        """Create the notebook widgets for input and output tabs."""
+        self.input_notebook = ttk.Notebook(self.diff_frame)
+        self.input_notebook.grid(row=1, column=0, sticky="nsew", padx=(0, 5))
+        
+        self.output_notebook = ttk.Notebook(self.diff_frame)
+        self.output_notebook.grid(row=1, column=1, sticky="nsew", padx=(5, 0))
+    
+    def _create_statistics_bars(self):
+        """Create statistics bars below the text areas."""
+        # Input statistics bar
+        self.input_stats_bar = ttk.Label(
+            self.diff_frame, 
+            text="Bytes: 0 | Word: 0 | Sentence: 0 | Line: 0 | Tokens: 0",
+            relief=tk.SUNKEN,
+            anchor=tk.W,
+            padding=(5, 2)
+        )
+        self.input_stats_bar.grid(row=2, column=0, sticky="ew", padx=(0, 5), pady=(5, 0))
+        
+        # Output statistics bar
+        self.output_stats_bar = ttk.Label(
+            self.diff_frame,
+            text="Bytes: 0 | Word: 0 | Sentence: 0 | Line: 0 | Tokens: 0",
+            relief=tk.SUNKEN,
+            anchor=tk.W,
+            padding=(5, 2)
+        )
+        self.output_stats_bar.grid(row=2, column=1, sticky="ew", padx=(5, 0), pady=(5, 0))
+
+    def _create_tabs(self):
+        """Create the text tabs for input and output."""
+        self.input_tabs = []
+        self.output_tabs = []
+        
+        for i in range(self.tab_count):
+            # Create input tab
+            if EFFICIENT_LINE_NUMBERS_AVAILABLE:
+                input_tab = OptimizedTextWithLineNumbers(self.input_notebook)
+            elif MEMORY_EFFICIENT_TEXT_AVAILABLE:
+                input_tab = MemoryEfficientTextWidget(self.input_notebook)
+            else:
+                input_tab = TextWithLineNumbers(self.input_notebook)
+            
+            input_tab.text.bind("<<Modified>>", self._on_tab_content_changed)
+            input_tab.text.bind("<KeyRelease>", self._on_tab_content_changed)
+            input_tab.text.bind("<Button-1>", self._on_tab_content_changed)
+            self.input_tabs.append(input_tab)
+            self.input_notebook.add(input_tab, text=f"{i+1}:")
+            
+            # Create output tab
+            if EFFICIENT_LINE_NUMBERS_AVAILABLE:
+                output_tab = OptimizedTextWithLineNumbers(self.output_notebook)
+            elif MEMORY_EFFICIENT_TEXT_AVAILABLE:
+                output_tab = MemoryEfficientTextWidget(self.output_notebook)
+            else:
+                output_tab = TextWithLineNumbers(self.output_notebook)
+            
+            output_tab.text.bind("<<Modified>>", self._on_tab_content_changed)
+            output_tab.text.bind("<KeyRelease>", self._on_tab_content_changed)
+            output_tab.text.bind("<Button-1>", self._on_tab_content_changed)
+            self.output_tabs.append(output_tab)
+            self.output_notebook.add(output_tab, text=f"{i+1}:")
+
+    def _configure_text_tags(self):
+        """Configure text tags for highlighting differences."""
+        for tab_list in [self.input_tabs, self.output_tabs]:
+            for tab in tab_list:
+                widget = tab.text
+                widget.config(state="normal")
+                widget.tag_configure("addition", background="#e6ffed")
+                widget.tag_configure("deletion", background="#ffebe9")
+                widget.tag_configure("modification", background="#e6f7ff")
+                widget.tag_configure("inline_add", background="#a7f0ba")
+                widget.tag_configure("inline_del", background="#ffc9c9")
+
+    def _setup_event_bindings(self):
+        """Set up event bindings for synchronized scrolling."""
+        self.input_notebook.bind("<<NotebookTabChanged>>", self._on_tab_changed)
+        self.output_notebook.bind("<<NotebookTabChanged>>", self._on_tab_changed)
+        self._setup_sync()
+    
+    def _on_tab_changed(self, event=None):
+        """Handle tab change events."""
+        # Clear filters when switching tabs
+        if hasattr(self, 'input_filter_var'):
+            self.input_filter_var.set("")
+        if hasattr(self, 'output_filter_var'):
+            self.output_filter_var.set("")
+        
+        self._setup_sync(event)
+        self.update_statistics()
+
+    def _setup_sync(self, event=None):
+        """Configure scroll and mousewheel syncing for the active tabs."""
+        try:
+            active_input_tab = self.input_tabs[self.input_notebook.index("current")]
+            active_output_tab = self.output_tabs[self.output_notebook.index("current")]
+        except (tk.TclError, IndexError):
+            return
+
+        # Configure scrollbar syncing
+        if hasattr(active_input_tab.text, 'vbar'):
+            active_input_tab.text.vbar.config(command=self._sync_scroll)
+        if hasattr(active_output_tab.text, 'vbar'):
+            active_output_tab.text.vbar.config(command=self._sync_scroll)
+
+        # Configure mouse wheel syncing
+        for tab in [active_input_tab, active_output_tab]:
+            tab.text.bind("<MouseWheel>", self._on_mousewheel)
+            tab.text.bind("<Button-4>", self._on_mousewheel)
+            tab.text.bind("<Button-5>", self._on_mousewheel)
+
+    def _sync_scroll(self, *args):
+        """Sync both text widgets when one's scrollbar is used."""
+        try:
+            active_input_tab = self.input_tabs[self.input_notebook.index("current")]
+            active_output_tab = self.output_tabs[self.output_notebook.index("current")]
+            
+            active_input_tab.text.yview(*args)
+            active_output_tab.text.yview(*args)
+            
+            # Update line numbers if available
+            if hasattr(active_input_tab, '_on_text_modified'):
+                active_input_tab._on_text_modified()
+            if hasattr(active_output_tab, '_on_text_modified'):
+                active_output_tab._on_text_modified()
+        except (tk.TclError, IndexError):
+            pass
+
+    def _on_mousewheel(self, event):
+        """Handle mouse wheel scrolling over either text widget."""
+        if platform.system() == "Windows":
+            delta = int(-1*(event.delta/120))
+        elif platform.system() == "Darwin":
+            delta = int(-1 * event.delta)
+        else:
+            delta = -1 if event.num == 4 else 1
+        
+        try:
+            active_input_tab = self.input_tabs[self.input_notebook.index("current")]
+            active_output_tab = self.output_tabs[self.output_notebook.index("current")]
+            
+            active_input_tab.text.yview_scroll(delta, "units")
+            active_output_tab.text.yview_scroll(delta, "units")
+            
+            # Update line numbers if available
+            if hasattr(active_input_tab, '_on_text_modified'):
+                active_input_tab._on_text_modified()
+            if hasattr(active_output_tab, '_on_text_modified'):
+                active_output_tab._on_text_modified()
+        except (tk.TclError, IndexError):
+            pass
+        
+        return "break"
+
+    def _on_tab_content_changed(self, event=None):
+        """Handle tab content changes."""
+        # Update tab labels when content changes
+        self.update_tab_labels()
+        
+        # Update statistics
+        self.update_statistics()
+        
+        # This can be overridden by the parent application
+        if hasattr(self, 'parent_callback') and self.parent_callback:
+            self.parent_callback()
+
+    def get_frame(self):
+        """Return the main frame widget."""
+        return self.diff_frame
+
+    def show(self):
+        """Show the diff viewer."""
+        self.diff_frame.grid(row=0, column=0, sticky="nsew", pady=5)
+
+    def hide(self):
+        """Hide the diff viewer."""
+        self.diff_frame.grid_remove()
+
+    def load_content(self, input_tabs_content, output_tabs_content):
+        """
+        Load content into the diff viewer tabs.
+        
+        Args:
+            input_tabs_content: List of strings for input tabs
+            output_tabs_content: List of strings for output tabs
+        """
+        self.logger.info("Loading content into Diff Viewer.")
+        
+        for i in range(min(len(input_tabs_content), self.tab_count)):
+            self.input_tabs[i].text.delete("1.0", tk.END)
+            self.input_tabs[i].text.insert("1.0", input_tabs_content[i])
+            
+        for i in range(min(len(output_tabs_content), self.tab_count)):
+            self.output_tabs[i].text.delete("1.0", tk.END)
+            self.output_tabs[i].text.insert("1.0", output_tabs_content[i])
+        
+        # Update tab labels after loading content
+        self.update_tab_labels()
+
+    def sync_content_back(self):
+        """
+        Get content from diff viewer tabs.
+        
+        Returns:
+            tuple: (input_contents, output_contents) as lists of strings
+        """
+        self.logger.info("Syncing Diff Viewer content back.")
+        
+        input_contents = []
+        output_contents = []
+        
+        for i in range(self.tab_count):
+            input_content = self.input_tabs[i].text.get("1.0", tk.END)
+            # Remove trailing newline that tkinter adds
+            if input_content.endswith('\n'):
+                input_content = input_content[:-1]
+            input_contents.append(input_content)
+            
+            output_content = self.output_tabs[i].text.get("1.0", tk.END)
+            # Remove trailing newline that tkinter adds
+            if output_content.endswith('\n'):
+                output_content = output_content[:-1]
+            output_contents.append(output_content)
+        
+        # Debug logging
+        non_empty_inputs = sum(1 for content in input_contents if content.strip())
+        non_empty_outputs = sum(1 for content in output_contents if content.strip())
+        self.logger.info(f"Syncing back {non_empty_inputs} non-empty input tabs, {non_empty_outputs} non-empty output tabs")
+        
+        return input_contents, output_contents
+
+    def _preprocess_for_diff(self, text, option):
+        """
+        Preprocess text into line dicts according to diff option.
+        
+        Args:
+            text: Input text to preprocess
+            option: Comparison option ('ignore_case', 'match_case', 'ignore_whitespace')
+            
+        Returns:
+            List of dicts with 'raw' and 'cmp' keys
+        """
+        lines = text.splitlines()
+        processed = []
+        for line in lines:
+            cmp_line = line
+            if option == "ignore_case": 
+                cmp_line = cmp_line.lower()
+            elif option == "ignore_whitespace": 
+                cmp_line = re.sub(r"\s+", " ", cmp_line).strip()
+            processed.append({"raw": line, "cmp": cmp_line})
+        return processed
+
+    def run_comparison(self, option=None):
+        """
+        Compare the active tabs and display the diff.
+        
+        Args:
+            option: Comparison option ('ignore_case', 'match_case', 'ignore_whitespace')
+                   If None, uses the current setting
+        """
+        self.logger.info("Running Diff Viewer comparison.")
+        
+        if option is not None:
+            self.settings["option"] = option
+        
+        current_option = self.settings.get("option", "ignore_case")
+        
+        try:
+            active_input_idx = self.input_notebook.index("current")
+            active_output_idx = self.output_notebook.index("current")
+            
+            input_widget = self.input_tabs[active_input_idx].text
+            output_widget = self.output_tabs[active_output_idx].text
+            
+            # Get text content (remove trailing newline that tkinter adds)
+            input_text = input_widget.get("1.0", tk.END)
+            if input_text.endswith('\n'):
+                input_text = input_text[:-1]
+            
+            output_text = output_widget.get("1.0", tk.END)
+            if output_text.endswith('\n'):
+                output_text = output_text[:-1]
+                
+        except (tk.TclError, IndexError):
+            self.logger.error("Could not get active tabs for comparison")
+            return
+        
+        # Clear filters before comparison
+        if hasattr(self, 'input_filter_var'):
+            self.input_filter_var.set("")
+        if hasattr(self, 'output_filter_var'):
+            self.output_filter_var.set("")
+        
+        # Clear stored original content
+        if active_input_idx in self.input_original_content:
+            del self.input_original_content[active_input_idx]
+        if active_output_idx in self.output_original_content:
+            del self.output_original_content[active_output_idx]
+
+        # Clear existing content
+        input_widget.delete("1.0", tk.END)
+        output_widget.delete("1.0", tk.END)
+
+        # Handle empty texts
+        if not input_text.strip() and not output_text.strip(): 
+            return
+        elif not input_text.strip():
+            for line in output_text.splitlines():
+                input_widget.insert(tk.END, '\n')
+                output_widget.insert(tk.END, line + '\n', 'addition')
+            return
+        elif not output_text.strip():
+            for line in input_text.splitlines():
+                input_widget.insert(tk.END, line + '\n', 'deletion')
+                output_widget.insert(tk.END, '\n')
+            return
+
+        # Preprocess texts for comparison
+        left_lines = self._preprocess_for_diff(input_text, current_option)
+        right_lines = self._preprocess_for_diff(output_text, current_option)
+        left_cmp = [l["cmp"] for l in left_lines]
+        right_cmp = [r["cmp"] for r in right_lines]
+        
+        try:
+            import difflib
+            matcher = difflib.SequenceMatcher(None, left_cmp, right_cmp, autojunk=False)
+            
+            for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+                if tag == 'equal':
+                    for i in range(i1, i2):
+                        input_widget.insert(tk.END, left_lines[i]["raw"] + '\n')
+                        output_widget.insert(tk.END, right_lines[j1 + (i - i1)]["raw"] + '\n')
+                        
+                elif tag == 'delete':
+                    for i in range(i1, i2):
+                        input_widget.insert(tk.END, left_lines[i]["raw"] + '\n', 'deletion')
+                        output_widget.insert(tk.END, '\n')
+                        
+                elif tag == 'insert':
+                    for j in range(j1, j2):
+                        input_widget.insert(tk.END, '\n')
+                        output_widget.insert(tk.END, right_lines[j]["raw"] + '\n', 'addition')
+                        
+                elif tag == 'replace':
+                    input_block = [l["raw"] for l in left_lines[i1:i2]]
+                    output_block = [r["raw"] for r in right_lines[j1:j2]]
+                    
+                    # Pad blocks to same length
+                    while len(input_block) < len(output_block): 
+                        input_block.append("")
+                    while len(output_block) < len(input_block): 
+                        output_block.append("")
+                    
+                    for line1, line2 in zip(input_block, output_block):
+                        if line1 and line2: 
+                            self._highlight_word_diffs(input_widget, [line1], output_widget, [line2])
+                        elif line1:
+                            input_widget.insert(tk.END, line1 + '\n', 'deletion')
+                            output_widget.insert(tk.END, '\n')
+                        elif line2:
+                            input_widget.insert(tk.END, '\n')
+                            output_widget.insert(tk.END, line2 + '\n', 'addition')
+                            
+        except Exception as e:
+            self.logger.error(f"Error in diff computation: {e}")
+            input_widget.insert(tk.END, input_text)
+            output_widget.insert(tk.END, output_text)
+        
+        # Reset scroll position
+        input_widget.yview_moveto(0)
+        output_widget.yview_moveto(0)
+        self._setup_sync()
+        
+        # Update tab labels after comparison
+        self.update_tab_labels()
+
+    def _highlight_word_diffs(self, w1, lines1, w2, lines2):
+        """
+        Highlight word-level differences within a 'replace' block.
+        
+        Args:
+            w1: First text widget
+            lines1: Lines for first widget
+            w2: Second text widget  
+            lines2: Lines for second widget
+        """
+        for line1, line2 in zip(lines1, lines2):
+            w1.insert(tk.END, line1 + '\n', 'modification')
+            w2.insert(tk.END, line2 + '\n', 'modification')
+
+            line_start1 = w1.index(f"{w1.index(tk.INSERT)} -1 lines linestart")
+            line_start2 = w2.index(f"{w2.index(tk.INSERT)} -1 lines linestart")
+
+            words1 = re.split(r'(\s+)', line1)
+            words2 = re.split(r'(\s+)', line2)
+            
+            try:
+                import difflib
+                matcher = difflib.SequenceMatcher(None, words1, words2)
+
+                for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+                    if tag == 'delete' or tag == 'replace':
+                        start_char1 = len("".join(words1[:i1]))
+                        end_char1 = len("".join(words1[:i2]))
+                        w1.tag_add('inline_del', f"{line_start1}+{start_char1}c", f"{line_start1}+{end_char1}c")
+                    if tag == 'insert' or tag == 'replace':
+                        start_char2 = len("".join(words2[:j1]))
+                        end_char2 = len("".join(words2[:j2]))
+                        w2.tag_add('inline_add', f"{line_start2}+{start_char2}c", f"{line_start2}+{end_char2}c")
+            except Exception as e:
+                self.logger.error(f"Error in word-level diff highlighting: {e}")
+
+    def clear_all_input_tabs(self):
+        """Clear all input tabs."""
+        for tab in self.input_tabs:
+            tab.text.delete("1.0", tk.END)
+        # Update tab labels after clearing
+        self.update_tab_labels()
+
+    def clear_all_output_tabs(self):
+        """Clear all output tabs."""
+        for tab in self.output_tabs:
+            tab.text.delete("1.0", tk.END)
+        # Update tab labels after clearing
+        self.update_tab_labels()
+
+    def copy_to_clipboard(self):
+        """Copy active output tab content to clipboard."""
+        try:
+            active_output_tab = self.output_tabs[self.output_notebook.index("current")]
+            content = active_output_tab.text.get("1.0", tk.END)
+            self.parent.clipboard_clear()
+            self.parent.clipboard_append(content)
+        except (tk.TclError, IndexError):
+            pass
+
+    def copy_to_specific_input_tab(self, tab_index):
+        """
+        Copy active output tab content to a specific input tab.
+        
+        Args:
+            tab_index: Index of the target input tab
+        """
+        try:
+            active_output_tab = self.output_tabs[self.output_notebook.index("current")]
+            content = active_output_tab.text.get("1.0", tk.END)
+            
+            if 0 <= tab_index < len(self.input_tabs):
+                self.input_tabs[tab_index].text.delete("1.0", tk.END)
+                self.input_tabs[tab_index].text.insert("1.0", content)
+        except (tk.TclError, IndexError):
+            pass
+
+    def load_file_to_input(self):
+        """Load file content to the active input tab."""
+        try:
+            from tkinter import filedialog
+            file_path = filedialog.askopenfilename(
+                title="Select file to load",
+                filetypes=[
+                    ("Text files", "*.txt"),
+                    ("All files", "*.*")
+                ],
+                parent=self.parent
+            )
+            
+            if file_path:
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+                
+                # Load into active input tab
+                active_input_tab = self.input_tabs[self.input_notebook.index("current")]
+                active_input_tab.text.delete("1.0", tk.END)
+                active_input_tab.text.insert("1.0", content)
+                
+                self.logger.info(f"Loaded file: {file_path}")
+        except Exception as e:
+            self.logger.error(f"Error loading file: {e}")
+            self._show_error("Error", f"Could not load file: {str(e)}")
+
+    def update_tab_labels(self):
+        """Update tab labels based on content."""
+        try:
+            # Update input tab labels
+            for i, tab in enumerate(self.input_tabs):
+                content = tab.text.get("1.0", tk.END).strip()
+                if content:
+                    # Get first few words for the label
+                    words = content.split()[:3]
+                    label = " ".join(words)
+                    if len(label) > 20:
+                        label = label[:17] + "..."
+                    if len(content.split()) > 3:
+                        label += "..."
+                    self.input_notebook.tab(i, text=f"{i+1}: {label}")
+                else:
+                    self.input_notebook.tab(i, text=f"{i+1}:")
+            
+            # Update output tab labels
+            for i, tab in enumerate(self.output_tabs):
+                content = tab.text.get("1.0", tk.END).strip()
+                if content:
+                    # Get first few words for the label
+                    words = content.split()[:3]
+                    label = " ".join(words)
+                    if len(label) > 20:
+                        label = label[:17] + "..."
+                    if len(content.split()) > 3:
+                        label += "..."
+                    self.output_notebook.tab(i, text=f"{i+1}: {label}")
+                else:
+                    self.output_notebook.tab(i, text=f"{i+1}:")
+                    
+        except Exception as e:
+            self.logger.error(f"Error updating tab labels: {e}")
+
+    def _on_input_filter_changed(self, *args):
+        """Handle input filter text changes."""
+        self._apply_input_filter()
+    
+    def _on_output_filter_changed(self, *args):
+        """Handle output filter text changes."""
+        self._apply_output_filter()
+    
+    def _clear_input_filter(self):
+        """Clear the input filter."""
+        self.input_filter_var.set("")
+    
+    def _clear_output_filter(self):
+        """Clear the output filter."""
+        self.output_filter_var.set("")
+    
+    def _apply_input_filter(self):
+        """Apply line filter to the active input tab."""
+        try:
+            active_idx = self.input_notebook.index("current")
+            current_tab = self.input_tabs[active_idx]
+            filter_text = self.input_filter_var.get().strip()
+            
+            # Store original content if not already stored
+            if active_idx not in self.input_original_content:
+                self.input_original_content[active_idx] = current_tab.text.get("1.0", tk.END)
+            
+            original_content = self.input_original_content[active_idx]
+            
+            if filter_text:
+                # Apply filter
+                lines = original_content.split('\n')
+                filtered_lines = [line for line in lines if filter_text.lower() in line.lower()]
+                filtered_content = '\n'.join(filtered_lines)
+                
+                current_tab.text.delete("1.0", tk.END)
+                current_tab.text.insert("1.0", filtered_content)
+            else:
+                # Restore original content
+                current_tab.text.delete("1.0", tk.END)
+                current_tab.text.insert("1.0", original_content)
+                # Clear stored content
+                if active_idx in self.input_original_content:
+                    del self.input_original_content[active_idx]
+            
+            # Update statistics
+            self.update_statistics()
+            
+        except Exception as e:
+            self.logger.error(f"Error applying input filter: {e}")
+    
+    def _apply_output_filter(self):
+        """Apply line filter to the active output tab."""
+        try:
+            active_idx = self.output_notebook.index("current")
+            current_tab = self.output_tabs[active_idx]
+            filter_text = self.output_filter_var.get().strip()
+            
+            # Store original content if not already stored
+            if active_idx not in self.output_original_content:
+                self.output_original_content[active_idx] = current_tab.text.get("1.0", tk.END)
+            
+            original_content = self.output_original_content[active_idx]
+            
+            if filter_text:
+                # Apply filter
+                lines = original_content.split('\n')
+                filtered_lines = [line for line in lines if filter_text.lower() in line.lower()]
+                filtered_content = '\n'.join(filtered_lines)
+                
+                current_tab.text.delete("1.0", tk.END)
+                current_tab.text.insert("1.0", filtered_content)
+            else:
+                # Restore original content
+                current_tab.text.delete("1.0", tk.END)
+                current_tab.text.insert("1.0", original_content)
+                # Clear stored content
+                if active_idx in self.output_original_content:
+                    del self.output_original_content[active_idx]
+            
+            # Update statistics
+            self.update_statistics()
+            
+        except Exception as e:
+            self.logger.error(f"Error applying output filter: {e}")
+
+    def get_settings(self):
+        """Get current diff viewer settings."""
+        return self.settings.copy()
+
+    def update_settings(self, settings):
+        """
+        Update diff viewer settings.
+        
+        Args:
+            settings: Dictionary of settings to update
+        """
+        self.settings.update(settings)
+    
+    def apply_font_to_widgets(self, font_tuple):
+        """
+        Apply font to all text widgets in the diff viewer.
+        
+        Args:
+            font_tuple: Tuple of (font_family, font_size)
+        """
+        try:
+            for tab in self.input_tabs:
+                if hasattr(tab, 'text'):
+                    tab.text.configure(font=font_tuple)
+            
+            for tab in self.output_tabs:
+                if hasattr(tab, 'text'):
+                    tab.text.configure(font=font_tuple)
+            
+            self.logger.debug(f"Applied font {font_tuple} to diff viewer text widgets")
+        except Exception as e:
+            self.logger.error(f"Error applying font to diff viewer: {e}")
+    
+    def update_statistics(self):
+        """Update statistics bars for the active tabs."""
+        try:
+            # Get active tab indices
+            active_input_idx = self.input_notebook.index("current")
+            active_output_idx = self.output_notebook.index("current")
+            
+            # Get text from active tabs
+            input_text = self.input_tabs[active_input_idx].text.get("1.0", tk.END)
+            output_text = self.output_tabs[active_output_idx].text.get("1.0", tk.END)
+            
+            # Update input statistics
+            if self.input_stats_bar:
+                self._update_stats_bar(self.input_stats_bar, input_text)
+            
+            # Update output statistics
+            if self.output_stats_bar:
+                self._update_stats_bar(self.output_stats_bar, output_text)
+                
+        except Exception as e:
+            self.logger.error(f"Error updating statistics: {e}")
+    
+    def _update_stats_bar(self, stats_bar, text):
+        """
+        Update a statistics bar with text statistics.
+        
+        Args:
+            stats_bar: The label widget to update
+            text: The text to analyze
+        """
+        try:
+            # Remove trailing newline that tkinter adds
+            if text.endswith('\n'):
+                text = text[:-1]
+            
+            # Handle empty text
+            if not text:
+                stats_bar.config(text="Bytes: 0 | Word: 0 | Sentence: 0 | Line: 0 | Tokens: 0")
+                return
+            
+            stripped_text = text.strip()
+            char_count = len(stripped_text)
+            byte_count = len(text.encode('utf-8'))
+            
+            # Count lines (more accurate)
+            line_count = text.count('\n') + 1
+            
+            # Count words
+            if char_count == 0:
+                word_count = 0
+            else:
+                words = [word for word in stripped_text.split() if word]
+                word_count = len(words)
+            
+            # Count sentences (rough approximation)
+            sentence_count = text.count('.') + text.count('!') + text.count('?')
+            if sentence_count == 0 and char_count > 0:
+                sentence_count = 1
+            
+            # Token estimation
+            token_count = max(1, round(char_count / 4)) if char_count > 0 else 0
+            
+            # Format bytes
+            if byte_count < 1024:
+                formatted_bytes = f"{byte_count}"
+            elif byte_count < 1024 * 1024:
+                formatted_bytes = f"{byte_count / 1024:.1f}K"
+            else:
+                formatted_bytes = f"{byte_count / (1024 * 1024):.1f}M"
+            
+            stats_bar.config(
+                text=f"Bytes: {formatted_bytes} | Word: {word_count} | Sentence: {sentence_count} | Line: {line_count} | Tokens: {token_count}"
+            )
+        except Exception as e:
+            self.logger.error(f"Error calculating statistics: {e}")
+
+
+class DiffViewerSettingsWidget:
+    """Settings widget for the diff viewer tool."""
+    
+    def __init__(self, parent, diff_viewer, on_setting_change=None):
+        """
+        Initialize the settings widget.
+        
+        Args:
+            parent: Parent tkinter widget
+            diff_viewer: DiffViewerWidget instance
+            on_setting_change: Callback function for setting changes
+        """
+        self.parent = parent
+        self.diff_viewer = diff_viewer
+        self.on_setting_change = on_setting_change
+        
+        # Get current settings
+        settings = diff_viewer.get_settings()
+        default_option = settings.get("option", "ignore_case")
+        
+        # Create option variable
+        self.option_var = tk.StringVar(value=default_option)
+        
+        # Create UI
+        self._create_ui()
+        
+    def _create_ui(self):
+        """Create the settings UI."""
+        ttk.Radiobutton(
+            self.parent, 
+            text="Ignore case", 
+            variable=self.option_var, 
+            value="ignore_case", 
+            command=self._on_option_change
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        ttk.Radiobutton(
+            self.parent, 
+            text="Match case", 
+            variable=self.option_var, 
+            value="match_case", 
+            command=self._on_option_change
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        ttk.Radiobutton(
+            self.parent, 
+            text="Ignore whitespace", 
+            variable=self.option_var, 
+            value="ignore_whitespace", 
+            command=self._on_option_change
+        ).pack(side=tk.LEFT, padx=(0, 16))
+        
+        ttk.Button(
+            self.parent, 
+            text="Compare Active Tabs", 
+            command=self._run_comparison
+        ).pack(side=tk.LEFT, padx=5)
+        
+        # Add separator
+        ttk.Label(self.parent, text="|").pack(side=tk.LEFT, padx=5)
+        
+        ttk.Button(
+            self.parent, 
+            text="List Comparator", 
+            command=self._launch_list_comparator
+        ).pack(side=tk.LEFT, padx=5)
+    
+    def _on_option_change(self):
+        """Handle option change."""
+        option = self.option_var.get()
+        self.diff_viewer.update_settings({"option": option})
+        
+        if self.on_setting_change:
+            self.on_setting_change("Diff Viewer", {"option": option})
+    
+    def _run_comparison(self):
+        """Run the diff comparison."""
+        option = self.option_var.get()
+        self.diff_viewer.run_comparison(option)
+    
+    def _launch_list_comparator(self):
+        """Launch the list comparator application."""
+        try:
+            # Try to use the parent app's integrated list comparator if available
+            # Check on the diff_viewer instance (not self, which is the settings widget)
+            if hasattr(self.diff_viewer, 'open_list_comparator') and callable(self.diff_viewer.open_list_comparator):
+                self.diff_viewer.logger.info("✅ Found open_list_comparator method, calling it...")
+                self.diff_viewer.open_list_comparator()
+                self.diff_viewer.logger.info("✅ List Comparator launched via parent app")
+            else:
+                # Fallback: Launch as subprocess (standalone mode)
+                import subprocess
+                import os
+                import sys
+                
+                # Get the directory where the current script is located
+                current_dir = os.path.dirname(os.path.abspath(__file__))
+                list_comparator_path = os.path.join(current_dir, "list_comparator.py")
+                
+                # Check if the list_comparator.py file exists
+                if os.path.exists(list_comparator_path):
+                    # Launch the list comparator as a separate process without console window
+                    if sys.platform.startswith('win'):
+                        # Windows - use pythonw.exe to avoid console window, or hide it
+                        try:
+                            # Try to use pythonw.exe first (no console window)
+                            pythonw_path = sys.executable.replace('python.exe', 'pythonw.exe')
+                            if os.path.exists(pythonw_path):
+                                subprocess.Popen([pythonw_path, list_comparator_path])
+                            else:
+                                # Fallback: use regular python but hide the console window
+                                startupinfo = subprocess.STARTUPINFO()
+                                startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+                                startupinfo.wShowWindow = subprocess.SW_HIDE
+                                subprocess.Popen([sys.executable, list_comparator_path], 
+                                               startupinfo=startupinfo)
+                        except:
+                            # Final fallback
+                            subprocess.Popen([sys.executable, list_comparator_path])
+                    else:
+                        # Unix/Linux/macOS
+                        subprocess.Popen([sys.executable, list_comparator_path])
+                    
+                    print("✅ List Comparator launched successfully (subprocess)")
+                else:
+                    print(f"❌ List Comparator not found at: {list_comparator_path}")
+                    # Try to show a message to the user if possible
+                    self._show_warning("List Comparator", 
+                                     f"List Comparator application not found.\n\nExpected location: {list_comparator_path}")
+                    
+        except Exception as e:
+            print(f"❌ Error launching List Comparator: {e}")
+            self._show_error("List Comparator", 
+                           f"Error launching List Comparator:\n{str(e)}")
+    
+    def get_settings(self):
+        """Get current settings."""
+        return {"option": self.option_var.get()}