fix: Semantic minimap/outline highlight accuracy - use byte offsets matching search behavior

Author: OlaProeis

CHANGELOG.md

@@ -38,6 +38,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Text wrapping support** - Handle wrapped lines correctly by using actual text rect width for measurement.
 - **Bold font measurement** - Use bold font for measurement when content starts with bold markers for better accuracy.
 
+#### Scroll Navigation Accuracy
+- **Unified scroll calculation** - Single function for all scroll-to-line operations (find, search-in-files, outline, minimap) ensuring consistent positioning.
+- **Fixed off-by-one errors** - Consistent 0-indexed vs 1-indexed line number handling across all navigation functions.
+- **Fresh line height** - Ensure actual rendered line height is used instead of stale/default values when calculating scroll positions.
+- **Large file accuracy** - Scroll navigation now works correctly in files with 3000+ lines; previously target lines could be hundreds of pixels off or completely out of view.
+- **Semantic minimap highlight fix** - Fixed highlight offset when clicking items in semantic minimap/outline panel. The highlight now correctly marks the target line by using byte offsets (matching search behavior) instead of character offsets.
+
 #### Settings & UX
 - **Session restore option** - New setting to disable tab restoration on startup. When disabled, app starts with a single empty tab instead of restoring previous session.
 

ROADMAP.md

@@ -97,11 +97,11 @@ New Ferrite logo and icon set.
 
 ---
 
-### v0.2.5.1 (Released) - Memory, Encoding & Polish
+### v0.2.5.1 (Released) - Memory, Encoding & Accuracy
 
 > **Status:** Released (2026-01-17)
 
-Point release focusing on memory optimization, multi-encoding support, cursor positioning improvements, and UX polish.
+Point release focusing on memory optimization, multi-encoding support, cursor positioning improvements, scroll navigation accuracy, and UX polish.
 
 #### Multi-Encoding File Support
 - [x] **Encoding detection** - Auto-detect file encoding on open using `encoding_rs` + `chardetng` crates
@@ -115,7 +115,14 @@ Point release focusing on memory optimization, multi-encoding support, cursor po
 - [x] **Text wrapping support** - Handle wrapped lines correctly by using actual text rect width for measurement
 - [x] **Bold font measurement** - Use bold font for measurement when content starts with bold markers
 
-> **Known Limitation:** Cursor positioning is best-effort accurate. Lines with mixed formatting (bold + regular + italic) may have slight drift on longer lines due to font width differences. Perfect positioning requires the custom editor widget planned for v0.3.0.
+#### Scroll Navigation Accuracy (Critical Fix)
+- [x] **Unified scroll calculation** - Single function for all scroll-to-line operations ensuring consistent behavior across find, search-in-files, outline panel, and semantic minimap
+- [x] **Fixed off-by-one errors** - Consistent 0-indexed vs 1-indexed line handling in `navigate_to_heading()` and related functions
+- [x] **Fresh line height tracking** - Use actual rendered line height instead of stale/default 20.0 value
+- [x] **Large file navigation** - Fixed scroll accuracy in files with 3000+ lines where targets around line 2000 could be 1000+ pixels off
+- [x] **Semantic minimap highlight fix** - Fixed highlight offset when clicking outline/minimap items; uses byte offsets (matching search) instead of character offsets
+
+> **Known Limitation:** Cursor positioning and scroll accuracy are best-effort within egui's constraints. Lines with mixed formatting may have slight drift on longer lines due to font width differences. Perfect positioning requires the custom editor widget planned for v0.3.0.
 
 #### Internationalization
 - [x] **Language selector** - Settings option to choose UI language
@@ -324,7 +331,7 @@ Replace egui's `TextEdit` with a custom `FerriteEditor` widget to unblock advanc
 - [ ] **Code folding with text hiding** - Actually collapse regions visually
 
 #### 4. Semantic Minimap Polish
-- [ ] **Scroll position accuracy** - Fix navigation centering for variable line heights, word wrap, and editor padding (deferred from v0.2.5)
+- [ ] **Pixel-perfect scroll positioning** - With custom editor widget, use actual galley coordinates for perfect navigation centering (basic fix shipped in v0.2.5.1; v0.3.0 provides full solution via FerriteEditor)
 
 #### 5. Markdown Enhancements
 - [ ] **Wikilinks support** ([#1](https://github.com/OlaProeis/Ferrite/issues/1)) - `[[wikilinks]]` syntax with auto-completion

src/app.rs

@@ -5376,6 +5376,9 @@ impl FerriteApp {
         // CSV/TSV files DO support split mode (raw text + table view)
         let skip_split_mode = file_type.is_structured();
 
+        // Track if we need to set App-level pending_scroll_to_line for Raw mode
+        let mut raw_mode_scroll_to_line: Option<usize> = None;
+
         if let Some(tab) = self.state.active_tab_mut() {
             let old_mode = tab.view_mode;
             let current_scroll = tab.scroll_offset;
@@ -5430,7 +5433,7 @@ impl FerriteApp {
                                 1
                             };
 
-                            // Store for line-based lookup after render
+                            // Store for line-based lookup after render (Rendered mode uses tab field)
                             tab.pending_scroll_to_line = Some(topmost_line);
                             debug!(
                                 "Sync scroll Raw→Rendered: scroll={} / line_height={:.1} → line {}",
@@ -5444,13 +5447,13 @@ impl FerriteApp {
                                 current_scroll,
                                 content_height,
                             ) {
-                                // Calculate target scroll in Raw mode
-                                let line_height = tab.raw_line_height.max(20.0);
-                                let target_scroll = (source_line.saturating_sub(1) as f32) * line_height;
-                                tab.pending_scroll_offset = Some(target_scroll);
+                                // Raw mode EditorWidget uses App-level pending_scroll_to_line
+                                // (not tab field), so we store it for setting after borrow ends.
+                                // source_line is 1-indexed from the mapping.
+                                raw_mode_scroll_to_line = Some(source_line);
                                 debug!(
-                                    "Sync scroll Rendered→Raw: scroll={} → line {} → raw_offset={:.1}",
-                                    current_scroll, source_line, target_scroll
+                                    "Sync scroll Rendered→Raw: scroll={} → line {} (will use App-level pending_scroll_to_line)",
+                                    current_scroll, source_line
                                 );
                             } else {
                                 // Fallback to percentage if no mappings
@@ -5474,6 +5477,12 @@ impl FerriteApp {
             // Mark settings dirty to save per-tab view mode on exit
             self.state.mark_settings_dirty();
         }
+
+        // Set App-level pending_scroll_to_line AFTER releasing mutable borrow.
+        // This is used by Raw mode EditorWidget which reads from self.pending_scroll_to_line.
+        if let Some(line) = raw_mode_scroll_to_line {
+            self.pending_scroll_to_line = Some(line);
+        }
     }
 
     /// Find the rendered Y position for a given source line using interpolated line mappings.
@@ -6377,88 +6386,49 @@ impl FerriteApp {
     /// 2. Applying transient highlight to make the heading visible
     /// 3. Positioning the cursor at the heading
     fn navigate_to_heading(&mut self, nav: HeadingNavRequest) {
-        // First, find the heading range without holding mutable borrow
-        // Note: content.find() returns BYTE offsets, we need to convert to CHAR offsets
+        // Find the line range using the line number from OutlineItem
+        // This is the most reliable approach since line numbers are always correct
         let found_range = if let Some(tab) = self.state.active_tab() {
             let content = &tab.content;
 
-            // Try to find the heading by text if available
-            if let (Some(title), Some(level)) = (&nav.title, nav.level) {
-                // Build the markdown heading pattern: "# Title" or "## Title" etc.
-                let hashes = "#".repeat(level as usize);
-                let pattern = format!("{} {}", hashes, title);
-                
-                // Search for exact pattern first - find() returns byte offset
-                if let Some(byte_start) = content.find(&pattern) {
-                    let byte_end = byte_start + pattern.len();
-                    // Convert byte offsets to character offsets for egui
-                    let char_start = Self::byte_to_char_offset(content, byte_start);
-                    let char_end = Self::byte_to_char_offset(content, byte_end);
-                    Some((char_start, char_end))
-                } else {
-                    // Try case-insensitive search around the expected line
-                    // This already returns character offsets
-                    Self::find_heading_near_line(content, title, level, nav.line)
-                }
-            } else if let Some(char_offset) = nav.char_offset {
-                // nav.char_offset is already a character offset from OutlineItem
-                // Find end of line starting from this position
-                let mut char_count = 0;
-                let mut line_end_char = char_offset;
-                for (i, ch) in content.chars().enumerate() {
-                    if i >= char_offset {
-                        if ch == '\n' {
-                            line_end_char = i;
-                            break;
-                        }
-                        char_count += 1;
-                    }
-                    if i > char_offset + 200 {
-                        // Safety limit
-                        line_end_char = i;
-                        break;
-                    }
-                }
-                if char_count > 0 {
-                    line_end_char = char_offset + char_count;
-                }
-                // If we didn't find newline, use end of content
-                if line_end_char == char_offset {
-                    line_end_char = content.chars().count();
-                }
-                Some((char_offset, line_end_char))
-            } else {
-                None
-            }
+            // Find the byte range for the target line (nav.line is 1-indexed)
+            Self::find_line_byte_range(content, nav.line)
         } else {
             None
         };
 
-        // Now apply navigation with mutable borrow
-        if let Some(tab) = self.state.active_tab_mut() {
+        // Apply navigation and calculate target line (1-indexed for scroll)
+        let target_line_1indexed = if let Some(tab) = self.state.active_tab_mut() {
             if let Some((char_start, char_end)) = found_range {
                 // Set transient highlight for the heading line (expects char offsets)
                 tab.set_transient_highlight(char_start, char_end);
 
-                // Calculate line and column from character offset
+                // Calculate line and column from character offset (0-indexed)
                 let (target_line, _) = Self::offset_to_line_col(&tab.content, char_start);
                 tab.cursor_position = (target_line, 0);
 
-                // Calculate scroll offset to center the heading
-                let line_height = tab.raw_line_height.max(1.0);
-                let viewport_height = tab.viewport_height;
-                let target_scroll = (target_line as f32 * line_height) - (viewport_height / 3.0);
-                tab.pending_scroll_offset = Some(target_scroll.max(0.0));
-                
+                let line_1indexed = target_line + 1;
                 debug!(
                     "Navigated to heading at char offset {}-{}, line {}",
-                    char_start, char_end, target_line + 1
+                    char_start, char_end, line_1indexed
                 );
+                Some(line_1indexed)
             } else {
-                // Fall back to basic line navigation
-                self.pending_scroll_to_line = Some(nav.line);
+                // Fall back to basic line navigation using nav.line (already 1-indexed)
                 tab.cursor_position = (nav.line.saturating_sub(1), 0);
+                debug!("Navigated to heading via fallback, line {}", nav.line);
+                Some(nav.line)
             }
+        } else {
+            None
+        };
+
+        // Set pending scroll AFTER releasing the mutable borrow.
+        // Use App-level pending_scroll_to_line so EditorWidget calculates
+        // scroll offset with fresh line height from ui.fonts().
+        // This is more accurate than using potentially stale raw_line_height.
+        if let Some(line) = target_line_1indexed {
+            self.pending_scroll_to_line = Some(line);
         }
     }
 
@@ -6508,6 +6478,56 @@ impl FerriteApp {
         None
     }
 
+    /// Find the BYTE range (start, end) for a specific line number.
+    /// 
+    /// # Arguments
+    /// * `content` - The text content
+    /// * `line_num` - The line number (1-indexed)
+    /// 
+    /// # Returns
+    /// The byte offset range (start, end) for that line, or None if line doesn't exist.
+    /// Note: Returns BYTE offsets because set_transient_highlight expects bytes.
+    fn find_line_byte_range(content: &str, line_num: usize) -> Option<(usize, usize)> {
+        if line_num == 0 {
+            return None;
+        }
+        
+        let target_idx = line_num - 1; // Convert to 0-indexed
+        
+        // Simple approach: find the byte position by scanning the actual bytes
+        let bytes = content.as_bytes();
+        let mut line_start = 0;
+        let mut current_line = 0;
+        
+        for (i, &byte) in bytes.iter().enumerate() {
+            if current_line == target_idx {
+                // Found the start of our target line, now find its end
+                let mut line_end = i;
+                for j in i..bytes.len() {
+                    if bytes[j] == b'\n' {
+                        // Don't include \r if present
+                        line_end = if j > 0 && bytes[j - 1] == b'\r' { j - 1 } else { j };
+                        break;
+                    }
+                    line_end = j + 1;
+                }
+                return Some((i, line_end));
+            }
+            
+            if byte == b'\n' {
+                current_line += 1;
+                line_start = i + 1;
+            }
+        }
+        
+        // Handle last line (no trailing newline)
+        if current_line == target_idx {
+            return Some((line_start, bytes.len()));
+        }
+        
+        None
+    }
+
     /// Convert a byte offset to character offset.
     /// 
     /// This is needed because `String::find()` returns byte offsets, but egui's

src/editor/outline.rs

@@ -351,7 +351,18 @@ impl DocumentOutline {
 /// A `DocumentOutline` containing all extracted items.
 pub fn extract_outline(text: &str) -> DocumentOutline {
     let mut items = Vec::new();
-    let mut char_offset = 0;
+    
+    // Build a map of line number (0-indexed) to character offset
+    // This is more accurate than reconstructing offsets from lines() iteration
+    let line_offsets: Vec<usize> = {
+        let mut offsets = vec![0]; // Line 0 starts at char 0
+        for (i, ch) in text.chars().enumerate() {
+            if ch == '\n' {
+                offsets.push(i + 1); // Next line starts after the \n
+            }
+        }
+        offsets
+    };
 
     // State tracking
     let mut in_code_block = false;
@@ -368,6 +379,9 @@ pub fn extract_outline(text: &str) -> DocumentOutline {
     for (line_idx, line) in text.lines().enumerate() {
         let line_num = line_idx + 1; // 1-indexed
         let trimmed = line.trim();
+        
+        // Get the character offset for this line from our pre-built map
+        let char_offset = line_offsets.get(line_idx).copied().unwrap_or(0);
 
         // Handle code block boundaries
         if trimmed.starts_with("```") {
@@ -479,9 +493,8 @@ pub fn extract_outline(text: &str) -> DocumentOutline {
             }
         }
 
-        // Track CHARACTER offset (not byte offset!) including newline
-        // Use chars().count() instead of len() to correctly handle UTF-8
-        char_offset += line.chars().count() + 1;
+        // Note: char_offset is now looked up from line_offsets map at loop start,
+        // so no manual tracking needed here.
     }
 
     // Finalize any remaining content blocks at end of document