pomera-ai-commander 1.1.1 → 1.2.2

package/tools/diff_viewer.py

@@ -1,1072 +1,1817 @@
-"""
-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()}
+"""
+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, filedialog, messagebox
+import difflib
+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=50, 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
+            "char_level_diff": False,  # Character-level diff mode (vs word-level)
+            "detect_moved": False,  # Detect moved lines
+            "syntax_highlight": False  # Syntax highlighting for code
+        }
+        
+        # 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
+        
+        # Diff tracking for navigation and summary
+        self.diff_positions = []  # List of (line_number, diff_type) tuples
+        self.current_diff_index = -1
+        self.diff_counts = {"additions": 0, "deletions": 0, "modifications": 0}
+        self.similarity_score = 0.0
+        self.diff_summary_bar = None
+        
+        # Regex filter mode flags
+        self.input_regex_mode = tk.BooleanVar(value=False)
+        self.output_regex_mode = tk.BooleanVar(value=False)
+        
+        # Store original source text for comparison (to avoid accumulating blank lines)
+        self.comparison_source_input = {}  # {tab_idx: original_text}
+        self.comparison_source_output = {}  # {tab_idx: original_text}
+        self.has_run_comparison = {}  # {tab_idx: bool}
+        
+        # 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 Exception:
+                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 Exception:
+                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._create_diff_summary_bar()
+        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, 2), fill=tk.X, expand=True)
+        self.input_filter_var.trace_add("write", self._on_input_filter_changed)
+        ttk.Checkbutton(input_filter_frame, text="Rx", variable=self.input_regex_mode, 
+                        command=self._on_input_filter_changed, width=3).pack(side=tk.LEFT, padx=(0, 2))
+        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, 2), fill=tk.X, expand=True)
+        self.output_filter_var.trace_add("write", self._on_output_filter_changed)
+        ttk.Checkbutton(output_filter_frame, text="Rx", variable=self.output_regex_mode,
+                        command=self._on_output_filter_changed, width=3).pack(side=tk.LEFT, padx=(0, 2))
+        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_diff_summary_bar(self):
+        """Create diff summary bar with navigation buttons and similarity score."""
+        # Container frame spanning both columns
+        summary_frame = ttk.Frame(self.diff_frame)
+        summary_frame.grid(row=3, column=0, columnspan=2, sticky="ew", pady=(5, 0))
+        
+        # Navigation buttons on the left
+        nav_frame = ttk.Frame(summary_frame)
+        nav_frame.pack(side=tk.LEFT)
+        
+        self.prev_diff_btn = ttk.Button(nav_frame, text="⬆ Prev", command=self._goto_prev_diff, width=8)
+        self.prev_diff_btn.pack(side=tk.LEFT, padx=(0, 5))
+        self.prev_diff_btn.state(['disabled'])
+        
+        self.next_diff_btn = ttk.Button(nav_frame, text="⬇ Next", command=self._goto_next_diff, width=8)
+        self.next_diff_btn.pack(side=tk.LEFT, padx=(0, 10))
+        self.next_diff_btn.state(['disabled'])
+        
+        # Diff summary label in the center
+        self.diff_summary_bar = ttk.Label(
+            summary_frame,
+            text="Run comparison to see diff summary",
+            anchor=tk.CENTER,
+            padding=(5, 2)
+        )
+        self.diff_summary_bar.pack(side=tk.LEFT, fill=tk.X, expand=True)
+        
+        # Export button on the right
+        self.export_html_btn = ttk.Button(summary_frame, text="Export HTML", command=self._export_to_html, width=13)
+        self.export_html_btn.pack(side=tk.RIGHT, padx=(10, 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 and syntax."""
+        for tab_list in [self.input_tabs, self.output_tabs]:
+            for tab in tab_list:
+                widget = tab.text
+                widget.config(state="normal")
+                # Diff highlighting tags
+                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")
+                widget.tag_configure("moved", background="#f3e8ff")  # Lavender for moved lines
+                
+                # Syntax highlighting tags (lower priority than diff tags)
+                widget.tag_configure("syntax_keyword", foreground="#0000ff")  # Blue
+                widget.tag_configure("syntax_string", foreground="#008000")   # Green
+                widget.tag_configure("syntax_comment", foreground="#808080", font=("", 0, "italic"))  # Gray italic
+                widget.tag_configure("syntax_number", foreground="#ff8c00")   # Dark orange
+                widget.tag_configure("syntax_function", foreground="#800080") # Purple
+                widget.tag_configure("syntax_decorator", foreground="#b8860b") # Dark goldenrod
+                widget.tag_configure("syntax_class", foreground="#2e8b57")    # Sea green
+
+    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])
+        
+        # Clear stored comparison source text (so new content is compared fresh)
+        self.comparison_source_input.clear()
+        self.comparison_source_output.clear()
+        self.has_run_comparison.clear()
+        
+        # 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', 'sentence_level')
+            
+        Returns:
+            List of dicts with 'raw' and 'cmp' keys
+        """
+        # For sentence-level comparison, split by sentences instead of lines
+        if option == "sentence_level":
+            return self._preprocess_sentences(text)
+        
+        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()
+            elif option == "ignore_punctuation":
+                # Remove all punctuation for comparison (useful for prose)
+                cmp_line = re.sub(r'[^\w\s]', '', cmp_line.lower()).strip()
+                cmp_line = re.sub(r"\s+", " ", cmp_line)  # Normalize whitespace too
+            processed.append({"raw": line, "cmp": cmp_line})
+        return processed
+    
+    def _preprocess_sentences(self, text):
+        """
+        Split text into sentences for sentence-level comparison.
+        
+        Args:
+            text: Input text to split into sentences
+            
+        Returns:
+            List of dicts with 'raw' (original sentence) and 'cmp' (normalized) keys
+        """
+        # Replace line breaks with spaces for continuous text
+        continuous_text = re.sub(r'\s+', ' ', text).strip()
+        
+        if not continuous_text:
+            return []
+        
+        # Split into sentences using pattern that handles common cases
+        # Matches: . ! ? followed by space or end of string
+        # But not: abbreviations like Mr. Mrs. Dr. etc.
+        sentence_pattern = r'(?<![A-Z][a-z])(?<![A-Z])(?<=\.|\!|\?)\s+'
+        sentences = re.split(sentence_pattern, continuous_text)
+        
+        processed = []
+        for sentence in sentences:
+            sentence = sentence.strip()
+            if sentence:
+                # Normalize for comparison: lowercase, normalize whitespace
+                cmp_sentence = re.sub(r'\s+', ' ', sentence.lower()).strip()
+                processed.append({"raw": sentence, "cmp": cmp_sentence})
+        
+        return processed
+    
+    def _clean_alignment_blanks(self, text):
+        """
+        Remove consecutive empty lines (alignment artifacts) while preserving single empty lines.
+        
+        This prevents blank lines from accumulating across comparison sessions.
+        
+        Args:
+            text: Input text that may contain alignment blank lines
+            
+        Returns:
+            Cleaned text with consecutive empty lines collapsed
+        """
+        if not text:
+            return text
+        
+        lines = text.splitlines()
+        cleaned_lines = []
+        prev_was_empty = False
+        
+        for line in lines:
+            is_empty = line.strip() == ""
+            
+            if is_empty and prev_was_empty:
+                # Skip consecutive empty lines
+                continue
+            
+            cleaned_lines.append(line)
+            prev_was_empty = is_empty
+        
+        return '\n'.join(cleaned_lines)
+    
+    def reset_comparison_source(self):
+        """
+        Reset comparison source cache and clean widget content of accumulated blanks.
+        
+        Called when user clicks 'Compare Active Tabs' to ensure fresh content is used.
+        """
+        # Clear the source cache
+        self.comparison_source_input.clear()
+        self.comparison_source_output.clear()
+        self.has_run_comparison.clear()
+        
+        # Clean the active tab widgets of accumulated blank lines
+        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 and clean input content
+            input_text = input_widget.get("1.0", tk.END)
+            if input_text.endswith('\n'):
+                input_text = input_text[:-1]
+            cleaned_input = self._clean_alignment_blanks(input_text)
+            
+            # Get and clean output content
+            output_text = output_widget.get("1.0", tk.END)
+            if output_text.endswith('\n'):
+                output_text = output_text[:-1]
+            cleaned_output = self._clean_alignment_blanks(output_text)
+            
+            # Replace widget content with cleaned version
+            input_widget.delete("1.0", tk.END)
+            input_widget.insert("1.0", cleaned_input)
+            
+            output_widget.delete("1.0", tk.END)
+            output_widget.insert("1.0", cleaned_output)
+            
+        except (tk.TclError, IndexError) as e:
+            self.logger.warning(f"Could not clean widget content: {e}")
+
+    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
+            
+            # Check if we have stored original text from a previous comparison
+            # This prevents accumulating blank lines when switching comparison modes
+            tab_key = (active_input_idx, active_output_idx)
+            
+            if tab_key in self.has_run_comparison and self.has_run_comparison[tab_key]:
+                # Use stored original text (without alignment blanks)
+                input_text = self.comparison_source_input.get(active_input_idx, "")
+                output_text = self.comparison_source_output.get(active_output_idx, "")
+            else:
+                # First comparison - read current widget content and store it
+                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]
+                
+                # Store the original source text (no blank line cleaning - preserves structure)
+                self.comparison_source_input[active_input_idx] = input_text
+                self.comparison_source_output[active_output_idx] = output_text
+                self.has_run_comparison[tab_key] = True
+                
+        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)
+        
+        # Reset diff tracking
+        self.diff_positions = []
+        self.current_diff_index = -1
+        self.diff_counts = {"additions": 0, "deletions": 0, "modifications": 0}
+        self.similarity_score = 0.0
+
+        # Handle empty texts
+        if not input_text.strip() and not output_text.strip():
+            self._update_diff_summary()
+            return
+        elif not input_text.strip():
+            for i, line in enumerate(output_text.splitlines()):
+                input_widget.insert(tk.END, '\n')
+                output_widget.insert(tk.END, line + '\n', 'addition')
+                self.diff_positions.append((i + 1, 'addition'))
+                self.diff_counts["additions"] += 1
+            self._update_diff_summary()
+            return
+        elif not output_text.strip():
+            for i, line in enumerate(input_text.splitlines()):
+                input_widget.insert(tk.END, line + '\n', 'deletion')
+                output_widget.insert(tk.END, '\n')
+                self.diff_positions.append((i + 1, 'deletion'))
+                self.diff_counts["deletions"] += 1
+            self._update_diff_summary()
+            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:
+            matcher = difflib.SequenceMatcher(None, left_cmp, right_cmp, autojunk=False)
+            
+            # Compute similarity score
+            self.similarity_score = matcher.ratio() * 100
+            
+            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')
+                        # Get line number AFTER inserting (current line minus 1 since cursor is on next line)
+                        actual_line = int(input_widget.index(tk.INSERT).split('.')[0]) - 1
+                        if actual_line < 1:
+                            actual_line = 1
+                        self.diff_positions.append((actual_line, 'deletion'))
+                        self.diff_counts["deletions"] += 1
+                        
+                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')
+                        # Get line number AFTER inserting
+                        actual_line = int(input_widget.index(tk.INSERT).split('.')[0]) - 1
+                        if actual_line < 1:
+                            actual_line = 1
+                        self.diff_positions.append((actual_line, 'addition'))
+                        self.diff_counts["additions"] += 1
+                        
+                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])
+                            # Get line number AFTER inserting
+                            actual_line = int(input_widget.index(tk.INSERT).split('.')[0]) - 1
+                            if actual_line < 1:
+                                actual_line = 1
+                            self.diff_positions.append((actual_line, 'modification'))
+                            self.diff_counts["modifications"] += 1
+                        elif line1:
+                            input_widget.insert(tk.END, line1 + '\n', 'deletion')
+                            output_widget.insert(tk.END, '\n')
+                            actual_line = int(input_widget.index(tk.INSERT).split('.')[0]) - 1
+                            if actual_line < 1:
+                                actual_line = 1
+                            self.diff_positions.append((actual_line, 'deletion'))
+                            self.diff_counts["deletions"] += 1
+                        elif line2:
+                            input_widget.insert(tk.END, '\n')
+                            output_widget.insert(tk.END, line2 + '\n', 'addition')
+                            actual_line = int(input_widget.index(tk.INSERT).split('.')[0]) - 1
+                            if actual_line < 1:
+                                actual_line = 1
+                            self.diff_positions.append((actual_line, 'addition'))
+                            self.diff_counts["additions"] += 1
+                            
+        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()
+        
+        # Detect moved lines if enabled
+        if self.settings.get("detect_moved", False):
+            self._detect_moved_lines(input_widget, output_widget)
+        
+        # Apply syntax highlighting if enabled
+        if self.settings.get("syntax_highlight", False):
+            self._apply_syntax_highlighting(input_widget)
+            self._apply_syntax_highlighting(output_widget)
+        
+        # Update tab labels after comparison
+        self.update_tab_labels()
+        
+        # Update diff summary bar
+        self._update_diff_summary()
+    
+    def _detect_moved_lines(self, input_widget, output_widget):
+        """
+        Detect lines that were moved (appear in both delete and insert sections).
+        Re-tags them as 'moved' instead of deletion/addition.
+        """
+        try:
+            # Get all lines with deletion tag from input
+            deleted_lines = {}
+            for tag_range in input_widget.tag_ranges("deletion"):
+                if isinstance(tag_range, str):
+                    continue
+                # Get line number from index
+                line_num = int(str(tag_range).split('.')[0])
+                line_content = input_widget.get(f"{line_num}.0", f"{line_num}.end").strip()
+                if line_content:
+                    deleted_lines[line_content.lower()] = line_num
+            
+            # Get all lines with addition tag from output
+            added_lines = {}
+            for tag_range in output_widget.tag_ranges("addition"):
+                if isinstance(tag_range, str):
+                    continue
+                line_num = int(str(tag_range).split('.')[0])
+                line_content = output_widget.get(f"{line_num}.0", f"{line_num}.end").strip()
+                if line_content:
+                    added_lines[line_content.lower()] = line_num
+            
+            # Find lines that appear in both (moved lines)
+            moved_count = 0
+            for content, input_line in deleted_lines.items():
+                if content in added_lines:
+                    output_line = added_lines[content]
+                    # Re-tag as moved in both widgets
+                    input_widget.tag_remove("deletion", f"{input_line}.0", f"{input_line}.end+1c")
+                    input_widget.tag_add("moved", f"{input_line}.0", f"{input_line}.end+1c")
+                    
+                    output_widget.tag_remove("addition", f"{output_line}.0", f"{output_line}.end+1c")
+                    output_widget.tag_add("moved", f"{output_line}.0", f"{output_line}.end+1c")
+                    
+                    moved_count += 1
+            
+            # Update counts
+            if moved_count > 0:
+                self.diff_counts["moved"] = moved_count
+                # Reduce deletion/addition counts
+                self.diff_counts["deletions"] = max(0, self.diff_counts.get("deletions", 0) - moved_count)
+                self.diff_counts["additions"] = max(0, self.diff_counts.get("additions", 0) - moved_count)
+                
+        except Exception as e:
+            self.logger.error(f"Error detecting moved lines: {e}")
+    
+    def _apply_syntax_highlighting(self, widget):
+        """
+        Apply syntax highlighting to code content in a text widget.
+        Uses regex patterns for common programming constructs.
+        """
+        try:
+            content = widget.get("1.0", tk.END)
+            
+            # Define patterns for syntax highlighting
+            patterns = [
+                # Python/JS keywords
+                (r'\b(def|class|import|from|return|if|elif|else|for|while|try|except|finally|with|as|'
+                 r'raise|yield|lambda|and|or|not|in|is|True|False|None|async|await|'
+                 r'function|const|let|var|new|this|typeof|instanceof|export|default)\b', 
+                 'syntax_keyword'),
+                
+                # Triple-quoted strings (must come before single/double quotes)
+                (r'"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\'', 'syntax_string'),
+                
+                # Single and double quoted strings
+                (r'"(?:[^"\\]|\\.)*"|\'(?:[^\'\\]|\\.)*\'', 'syntax_string'),
+                
+                # Comments (Python # and JS //)
+                (r'#[^\n]*|//[^\n]*', 'syntax_comment'),
+                
+                # Numbers (integers, floats, hex)
+                (r'\b(?:0x[0-9a-fA-F]+|0b[01]+|0o[0-7]+|\d+\.?\d*(?:e[+-]?\d+)?)\b', 'syntax_number'),
+                
+                # Function definitions
+                (r'\b(?:def|function)\s+([a-zA-Z_][a-zA-Z0-9_]*)', 'syntax_function'),
+                
+                # Decorators
+                (r'@[a-zA-Z_][a-zA-Z0-9_.]*', 'syntax_decorator'),
+                
+                # Class definitions
+                (r'\bclass\s+([a-zA-Z_][a-zA-Z0-9_]*)', 'syntax_class'),
+            ]
+            
+            for pattern, tag in patterns:
+                for match in re.finditer(pattern, content):
+                    start_idx = f"1.0+{match.start()}c"
+                    end_idx = f"1.0+{match.end()}c"
+                    
+                    # For function/class definitions, highlight just the name (group 1)
+                    if tag in ('syntax_function', 'syntax_class') and match.lastindex:
+                        name_start = match.start(1)
+                        name_end = match.end(1)
+                        start_idx = f"1.0+{name_start}c"
+                        end_idx = f"1.0+{name_end}c"
+                    
+                    widget.tag_add(tag, start_idx, end_idx)
+            
+            # Ensure diff tags have higher priority (raise them above syntax tags)
+            for diff_tag in ['addition', 'deletion', 'modification', 'inline_add', 'inline_del', 'moved']:
+                widget.tag_raise(diff_tag)
+                
+        except Exception as e:
+            self.logger.error(f"Error applying syntax highlighting: {e}")
+
+    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
+        """
+        # Check if character-level diff is enabled
+        use_char_diff = self.settings.get("char_level_diff", False)
+        
+        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")
+
+            if use_char_diff:
+                # Character-level diff
+                self._apply_char_diff(w1, line1, line_start1, w2, line2, line_start2)
+            else:
+                # Word-level diff
+                self._apply_word_diff(w1, line1, line_start1, w2, line2, line_start2)
+    
+    def _apply_word_diff(self, w1, line1, line_start1, w2, line2, line_start2):
+        """Apply word-level diff highlighting."""
+        try:
+            words1 = re.split(r'(\s+)', line1)
+            words2 = re.split(r'(\s+)', line2)
+            
+            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 _apply_char_diff(self, w1, line1, line_start1, w2, line2, line_start2):
+        """Apply character-level diff highlighting."""
+        try:
+            # Split into individual characters
+            chars1 = list(line1)
+            chars2 = list(line2)
+            
+            matcher = difflib.SequenceMatcher(None, chars1, chars2)
+
+            for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+                if tag == 'delete' or tag == 'replace':
+                    w1.tag_add('inline_del', f"{line_start1}+{i1}c", f"{line_start1}+{i2}c")
+                if tag == 'insert' or tag == 'replace':
+                    w2.tag_add('inline_add', f"{line_start2}+{j1}c", f"{line_start2}+{j2}c")
+        except Exception as e:
+            self.logger.error(f"Error in character-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:
+            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 _update_diff_summary(self):
+        """Update the diff summary bar with current comparison results."""
+        if not self.diff_summary_bar:
+            return
+        
+        total_diffs = len(self.diff_positions)
+        adds = self.diff_counts.get("additions", 0)
+        dels = self.diff_counts.get("deletions", 0)
+        mods = self.diff_counts.get("modifications", 0)
+        moved = self.diff_counts.get("moved", 0)
+        
+        if total_diffs == 0 and moved == 0:
+            summary_text = "No differences found | 100% similar"
+            self.prev_diff_btn.state(['disabled'])
+            self.next_diff_btn.state(['disabled'])
+        else:
+            parts = [f"+{adds} additions", f"-{dels} deletions", f"~{mods} modifications"]
+            if moved > 0:
+                parts.append(f"↔{moved} moved")
+            parts.append(f"{self.similarity_score:.1f}% similar")
+            summary_text = " | ".join(parts)
+            self.prev_diff_btn.state(['!disabled'])
+            self.next_diff_btn.state(['!disabled'])
+        
+        self.diff_summary_bar.config(text=summary_text)
+    
+    def _goto_prev_diff(self):
+        """Navigate to the previous difference."""
+        if not self.diff_positions:
+            return
+        
+        if self.current_diff_index <= 0:
+            self.current_diff_index = len(self.diff_positions) - 1
+        else:
+            self.current_diff_index -= 1
+        
+        self._scroll_to_diff(self.current_diff_index)
+    
+    def _goto_next_diff(self):
+        """Navigate to the next difference."""
+        if not self.diff_positions:
+            return
+        
+        if self.current_diff_index >= len(self.diff_positions) - 1:
+            self.current_diff_index = 0
+        else:
+            self.current_diff_index += 1
+        
+        self._scroll_to_diff(self.current_diff_index)
+    
+    def _scroll_to_diff(self, diff_index):
+        """Scroll both text widgets to show the specified difference."""
+        try:
+            if diff_index < 0 or diff_index >= len(self.diff_positions):
+                return
+            
+            line_num, diff_type = self.diff_positions[diff_index]
+            
+            active_input_tab = self.input_tabs[self.input_notebook.index("current")]
+            active_output_tab = self.output_tabs[self.output_notebook.index("current")]
+            
+            input_widget = active_input_tab.text
+            output_widget = active_output_tab.text
+            
+            # Line index for the diff
+            line_index = f"{line_num}.0"
+            line_end = f"{line_num}.end"
+            
+            # Remove any previous navigation highlight
+            input_widget.tag_remove("nav_highlight", "1.0", tk.END)
+            output_widget.tag_remove("nav_highlight", "1.0", tk.END)
+            
+            # Configure navigation highlight tag (bright yellow background with high priority)
+            input_widget.tag_configure("nav_highlight", background="#ffff00", foreground="#000000")
+            output_widget.tag_configure("nav_highlight", background="#ffff00", foreground="#000000")
+            
+            # Add highlight to current diff line
+            input_widget.tag_add("nav_highlight", line_index, line_end)
+            output_widget.tag_add("nav_highlight", line_index, line_end)
+            
+            # Raise nav_highlight above all other tags so it's visible
+            input_widget.tag_raise("nav_highlight")
+            output_widget.tag_raise("nav_highlight")
+            
+            # Move cursor to the beginning of the line
+            input_widget.mark_set(tk.INSERT, line_index)
+            output_widget.mark_set(tk.INSERT, line_index)
+            
+            # Focus the input widget
+            input_widget.focus_set()
+            
+            # Scroll to make the line visible (centered if possible)
+            input_widget.see(line_index)
+            output_widget.see(line_index)
+            
+            # Force update of 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()
+            
+            # Update summary to show current position
+            total = len(self.diff_positions)
+            current = diff_index + 1
+            base_summary = self.diff_summary_bar.cget("text").split(" | Diff ")[0]
+            self.diff_summary_bar.config(text=f"{base_summary} | Diff {current}/{total}")
+            
+        except (tk.TclError, IndexError) as e:
+            self.logger.error(f"Error scrolling to diff: {e}")
+    
+    def _export_to_html(self):
+        """Export the current diff comparison to an HTML file."""
+        try:
+            active_input_idx = self.input_notebook.index("current")
+            active_output_idx = self.output_notebook.index("current")
+            
+            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)
+            
+            # Remove trailing newlines
+            if input_text.endswith('\n'):
+                input_text = input_text[:-1]
+            if output_text.endswith('\n'):
+                output_text = output_text[:-1]
+            
+            if not input_text.strip() and not output_text.strip():
+                messagebox.showinfo("Export", "No content to export.", parent=self.parent)
+                return
+            
+            # Ask for save location
+            file_path = filedialog.asksaveasfilename(
+                title="Export Diff as HTML",
+                defaultextension=".html",
+                filetypes=[("HTML files", "*.html"), ("All files", "*.*")],
+                parent=self.parent
+            )
+            
+            if not file_path:
+                return
+            
+            # Generate HTML diff
+            html_diff = difflib.HtmlDiff(wrapcolumn=80)
+            html_content = html_diff.make_file(
+                input_text.splitlines(),
+                output_text.splitlines(),
+                fromdesc="Input",
+                todesc="Output",
+                context=False
+            )
+            
+            # Add custom styling for better appearance
+            custom_css = """
+            <style>
+                body { font-family: 'Segoe UI', Tahoma, sans-serif; margin: 20px; }
+                table.diff { border-collapse: collapse; width: 100%; }
+                .diff_header { background-color: #f0f0f0; }
+                .diff_next { background-color: #e0e0e0; }
+                td { padding: 2px 8px; font-family: 'Consolas', 'Monaco', monospace; font-size: 12px; }
+                .diff_add { background-color: #e6ffed; }
+                .diff_chg { background-color: #e6f7ff; }
+                .diff_sub { background-color: #ffebe9; }
+                .summary { margin-bottom: 15px; padding: 10px; background: #f5f5f5; border-radius: 5px; }
+            </style>
+            """
+            
+            # Insert summary and custom CSS
+            summary_html = f"""
+            <div class="summary">
+                <strong>Diff Summary:</strong> 
+                +{self.diff_counts.get('additions', 0)} additions | 
+                -{self.diff_counts.get('deletions', 0)} deletions | 
+                ~{self.diff_counts.get('modifications', 0)} modifications | 
+                {self.similarity_score:.1f}% similar
+            </div>
+            """
+            
+            html_content = html_content.replace("</head>", f"{custom_css}</head>")
+            html_content = html_content.replace("<body>", f"<body>{summary_html}")
+            
+            # Write to file
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(html_content)
+            
+            self.logger.info(f"Exported diff to: {file_path}")
+            messagebox.showinfo("Export Complete", f"Diff exported to:\n{file_path}", parent=self.parent)
+            
+        except Exception as e:
+            self.logger.error(f"Error exporting to HTML: {e}")
+            self._show_error("Export Error", f"Could not export diff: {str(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')
+                
+                if self.input_regex_mode.get():
+                    # Regex mode
+                    try:
+                        pattern = re.compile(filter_text, re.IGNORECASE)
+                        filtered_lines = [line for line in lines if pattern.search(line)]
+                    except re.error as e:
+                        self.logger.warning(f"Invalid regex pattern: {e}")
+                        # Fallback to literal search on regex error
+                        filtered_lines = [line for line in lines if filter_text.lower() in line.lower()]
+                else:
+                    # Simple substring match
+                    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')
+                
+                if self.output_regex_mode.get():
+                    # Regex mode
+                    try:
+                        pattern = re.compile(filter_text, re.IGNORECASE)
+                        filtered_lines = [line for line in lines if pattern.search(line)]
+                    except re.error as e:
+                        self.logger.warning(f"Invalid regex pattern: {e}")
+                        # Fallback to literal search on regex error
+                        filtered_lines = [line for line in lines if filter_text.lower() in line.lower()]
+                else:
+                    # Simple substring match
+                    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 using regex pattern that handles abbreviations better
+            # Looks for sentence-ending punctuation followed by space or end of string
+            sentence_pattern = r'[.!?]+(?:\s|$)'
+            sentence_matches = re.findall(sentence_pattern, text)
+            sentence_count = len(sentence_matches)
+            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")
+        default_char_level = settings.get("char_level_diff", False)
+        default_detect_moved = settings.get("detect_moved", False)
+        default_syntax = settings.get("syntax_highlight", False)
+        
+        # Create option variables
+        self.option_var = tk.StringVar(value=default_option)
+        self.char_level_var = tk.BooleanVar(value=default_char_level)
+        self.detect_moved_var = tk.BooleanVar(value=default_detect_moved)
+        self.syntax_var = tk.BooleanVar(value=default_syntax)
+        
+        # Create UI
+        self._create_ui()
+        
+    def _create_ui(self):
+        """Create the settings UI in two rows for better layout."""
+        # Row 1: Comparison mode radio buttons
+        row1 = ttk.Frame(self.parent)
+        row1.pack(fill=tk.X, pady=(0, 3))
+        
+        ttk.Label(row1, text="Mode:").pack(side=tk.LEFT, padx=(0, 5))
+        
+        ttk.Radiobutton(
+            row1, 
+            text="Ignore case", 
+            variable=self.option_var, 
+            value="ignore_case", 
+            command=self._on_option_change
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        ttk.Radiobutton(
+            row1, 
+            text="Match case", 
+            variable=self.option_var, 
+            value="match_case", 
+            command=self._on_option_change
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        ttk.Radiobutton(
+            row1, 
+            text="Ignore whitespace", 
+            variable=self.option_var, 
+            value="ignore_whitespace", 
+            command=self._on_option_change
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        ttk.Radiobutton(
+            row1, 
+            text="Ignore punctuation", 
+            variable=self.option_var, 
+            value="ignore_punctuation", 
+            command=self._on_option_change
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        ttk.Radiobutton(
+            row1, 
+            text="Sentences", 
+            variable=self.option_var, 
+            value="sentence_level", 
+            command=self._on_option_change
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        # Row 2: Action buttons and options
+        row2 = ttk.Frame(self.parent)
+        row2.pack(fill=tk.X)
+        
+        ttk.Button(
+            row2, 
+            text="Compare Active Tabs", 
+            command=self._run_comparison
+        ).pack(side=tk.LEFT, padx=(0, 10))
+        
+        ttk.Label(row2, text="|").pack(side=tk.LEFT, padx=5)
+        
+        ttk.Label(row2, text="Options:").pack(side=tk.LEFT, padx=(0, 5))
+        
+        # Character-level diff checkbox
+        ttk.Checkbutton(
+            row2,
+            text="Char diff",
+            variable=self.char_level_var,
+            command=self._on_char_level_change
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        # Detect moved lines checkbox
+        ttk.Checkbutton(
+            row2,
+            text="Detect moved",
+            variable=self.detect_moved_var,
+            command=self._on_detect_moved_change
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        # Syntax highlighting checkbox
+        ttk.Checkbutton(
+            row2,
+            text="Syntax",
+            variable=self.syntax_var,
+            command=self._on_syntax_change
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        ttk.Label(row2, text="|").pack(side=tk.LEFT, padx=5)
+        
+        ttk.Button(
+            row2, 
+            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()
+        
+        # Show confirmation dialog for sentence mode
+        if option == "sentence_level":
+            if not self._confirm_sentence_mode():
+                # User cancelled - revert to previous option
+                previous_option = self.diff_viewer.settings.get("option", "ignore_case")
+                self.option_var.set(previous_option)
+                return
+        
+        self.diff_viewer.update_settings({"option": option})
+        
+        if self.on_setting_change:
+            self.on_setting_change("Diff Viewer", {"option": option})
+    
+    def _confirm_sentence_mode(self):
+        """Show confirmation dialog for sentence mode."""
+        message = (
+            "Sentence Mode restructures text for comparison.\n\n"
+            "• Text will be split into sentences (not lines)\n"
+            "• Each sentence appears on its own line\n"
+            "• Original line breaks will not be preserved\n\n"
+            "This is useful for comparing prose where sentences\n"
+            "may span multiple lines or be wrapped differently.\n\n"
+            "Continue with Sentence Mode?"
+        )
+        return messagebox.askyesno(
+            "Sentence Mode", 
+            message,
+            icon=messagebox.WARNING
+        )
+    
+    def _on_char_level_change(self):
+        """Handle character-level diff toggle."""
+        char_level = self.char_level_var.get()
+        self.diff_viewer.update_settings({"char_level_diff": char_level})
+        
+        # Re-run comparison with new setting
+        self._run_comparison()
+        
+        if self.on_setting_change:
+            self.on_setting_change("Diff Viewer", {"char_level_diff": char_level})
+    
+    def _on_detect_moved_change(self):
+        """Handle detect moved lines toggle."""
+        detect_moved = self.detect_moved_var.get()
+        self.diff_viewer.update_settings({"detect_moved": detect_moved})
+        
+        # Re-run comparison with new setting
+        self._run_comparison()
+        
+        if self.on_setting_change:
+            self.on_setting_change("Diff Viewer", {"detect_moved": detect_moved})
+    
+    def _on_syntax_change(self):
+        """Handle syntax highlighting toggle."""
+        syntax = self.syntax_var.get()
+        self.diff_viewer.update_settings({"syntax_highlight": syntax})
+        
+        # Re-run comparison with new setting
+        self._run_comparison()
+        
+        if self.on_setting_change:
+            self.on_setting_change("Diff Viewer", {"syntax_highlight": syntax})
+    
+    def _run_comparison(self):
+        """Run the diff comparison."""
+        option = self.option_var.get()
+        # Reset comparison source and clean widget content of accumulated blanks
+        self.diff_viewer.reset_comparison_source()
+        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 Exception:
+                            # 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()}
+    
+    def _show_warning(self, title, message):
+        """Show warning dialog using DialogManager if available, otherwise use messagebox."""
+        if hasattr(self.diff_viewer, '_show_warning'):
+            return self.diff_viewer._show_warning(title, message)
+        else:
+            messagebox.showwarning(title, message, parent=self.parent)
+            return True
+    
+    def _show_error(self, title, message):
+        """Show error dialog using DialogManager if available, otherwise use messagebox."""
+        if hasattr(self.diff_viewer, '_show_error'):
+            return self.diff_viewer._show_error(title, message)
+        else:
+            messagebox.showerror(title, message, parent=self.parent)
+            return True