pomera-ai-commander 0.1.0

package/core/efficient_line_numbers.py

@@ -0,0 +1,511 @@
+"""
+Efficient line number rendering system for Promera AI Commander.
+Optimizes line number display for large documents by only rendering visible lines
+and implementing intelligent caching and debouncing.
+"""
+
+import tkinter as tk
+from tkinter import scrolledtext
+import platform
+import time
+import threading
+from typing import Dict, List, Tuple, Optional, Any
+from dataclasses import dataclass
+
+@dataclass
+class LineInfo:
+    """Information about a line in the text widget."""
+    line_number: int
+    y_position: int
+    height: int
+    is_visible: bool
+
+class EfficientLineNumbers(tk.Frame):
+    """
+    Optimized line number widget that only renders visible lines
+    and implements intelligent caching and debouncing.
+    """
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        
+        # Configuration
+        self.line_number_width = 50  # Adjustable width
+        self.debounce_delay = 5  # ms - very responsive updates
+        self.cache_size_limit = 1000  # Maximum cached line positions
+        
+        # Create widgets
+        self.text = scrolledtext.ScrolledText(
+            self, wrap=tk.WORD, height=15, width=50, undo=True
+        )
+        self.linenumbers = tk.Canvas(
+            self, width=self.line_number_width, bg='#f0f0f0', 
+            highlightthickness=0, bd=0
+        )
+        
+        # Layout
+        self.linenumbers.pack(side=tk.LEFT, fill=tk.Y)
+        self.text.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)
+        
+        # Performance tracking
+        self.visible_lines_cache: Dict[str, LineInfo] = {}
+        self.last_scroll_position: Optional[Tuple[float, float]] = None
+        self.last_content_hash: Optional[str] = None
+        self.last_update_time: float = 0
+        self.pending_update_id: Optional[str] = None
+        
+        # Rendering optimization
+        self.canvas_items: List[int] = []  # Track canvas items for efficient clearing
+        self.font_metrics: Optional[Dict[str, int]] = None
+        self.line_height: int = 16  # Default, will be calculated
+        
+        # Setup event bindings
+        self._setup_event_bindings()
+        
+        # Ensure scrollbar is properly connected
+        self._setup_scrollbar_sync()
+        
+        # Initial render
+        self.after(10, self._update_line_numbers)
+    
+    def _setup_event_bindings(self):
+        """Setup optimized event bindings."""
+        # Mouse wheel events on both text and line numbers
+        self.linenumbers.bind("<MouseWheel>", self._on_mousewheel)
+        self.linenumbers.bind("<Button-4>", self._on_mousewheel)
+        self.linenumbers.bind("<Button-5>", self._on_mousewheel)
+        self.text.bind("<MouseWheel>", self._on_text_mousewheel)
+        self.text.bind("<Button-4>", self._on_text_mousewheel)
+        self.text.bind("<Button-5>", self._on_text_mousewheel)
+        
+        # Key events for navigation (works even when disabled)
+        self.text.bind("<Up>", self._on_navigation_key)
+        self.text.bind("<Down>", self._on_navigation_key)
+        self.text.bind("<Page_Up>", self._on_navigation_key)
+        self.text.bind("<Page_Down>", self._on_navigation_key)
+        self.text.bind("<Home>", self._on_navigation_key)
+        self.text.bind("<End>", self._on_navigation_key)
+        
+        # Text modification events (with immediate and debounced updates)
+        self.text.bind("<<Modified>>", self._on_text_modified_debounced)
+        self.text.bind("<Configure>", self._on_configure_debounced)
+        self.text.bind("<KeyPress>", self._on_key_press)
+        self.text.bind("<KeyRelease>", self._on_key_release)
+        self.text.bind("<Button-1>", self._on_mouse_click)
+        
+        # Focus events for optimization
+        self.text.bind("<FocusIn>", self._on_focus_in)
+        self.text.bind("<FocusOut>", self._on_focus_out)
+    
+    def _setup_scrollbar_sync(self):
+        """Setup proper scrollbar synchronization."""
+        # Configure the scrollbar to call our custom scroll handler
+        original_yscrollcommand = self.text.cget('yscrollcommand')
+        
+        def combined_scroll_command(*args):
+            # Call original scroll command (updates scrollbar)
+            if original_yscrollcommand:
+                self.text.tk.call(original_yscrollcommand, *args)
+            # Update line numbers immediately for scrollbar changes
+            self._update_line_numbers()
+        
+        # Set up the text widget to call our combined handler
+        self.text.config(yscrollcommand=combined_scroll_command)
+        
+        # Configure scrollbar to call our scroll handler
+        self.text.vbar.config(command=self._on_text_scroll)
+        
+        # Also bind scrollbar events directly
+        self.text.vbar.bind("<Button-1>", lambda e: self.after(10, self._update_line_numbers))
+        self.text.vbar.bind("<B1-Motion>", lambda e: self.after(1, self._update_line_numbers))
+    
+    def _on_text_scroll(self, *args):
+        """Handle scrolling with optimized line number updates."""
+        # Apply the scroll to the text widget
+        self.text.yview(*args)
+        
+        # Immediate line number update for scrolling (no delay)
+        self._update_line_numbers()
+    
+    def _on_mousewheel(self, event):
+        """Handle mouse wheel scrolling with platform-specific logic."""
+        if platform.system() == "Windows":
+            delta = int(-1 * (event.delta / 120))
+        elif platform.system() == "Darwin":  # macOS
+            delta = int(-1 * event.delta)
+        else:  # Linux
+            delta = -1 if event.num == 4 else 1
+        
+        # Scroll the text widget
+        self.text.yview_scroll(delta, "units")
+        
+        # Immediate line number update for mouse wheel scrolling (no delay)
+        self._update_line_numbers()
+        return "break"
+    
+    def _on_text_modified_debounced(self, event=None):
+        """Handle text modifications with debouncing."""
+        if event and hasattr(event.widget, 'edit_modified') and event.widget.edit_modified():
+            event.widget.edit_modified(False)
+            self._schedule_line_number_update()
+    
+    def _on_configure_debounced(self, event=None):
+        """Handle widget configuration changes with debouncing."""
+        self._schedule_line_number_update()
+    
+    def _on_focus_in(self, event=None):
+        """Handle focus in - ensure line numbers are up to date."""
+        self._schedule_line_number_update()
+    
+    def _on_focus_out(self, event=None):
+        """Handle focus out - can reduce update frequency."""
+        pass  # Could implement reduced update frequency when not focused
+    
+    def _on_key_press(self, event=None):
+        """Handle key press events - immediate update for Enter key."""
+        if event and event.keysym in ['Return', 'BackSpace', 'Delete']:
+            # For line-changing operations, update immediately
+            self.after_idle(self._update_line_numbers)
+        else:
+            # For other keys, use debounced update
+            self._schedule_line_number_update()
+    
+    def _on_key_release(self, event=None):
+        """Handle key release events."""
+        # Schedule update after key release
+        self._schedule_line_number_update()
+    
+    def _on_mouse_click(self, event=None):
+        """Handle mouse click events."""
+        # Update line numbers after mouse click (cursor position change)
+        self.after_idle(self._update_line_numbers)
+    
+    def _on_text_mousewheel(self, event):
+        """Handle mouse wheel scrolling on text widget."""
+        # Let the text widget handle the scroll normally, then update line numbers immediately
+        self.after(1, self._update_line_numbers)  # Very short delay to let text widget scroll first
+        # Don't return "break" so the text widget can handle the scroll
+    
+    def _on_navigation_key(self, event):
+        """Handle navigation keys that might change the view."""
+        # Let the text widget handle the key first, then update line numbers
+        self.after(1, self._update_line_numbers)
+        # Don't return "break" so the text widget can handle the key
+    
+    def _schedule_line_number_update(self):
+        """Schedule a debounced line number update."""
+        current_time = time.time() * 1000  # Convert to milliseconds
+        
+        # Cancel pending update
+        if self.pending_update_id:
+            self.after_cancel(self.pending_update_id)
+        
+        # Schedule new update
+        self.pending_update_id = self.after(
+            self.debounce_delay, 
+            self._update_line_numbers
+        )
+        
+        self.last_update_time = current_time
+    
+    def _update_line_numbers(self):
+        """Update line numbers with optimizations."""
+        try:
+            self.pending_update_id = None
+            
+            # Get current view information
+            view_info = self._get_view_info()
+            if not view_info:
+                return
+            
+            # Check if update is actually needed
+            if not self._needs_update(view_info):
+                return
+            
+            # Clear existing canvas items efficiently
+            self._clear_canvas_items()
+            
+            # Get visible lines only
+            visible_lines = self._get_visible_lines()
+            
+            # Render visible line numbers
+            self._render_line_numbers(visible_lines)
+            
+            # Update cache
+            self._update_cache(view_info, visible_lines)
+            
+        except Exception as e:
+            # Graceful error handling
+            print(f"Error updating line numbers: {e}")
+    
+    def _get_view_info(self) -> Optional[Dict[str, Any]]:
+        """Get current view information."""
+        try:
+            return {
+                'scroll_position': self.text.yview(),
+                'widget_height': self.text.winfo_height(),
+                'content_hash': self._get_content_hash()
+            }
+        except Exception:
+            return None
+    
+    def _get_content_hash(self) -> str:
+        """Get a hash of the current content for change detection."""
+        try:
+            content = self.text.get("1.0", "end-1c")
+            # Simple hash based on content length and first/last chars
+            if content:
+                return f"{len(content)}_{content[:10]}_{content[-10:]}"
+            return "empty"
+        except Exception:
+            return "error"
+    
+    def _needs_update(self, view_info: Dict[str, Any]) -> bool:
+        """Check if line numbers actually need updating."""
+        # Always update if no previous state
+        if self.last_scroll_position is None or self.last_content_hash is None:
+            return True
+        
+        # Check if content changed
+        if view_info['content_hash'] != self.last_content_hash:
+            return True
+        
+        # Check if scroll position changed significantly
+        old_top, old_bottom = self.last_scroll_position
+        new_top, new_bottom = view_info['scroll_position']
+        
+        # Update if scroll position changed by more than 0.1% of view (more sensitive)
+        scroll_threshold = 0.001
+        if (abs(new_top - old_top) > scroll_threshold or 
+            abs(new_bottom - old_bottom) > scroll_threshold):
+            return True
+        
+        return False
+    
+    def _clear_canvas_items(self):
+        """Efficiently clear canvas items."""
+        if self.canvas_items:
+            for item_id in self.canvas_items:
+                try:
+                    self.linenumbers.delete(item_id)
+                except Exception:
+                    pass  # Item may already be deleted
+            self.canvas_items.clear()
+        else:
+            # Fallback to delete all
+            self.linenumbers.delete("all")
+    
+    def _get_visible_lines(self) -> List[LineInfo]:
+        """Get information about currently visible lines."""
+        visible_lines = []
+        
+        try:
+            # Get the first visible line
+            first_visible = self.text.index("@0,0")
+            
+            # Calculate font metrics if not cached
+            if self.font_metrics is None:
+                self._calculate_font_metrics()
+            
+            # Iterate through visible lines
+            current_index = first_visible
+            y_offset = 0
+            
+            while True:
+                try:
+                    # Get line display info
+                    dline_info = self.text.dlineinfo(current_index)
+                    if dline_info is None:
+                        break
+                    
+                    # Extract line information
+                    x, y, width, height, baseline = dline_info
+                    line_number = int(current_index.split('.')[0])
+                    
+                    # Check if line is within visible area
+                    widget_height = self.text.winfo_height()
+                    if y > widget_height:
+                        break
+                    
+                    visible_lines.append(LineInfo(
+                        line_number=line_number,
+                        y_position=y,
+                        height=height,
+                        is_visible=True
+                    ))
+                    
+                    # Move to next line
+                    next_index = self.text.index(f"{current_index}+1line")
+                    if next_index == current_index:
+                        break
+                    current_index = next_index
+                    
+                except Exception:
+                    break
+            
+        except Exception as e:
+            print(f"Error getting visible lines: {e}")
+        
+        return visible_lines
+    
+    def _calculate_font_metrics(self):
+        """Calculate font metrics for line height estimation."""
+        try:
+            # Create a temporary text item to measure font
+            temp_item = self.linenumbers.create_text(
+                0, 0, text="1", font=("TkDefaultFont",), anchor="nw"
+            )
+            bbox = self.linenumbers.bbox(temp_item)
+            if bbox:
+                self.line_height = bbox[3] - bbox[1]
+            self.linenumbers.delete(temp_item)
+            
+            self.font_metrics = {
+                'line_height': self.line_height,
+                'char_width': 8  # Approximate
+            }
+        except Exception:
+            self.font_metrics = {
+                'line_height': 16,
+                'char_width': 8
+            }
+    
+    def _render_line_numbers(self, visible_lines: List[LineInfo]):
+        """Render line numbers for visible lines only."""
+        if not visible_lines:
+            return
+        
+        try:
+            # Calculate optimal text positioning
+            text_x = self.line_number_width - 5  # Right-aligned with padding
+            
+            # Render each visible line number
+            for line_info in visible_lines:
+                try:
+                    item_id = self.linenumbers.create_text(
+                        text_x, line_info.y_position,
+                        text=str(line_info.line_number),
+                        anchor="ne",  # Right-aligned
+                        fill="gray",
+                        font=("TkDefaultFont", "9")
+                    )
+                    self.canvas_items.append(item_id)
+                except Exception as e:
+                    print(f"Error rendering line {line_info.line_number}: {e}")
+                    continue
+            
+            # Sync canvas scroll position with text widget
+            self._sync_canvas_scroll()
+            
+        except Exception as e:
+            print(f"Error rendering line numbers: {e}")
+    
+    def _sync_canvas_scroll(self):
+        """Synchronize canvas scroll position with text widget."""
+        try:
+            # Get the text widget's current scroll position
+            scroll_top, scroll_bottom = self.text.yview()
+            
+            # Move the canvas to match the text widget's scroll position
+            self.linenumbers.yview_moveto(scroll_top)
+        except Exception as e:
+            print(f"Error syncing canvas scroll: {e}")
+    
+    def _update_cache(self, view_info: Dict[str, Any], visible_lines: List[LineInfo]):
+        """Update internal cache with current state."""
+        self.last_scroll_position = view_info['scroll_position']
+        self.last_content_hash = view_info['content_hash']
+        
+        # Update visible lines cache (with size limit)
+        cache_key = f"{view_info['content_hash']}_{view_info['scroll_position']}"
+        self.visible_lines_cache[cache_key] = visible_lines
+        
+        # Limit cache size
+        if len(self.visible_lines_cache) > self.cache_size_limit:
+            # Remove oldest entries (simple FIFO)
+            oldest_keys = list(self.visible_lines_cache.keys())[:-self.cache_size_limit//2]
+            for key in oldest_keys:
+                self.visible_lines_cache.pop(key, None)
+    
+    def get_performance_stats(self) -> Dict[str, Any]:
+        """Get performance statistics for monitoring."""
+        return {
+            'cache_size': len(self.visible_lines_cache),
+            'canvas_items': len(self.canvas_items),
+            'last_update_time': self.last_update_time,
+            'debounce_delay': self.debounce_delay,
+            'line_height': self.line_height
+        }
+    
+    def clear_cache(self):
+        """Clear internal caches for memory management."""
+        self.visible_lines_cache.clear()
+        self.last_scroll_position = None
+        self.last_content_hash = None
+    
+    def set_line_number_width(self, width: int):
+        """Dynamically adjust line number width."""
+        self.line_number_width = width
+        self.linenumbers.config(width=width)
+        self._schedule_line_number_update()
+    
+    def set_debounce_delay(self, delay: int):
+        """Adjust debounce delay for different performance needs."""
+        self.debounce_delay = max(10, min(500, delay))  # Clamp between 10-500ms
+
+class OptimizedTextWithLineNumbers(EfficientLineNumbers):
+    """
+    Drop-in replacement for the original TextWithLineNumbers class
+    with all the performance optimizations including lazy updates.
+    """
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        
+        # Add performance monitoring integration if available
+        try:
+            from performance_monitor import get_performance_monitor, PerformanceContext
+            self.performance_monitor = get_performance_monitor()
+            self.performance_monitoring = True
+        except ImportError:
+            self.performance_monitor = None
+            self.performance_monitoring = False
+    
+    def _on_text_modified(self, event=None):
+        """Compatibility method for the main application."""
+        # This method is called by the main application for compatibility
+        # Delegate to our optimized update method
+        self._schedule_line_number_update()
+        
+        # Handle the modified flag like the original implementation
+        if event and hasattr(event.widget, 'edit_modified') and event.widget.edit_modified():
+            event.widget.edit_modified(False)
+    
+    def _update_line_numbers(self):
+        """Override with performance monitoring."""
+        if self.performance_monitoring and self.performance_monitor:
+            try:
+                from performance_monitor import PerformanceContext
+                with PerformanceContext(self.performance_monitor, 'line_numbers_update'):
+                    super()._update_line_numbers()
+            except ImportError:
+                # Fall back to non-monitored update
+                super()._update_line_numbers()
+        else:
+            super()._update_line_numbers()
+    
+    def force_immediate_update(self):
+        """Force an immediate line number update."""
+        self._update_line_numbers()
+    
+    def cleanup_resources(self):
+        """Clean up resources when widget is destroyed."""
+        # Clear caches
+        self.clear_cache()
+    
+    def get_performance_info(self) -> Dict[str, Any]:
+        """Get comprehensive performance information."""
+        return self.get_performance_stats()
+
+# Backward compatibility alias
+TextWithLineNumbers = OptimizedTextWithLineNumbers