Fixed bug in ansi output.

Author: mkrueger

crates/icy_draw/src/ui/editor/ansi/main_area.rs

@@ -565,8 +565,39 @@ impl AnsiEditorMainArea {
     }
 
     /// Scroll the canvas to show the given character position (used for goto user)
-    pub fn scroll_to_position(&mut self, col: i32, row: i32) {
-        self.core.scroll_to_position(col, row);
+    pub fn scroll_to_position(&mut self, col: i32, row: i32) -> Task<AnsiEditorMessage> {
+        let (buf_width, buf_height) = {
+            let mut screen_guard = self.core.screen.lock();
+            let state = screen_guard
+                .as_any_mut()
+                .downcast_mut::<EditState>()
+                .expect("AnsiEditor screen should always be EditState");
+            let buffer = state.get_buffer();
+            (buffer.width().max(1) as f32, buffer.height().max(1) as f32)
+        };
+
+        let norm_x: f32 = (col as f32 + 0.5) / buf_width;
+        let norm_y: f32 = (row as f32 + 0.5) / buf_height;
+
+        let terminal = &self.core.canvas.terminal;
+        let content_width = terminal.content_width().max(1.0);
+        let content_height = terminal.content_height().max(1.0);
+        let visible_width = terminal.visible_content_width().max(1.0);
+        let visible_height = terminal.visible_content_height().max(1.0);
+
+        // Keep current X when horizontal scrolling isn't possible.
+        let current_scroll_x = terminal.scroll_x();
+
+        let target_x = if content_width > visible_width {
+            norm_x.clamp(0.0, 1.0) * content_width - visible_width / 2.0
+        } else {
+            current_scroll_x
+        };
+
+        let target_y = norm_y.clamp(0.0, 1.0) * content_height - visible_height / 2.0;
+
+        // Programmatic scrolling is task-driven via the owning scroll_area.
+        terminal.scroll_to_content::<AnsiEditorMessage>(Some(target_x), Some(target_y))
     }
 
     pub fn zoom_info_string(&self) -> String {
@@ -1548,7 +1579,25 @@ impl AnsiEditorMainArea {
                     RightPanelMessage::Minimap(minimap_msg) => {
                         match minimap_msg {
                             MinimapMessage::ScrollTo { norm_x, norm_y } => {
-                                self.core.scroll_canvas_to_normalized(norm_x, norm_y);
+                                let terminal = &self.core.canvas.terminal;
+                                let content_width = terminal.content_width().max(1.0);
+                                let content_height = terminal.content_height().max(1.0);
+                                let visible_width = terminal.visible_content_width().max(1.0);
+                                let visible_height = terminal.visible_content_height().max(1.0);
+
+                                // Keep current X when horizontal scrolling isn't possible.
+                                let current_scroll_x = terminal.scroll_x();
+
+                                let target_x = if content_width > visible_width {
+                                    norm_x.clamp(0.0, 1.0) * content_width - visible_width / 2.0
+                                } else {
+                                    current_scroll_x
+                                };
+
+                                let target_y = norm_y.clamp(0.0, 1.0) * content_height - visible_height / 2.0;
+
+                                let scroll_task = terminal.scroll_to_content::<AnsiEditorMessage>(Some(target_x), Some(target_y));
+                                return Task::batch(vec![task, scroll_task]);
                             }
                             MinimapMessage::Scroll(_dy) => {
                                 // handled internally by the minimap view

crates/icy_draw/src/ui/editor/ansi/widget/minimap/minimap_shader.rs

@@ -409,19 +409,10 @@ impl shader::Program<MinimapMessage> for MinimapProgram {
         cursor: mouse::Cursor,
     ) -> Option<icy_ui::widget::Action<MinimapMessage>> {
         match event {
-            // Handle redraw requests for continuous drag scrolling
-            icy_ui::Event::Window(icy_ui::window::Event::RedrawRequested(now)) => {
-                if state.is_dragging {
-                    state.last_redraw = Some(*now);
-                    // Re-send scroll position based on last known pointer position
-                    if let Some(last_pos) = state.last_pointer_position {
-                        if let Some((norm_x, norm_y)) = self.calculate_normalized_position(last_pos, bounds) {
-                            return Some(icy_ui::widget::Action::publish(MinimapMessage::ScrollTo { norm_x, norm_y }));
-                        }
-                    }
-                } else {
-                    state.last_redraw = None;
-                }
+            // IMPORTANT: Do not publish messages from RedrawRequested.
+            // Doing so can create redraw → message → layout invalidation loops in winit.
+            icy_ui::Event::Window(icy_ui::window::Event::RedrawRequested(_now)) => {
+                state.last_redraw = None;
             }
 
             // Handle mouse button press - start dragging

crates/icy_draw/src/ui/editor/ansi/widget/minimap/mod.rs

@@ -124,20 +124,22 @@ impl MinimapView {
         )
     }
 
-    /// Ensure the viewport rectangle is visible in the minimap
-    /// Adjusts scroll_position so the viewport is always on screen
-    /// Uses interior mutability so it can be called from view()
+    /// Compute the scroll position (0..1) that would keep the viewport rectangle visible.
     ///
-    /// viewport_y and viewport_height are normalized (0-1) relative to full buffer
-    /// content_width and content_height are in pixels
-    fn ensure_viewport_visible(&self, viewport_y: f32, viewport_height: f32, content_width: f32, content_height: f32) {
-        let shared = self.shared_state.lock();
-        let avail_width = shared.available_width;
-        let avail_height = shared.available_height;
-        drop(shared);
-
+    /// This is intentionally **pure** (does not mutate `self.scroll_position`) so it can be
+    /// called from `view()` without triggering layout invalidation/redraw loops.
+    fn compute_scroll_to_show_viewport(
+        &self,
+        current_scroll: f32,
+        viewport_y: f32,
+        viewport_height: f32,
+        content_width: f32,
+        content_height: f32,
+        avail_width: f32,
+        avail_height: f32,
+    ) -> f32 {
         if avail_width <= 0.0 || avail_height <= 0.0 || content_height <= 0.0 || content_width <= 0.0 {
-            return;
+            return current_scroll;
         }
 
         // Scale factor: minimap fills available width
@@ -148,21 +150,20 @@ impl MinimapView {
 
         // If content fits in available space, no scrolling needed
         if scaled_content_height <= avail_height {
-            *self.scroll_position.borrow_mut() = 0.0;
-            return;
+            return 0.0;
         }
 
-        // viewport_y and viewport_height are already normalized (0-1)
+        // viewport_y and viewport_height are normalized (0-1)
         // Convert to scaled pixels
         let viewport_top_scaled = viewport_y * content_height * scale;
         let viewport_height_scaled = viewport_height * content_height * scale;
         let viewport_bottom_scaled = viewport_top_scaled + viewport_height_scaled;
 
         // Maximum scroll offset in pixels
-        let max_scroll_px = scaled_content_height - avail_height;
+        let max_scroll_px = (scaled_content_height - avail_height).max(0.0);
 
         // Current scroll offset in pixels
-        let current_scroll = *self.scroll_position.borrow();
+        let current_scroll = current_scroll.clamp(0.0, 1.0);
         let current_scroll_px = current_scroll * max_scroll_px;
 
         // Visible range in scaled pixels
@@ -172,24 +173,20 @@ impl MinimapView {
         // If viewport is larger than visible area, align to viewport top to avoid oscillation
         if viewport_height_scaled >= avail_height {
             let new_scroll_px = viewport_top_scaled;
-            let new_scroll = (new_scroll_px / max_scroll_px).clamp(0.0, 1.0);
-            *self.scroll_position.borrow_mut() = new_scroll;
-            return;
+            return (new_scroll_px / max_scroll_px).clamp(0.0, 1.0);
         }
 
         // Check if viewport is above visible area
         if viewport_top_scaled < visible_top {
-            // Scroll up to show viewport at top
             let new_scroll_px = viewport_top_scaled;
-            let new_scroll = (new_scroll_px / max_scroll_px).clamp(0.0, 1.0);
-            *self.scroll_position.borrow_mut() = new_scroll;
+            (new_scroll_px / max_scroll_px).clamp(0.0, 1.0)
         } else if viewport_bottom_scaled > visible_bottom {
-            // Scroll down to show viewport at bottom
             let new_scroll_px = viewport_bottom_scaled - avail_height;
-            let new_scroll = (new_scroll_px / max_scroll_px).clamp(0.0, 1.0);
-            *self.scroll_position.borrow_mut() = new_scroll;
+            (new_scroll_px / max_scroll_px).clamp(0.0, 1.0)
+        } else {
+            // If viewport is within visible area, don't change scroll
+            current_scroll
         }
-        // If viewport is within visible area, don't change scroll
     }
 
     /// Update the minimap view state
@@ -255,12 +252,24 @@ impl MinimapView {
                 let content_width = content_width_u32 as f32;
                 let content_height = content_height_f32;
 
-                // Auto-scroll to keep viewport visible
-                self.ensure_viewport_visible(viewport_info.y, viewport_info.height, content_width, content_height);
+                        // Compute a scroll position that keeps the viewport visible.
+                        // Do NOT mutate widget state from view() (can trigger layout invalidation loops).
+                        let scroll_normalized = {
+                            let current = *self.scroll_position.borrow();
+                            self.compute_scroll_to_show_viewport(
+                                current,
+                                viewport_info.y,
+                                viewport_info.height,
+                                content_width,
+                                content_height,
+                                avail_width,
+                                avail_height,
+                            )
+                        };
 
                 // Calculate which tiles to select based on visible area
                 let tile_height = TILE_HEIGHT as f32;
-                let scroll_normalized = *self.scroll_position.borrow();
+                let scroll_normalized = scroll_normalized;
 
                 let max_tile_idx = ((content_height / tile_height).ceil().max(1.0) as i32) - 1;
 

crates/icy_draw/src/ui/main_window/main_window.rs

@@ -1966,7 +1966,9 @@ impl MainWindow {
                             if let Some((col, row)) = user.cursor {
                                 log::info!("Goto user {} at ({}, {})", user.user.nick, col, row);
                                 if let ModeState::Ansi(editor) = &mut self.mode_state {
-                                    editor.scroll_to_position(col, row);
+                                    // Clicking elsewhere removes focus from chat input
+                                    self.collaboration_state.chat_input_focused = false;
+                                    return editor.scroll_to_position(col, row).map(Message::AnsiEditor);
                                 }
                             }
                         }

crates/icy_engine/src/formats/ansi_v2.rs

@@ -777,7 +777,7 @@ impl StringGeneratorV2 {
     fn generate_cells<T: TextPane>(&self, buf: &TextBuffer, layer: &T, area: Rectangle, font_map: &HashMap<u8, u8>) -> (AnsiState, Vec<Vec<CharCell>>) {
         let mut result: Vec<Vec<CharCell>> = Vec::new();
 
-        let mut state = AnsiState {
+        let default_state = AnsiState {
             is_bold: false,
             is_blink: false,
             is_italic: false,
@@ -792,9 +792,18 @@ impl StringGeneratorV2 {
             bg_idx: 0,
         };
 
+        let mut state = default_state.clone();
+
         for y in area.y_range() {
             let mut line = Vec::new();
 
+            // In UTF-8 mode we emit SGR resets between lines (see `generate()`), so we must
+            // also reset the exporter state between lines. Otherwise the next line may start
+            // without re-emitting attributes (e.g. bold/colors) after an `ESC[0m`.
+            if self.level.supports_utf8() {
+                state = default_state.clone();
+            }
+
             if self.options.longer_terminal_output {
                 if let Some(skip_lines) = &self.options.skip_lines {
                     if skip_lines.contains(&(y as usize)) {
@@ -961,9 +970,14 @@ impl StringGeneratorV2 {
                         continue;
                     }
                 }
+                // In longer-terminal-output mode we position each line explicitly.
+                // For UTF-8 terminal output we also reset SGR for each emitted line to avoid
+                // attribute bleed and to match the per-line state reset in `generate_cells()`.
                 if is_first_output_line {
                     is_first_output_line = false;
                     result.extend_from_slice(b"\x1b[0m");
+                } else if self.level.supports_utf8() {
+                    result.extend_from_slice(b"\x1b[0m");
                 }
                 result.extend_from_slice(b"\x1b[");
                 result.extend_from_slice((y + 1).to_string().as_bytes());