`1018a92`

Reduce cursor flicker by batching terminal writes

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: 1018a92721d8cc22909e4248c4a7e54f4630ef2f
Parents: 88396f7
Tree: 5336455

2 changed files

Status	File	+	-
M	`src/editor/state.rs`	3	0
M	`src/render/screen.rs`	273	286

src/editor/state.rsmodified

+     }
      fn render(&mut self) -> Result<()> {
 +        // Hide cursor at start of render pass to prevent flicker
 +        self.screen.hide_cursor()?;
++
          // Calculate fuss pane width if active
          let fuss_width = if self.workspace.fuss.active {
              self.workspace.fuss.width(self.screen.cols)

src/render/screen.rsmodified

1971 lines changed — click to load

          DisableMouseCapture, EnableMouseCapture,
          KeyboardEnhancementFlags, PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
      },
 -    execute,
 +    execute, queue,
      style::{Attribute, Color, Print, ResetColor, SetAttribute, SetBackgroundColor, SetForegroundColor},
      terminal::{self, Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen},
  };
      /// Position and show the hardware cursor at the given screen coordinates
      pub fn show_cursor_at(&mut self, col: u16, row: u16) -> Result<()> {
 -        execute!(self.stdout, MoveTo(col, row), Show)?;
 +        queue!(self.stdout, MoveTo(col, row), Show)?;
          self.stdout.flush()?;
          Ok(())
+     }
 +    /// Hide the hardware cursor (call at start of render pass)
 +    pub fn hide_cursor(&mut self) -> Result<()> {
 +        queue!(self.stdout, Hide)?;
 +        Ok(())
 +    }
++
      #[allow(dead_code)]
      pub fn clear(&mut self) -> Result<()> {
 -        execute!(self.stdout, Clear(ClearType::All))?;
 +        queue!(self.stdout, Clear(ClearType::All))?;
          Ok(())
+     }
      /// Render the tab bar
      /// Returns the height of the tab bar (always 1)
      pub fn render_tab_bar(&mut self, tabs: &[TabInfo], left_offset: u16) -> Result<u16> {
 -        execute!(self.stdout, MoveTo(left_offset, 0))?;
 +        queue!(self.stdout, MoveTo(left_offset, 0))?;
          // Fill the tab bar background
          let available_width = self.cols.saturating_sub(left_offset) as usize;
 -        execute!(
 +        queue!(
              self.stdout,
              SetBackgroundColor(TAB_BAR_BG),
              SetForegroundColor(TAB_INACTIVE_FG),
                  (TAB_BAR_BG, TAB_INACTIVE_FG)
              };
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(current_col as u16, 0),
                  SetBackgroundColor(bg),
              // Print index number (for Alt+N shortcut hint)
              if !index_str.is_empty() {
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetForegroundColor(LINE_NUM_COLOR),
                      Print(&index_str),
+             }
              // Print tab name
 -            execute!(
 +            queue!(
                  self.stdout,
                  SetForegroundColor(fg),
                  Print(&display_name),
              // Print modified indicator
              if tab.is_modified {
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetForegroundColor(TAB_MODIFIED_FG),
                      Print(modified_str),
              // Add separator between tabs
              if i + 1 < tab_count {
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(TAB_BAR_BG),
                      SetForegroundColor(LINE_NUM_COLOR),
+         }
          // Fill the rest of the line
 -        execute!(
 +        queue!(
              self.stdout,
              SetBackgroundColor(TAB_BAR_BG),
              Clear(ClearType::UntilNewLine),
          left_offset: u16,
          top_offset: u16,
      ) -> Result<()> {
 -        execute!(self.stdout, Hide)?;
+-
          // Calculate available screen area
          let available_width = self.cols.saturating_sub(left_offset) as f32;
          let available_height = self.rows.saturating_sub(2 + top_offset) as f32; // -2 for gap + status bar
                  let sep_x = pane_x.saturating_sub(1);
                  let sep_color = if pane.is_active { PANE_ACTIVE_SEPARATOR_FG } else { PANE_SEPARATOR_FG };
                  for row in 0..pane_height {
 -                    execute!(
 +                    queue!(
                          self.stdout,
                          MoveTo(sep_x, pane_y + row),
                          SetBackgroundColor(BG_COLOR),
                  let sep_y = pane_y.saturating_sub(1);
                  let sep_color = if pane.is_active { PANE_ACTIVE_SEPARATOR_FG } else { PANE_SEPARATOR_FG };
                  for col in 0..pane_width {
 -                    execute!(
 +                    queue!(
                          self.stdout,
                          MoveTo(pane_x + col, sep_y),
                          SetBackgroundColor(BG_COLOR),
          // Render the gap row (empty line between text and status bar)
          let gap_row = top_offset + available_height as u16;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(left_offset, gap_row),
              SetBackgroundColor(BG_COLOR),
              )?;
+         }
 -        // Position hardware cursor
 +        // Position hardware cursor (but don't show - caller handles that)
          if let Some((col, row)) = cursor_screen_pos {
 -            execute!(self.stdout, MoveTo(col, row), Show)?;
 +            queue!(self.stdout, MoveTo(col, row))?;
+         }
 -        self.stdout.flush()?;
          Ok(())
+     }
          for row in 0..height as usize {
              let line_idx = pane.viewport_line + row;
              let is_current_line = line_idx == primary.line;
 -            execute!(self.stdout, MoveTo(x, y + row as u16))?;
 +            queue!(self.stdout, MoveTo(x, y + row as u16))?;
              if line_idx < buffer.line_count() {
                  let line_num_fg = if is_current_line {
                  };
                  let line_bg = if is_current_line { current_line_bg } else { bg_color };
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(line_bg),
                      SetForegroundColor(line_num_fg),
                      } else {
                          // Inactive pane: simple dimmed text
                          let chars: String = line.chars().take(text_cols).collect();
 -                        execute!(
 +                        queue!(
                              self.stdout,
                              SetBackgroundColor(line_bg),
                              SetForegroundColor(text_color),
+                 }
                  // Fill rest of pane width
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(line_bg),
                  )?;
                  let current_col = x + line_num_width as u16 + 1 + text_cols.min(line_len) as u16;
                  let remaining = (x + width).saturating_sub(current_col);
                  if remaining > 0 {
 -                    execute!(self.stdout, Print(" ".repeat(remaining as usize)))?;
 +                    queue!(self.stdout, Print(" ".repeat(remaining as usize)))?;
+                 }
 -                execute!(self.stdout, ResetColor)?;
 +                queue!(self.stdout, ResetColor)?;
              } else {
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(bg_color),
                      SetForegroundColor(if is_active { Color::DarkBlue } else { INACTIVE_LINE_NUM_COLOR }),
                  )?;
                  // Fill rest of line within pane bounds
                  let remaining = width.saturating_sub(line_num_width as u16 + 1);
 -                execute!(self.stdout, Print(" ".repeat(remaining as usize)), ResetColor)?;
 +                queue!(self.stdout, Print(" ".repeat(remaining as usize)), ResetColor)?;
+             }
+         }
          message: Option<&str>,
          bracket_match: Option<(usize, usize)>,
      ) -> Result<()> {
 -        // Hide cursor during render to prevent flicker
 -        execute!(self.stdout, Hide)?;
+-
          let line_num_width = self.line_number_width(buffer.line_count());
          let text_cols = self.cols as usize - line_num_width - 1;
          for row in 0..text_rows {
              let line_idx = viewport_line + row;
              let is_current_line = line_idx == primary.line;
 -            execute!(self.stdout, MoveTo(0, row as u16))?;
 +            queue!(self.stdout, MoveTo(0, row as u16))?;
              if line_idx < buffer.line_count() {
                  // Line number with appropriate color
                  };
                  let line_bg = if is_current_line { CURRENT_LINE_BG } else { BG_COLOR };
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(line_bg),
                      SetForegroundColor(line_num_fg),
+                 }
                  // Fill rest of line with background color
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(line_bg),
                      Clear(ClearType::UntilNewLine),
                  )?;
              } else {
                  // Empty line indicator
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(BG_COLOR),
                      SetForegroundColor(Color::DarkBlue),
          // Render the gap row (empty line between text and status bar)
          let gap_row = text_rows as u16;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(0, gap_row),
              SetBackgroundColor(BG_COLOR),
          // Status bar
          self.render_status_bar(buffer, cursors, filename, message)?;
 -        // Position hardware cursor at primary cursor
 +        // Position hardware cursor at primary cursor (but don't show - caller handles that)
          let cursor_row = primary.line.saturating_sub(viewport_line);
          let cursor_col = line_num_width + 1 + primary.col;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(cursor_col as u16, cursor_row as u16),
 -            Show
          )?;
 -        self.stdout.flush()?;
          Ok(())
+     }
              // Apply styling
              if bold {
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(bg),
                      SetForegroundColor(fg),
                      SetAttribute(Attribute::NoBold),
                  )?;
              } else {
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(bg),
                      SetForegroundColor(fg),
+         }
          // Reset to line background for rest of line
 -        execute!(self.stdout, SetBackgroundColor(line_bg), SetForegroundColor(default_fg))?;
 +        queue!(self.stdout, SetBackgroundColor(line_bg), SetForegroundColor(default_fg))?;
          // Handle secondary cursors at end of line (past text content)
          let max_cursor_past_text = secondary_cursors.iter()
              if max_cursor < max_cols {
                  for col in char_count..=max_cursor {
                      if secondary_cursors.contains(&col) {
 -                        execute!(
 +                        queue!(
                              self.stdout,
                              SetBackgroundColor(Color::Magenta),
                              SetForegroundColor(Color::White),
                              Print(" ")
                          )?;
                      } else {
 -                        execute!(
 +                        queue!(
                              self.stdout,
                              SetBackgroundColor(line_bg),
                              Print(" ")
                          )?;
+                     }
+                 }
 -                execute!(self.stdout, SetBackgroundColor(line_bg), SetForegroundColor(default_fg))?;
 +                queue!(self.stdout, SetBackgroundColor(line_bg), SetForegroundColor(default_fg))?;
+             }
+         }
          message: Option<&str>,
      ) -> Result<()> {
          let status_row = self.rows.saturating_sub(1);
 -        execute!(self.stdout, MoveTo(0, status_row))?;
 +        queue!(self.stdout, MoveTo(0, status_row))?;
          // Status bar background
 -        execute!(
 +        queue!(
              self.stdout,
              SetBackgroundColor(Color::DarkGrey),
              SetForegroundColor(Color::White)
          let padding = (self.cols as usize).saturating_sub(left.len() + right.len());
          let middle = " ".repeat(padding);
 -        execute!(
 +        queue!(
              self.stdout,
              Print(&left),
              Print(&middle),
          let tree_rows = text_rows.saturating_sub(hint_rows + header_rows);
          // Draw header: repo_name:branch
 -        execute!(self.stdout, MoveTo(0, 0))?;
 +        queue!(self.stdout, MoveTo(0, 0))?;
          let header_text = if let Some(b) = branch {
              format!("{}:{}", repo_name, b)
          } else {
          let padded = format!("{:<width$}", truncated, width = width);
          // Render header with cyan repo name, yellow branch
 -        execute!(
 +        queue!(
              self.stdout,
              SetBackgroundColor(BG_COLOR),
              SetForegroundColor(Color::Cyan),
          )?;
          if let Some(b) = branch {
              let repo_display: String = repo_name.chars().take(width.saturating_sub(1)).collect();
 -            execute!(self.stdout, Print(&repo_display))?;
 -            execute!(
 +            queue!(self.stdout, Print(&repo_display))?;
 +            queue!(
                  self.stdout,
                  SetForegroundColor(Color::DarkGrey),
                  Print(":"),
              let remaining = width.saturating_sub(repo_display.len() + 1);
              let branch_display: String = b.chars().take(remaining).collect();
              let branch_padded = format!("{:<width$}", branch_display, width = remaining);
 -            execute!(self.stdout, Print(&branch_padded))?;
 +            queue!(self.stdout, Print(&branch_padded))?;
          } else {
 -            execute!(self.stdout, Print(&padded))?;
 +            queue!(self.stdout, Print(&padded))?;
+         }
 -        execute!(self.stdout, ResetColor)?;
 +        queue!(self.stdout, ResetColor)?;
          // Draw separator
 -        execute!(self.stdout, MoveTo(0, 1))?;
 +        queue!(self.stdout, MoveTo(0, 1))?;
          let separator = "─".repeat(width);
 -        execute!(
 +        queue!(
              self.stdout,
              SetBackgroundColor(BG_COLOR),
              SetForegroundColor(Color::DarkGrey),
          // Draw git mode indicator line
          if git_mode {
              let git_row = 2u16;
 -            execute!(self.stdout, MoveTo(0, git_row))?;
 +            queue!(self.stdout, MoveTo(0, git_row))?;
              let git_hint = "Git: a/u/d/m/p/l/f/t";
              let padded = format!("{:<width$}", git_hint, width = width);
 -            execute!(
 +            queue!(
                  self.stdout,
                  SetBackgroundColor(Color::AnsiValue(235)),
                  SetForegroundColor(Color::Yellow),
          // Draw file tree (starting after header)
          for row in 0..tree_rows {
              let screen_row = (row + header_rows) as u16;
 -            execute!(self.stdout, MoveTo(0, screen_row))?;
 +            queue!(self.stdout, MoveTo(0, screen_row))?;
              let item_idx = scroll + row;
              if item_idx < items.len() {
                      // Highlight selected - need to handle git indicator specially
                      let padded_len = width.saturating_sub(indicator_display_len);
                      let padded = format!("{:<width$}", display_base, width = padded_len);
 -                    execute!(
 +                    queue!(
                          self.stdout,
                          SetBackgroundColor(Color::DarkGrey),
                          SetForegroundColor(Color::White),
                      if !git_indicator.is_empty() {
                          // Git indicator with selection background
                          if item.git_status.staged {
 -                            execute!(self.stdout, SetForegroundColor(Color::Green), Print(" ↑"))?;
 +                            queue!(self.stdout, SetForegroundColor(Color::Green), Print(" ↑"))?;
                          } else if item.git_status.unstaged {
 -                            execute!(self.stdout, SetForegroundColor(Color::Red), Print(" ✗"))?;
 +                            queue!(self.stdout, SetForegroundColor(Color::Red), Print(" ✗"))?;
                          } else if item.git_status.untracked {
 -                            execute!(self.stdout, SetForegroundColor(Color::DarkGrey), Print(" ?"))?;
 +                            queue!(self.stdout, SetForegroundColor(Color::DarkGrey), Print(" ?"))?;
                          } else if item.git_status.incoming {
 -                            execute!(self.stdout, SetForegroundColor(Color::Blue), Print(" ↓"))?;
 +                            queue!(self.stdout, SetForegroundColor(Color::Blue), Print(" ↓"))?;
+                         }
+                     }
 -                    execute!(self.stdout, ResetColor)?;
 +                    queue!(self.stdout, ResetColor)?;
                  } else if item.is_dir {
                      // Directories in blue
                      let padded_len = width.saturating_sub(indicator_display_len);
                      let padded = format!("{:<width$}", display_base, width = padded_len);
 -                    execute!(
 +                    queue!(
                          self.stdout,
                          SetBackgroundColor(BG_COLOR),
                          SetForegroundColor(Color::Blue),
                  } else if item.git_status.gitignored {
                      // Gitignored files in dark gray
                      let padded = format!("{:<width$}", display_base, width = width);
 -                    execute!(
 +                    queue!(
                          self.stdout,
                          SetBackgroundColor(BG_COLOR),
                          SetForegroundColor(Color::DarkGrey),
                      // Files in default color with git status
                      let padded_len = width.saturating_sub(indicator_display_len);
                      let padded = format!("{:<width$}", display_base, width = padded_len);
 -                    execute!(
 +                    queue!(
                          self.stdout,
                          SetBackgroundColor(BG_COLOR),
                          SetForegroundColor(Color::Reset),
                      )?;
                      // Add git status indicator
                      if item.git_status.staged {
 -                        execute!(self.stdout, SetForegroundColor(Color::Green), Print(" ↑"))?;
 +                        queue!(self.stdout, SetForegroundColor(Color::Green), Print(" ↑"))?;
                      } else if item.git_status.unstaged {
 -                        execute!(self.stdout, SetForegroundColor(Color::Red), Print(" ✗"))?;
 +                        queue!(self.stdout, SetForegroundColor(Color::Red), Print(" ✗"))?;
                      } else if item.git_status.untracked {
 -                        execute!(self.stdout, SetForegroundColor(Color::DarkGrey), Print(" ?"))?;
 +                        queue!(self.stdout, SetForegroundColor(Color::DarkGrey), Print(" ?"))?;
                      } else if item.git_status.incoming {
 -                        execute!(self.stdout, SetForegroundColor(Color::Blue), Print(" ↓"))?;
 +                        queue!(self.stdout, SetForegroundColor(Color::Blue), Print(" ↓"))?;
+                     }
 -                    execute!(self.stdout, ResetColor)?;
 +                    queue!(self.stdout, ResetColor)?;
+                 }
              } else {
                  // Empty row
                  let empty = " ".repeat(width);
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(BG_COLOR),
                      Print(&empty),
              ];
              for (i, hint) in hints.iter().enumerate() {
                  if hint_start + i < text_rows {
 -                    execute!(self.stdout, MoveTo(0, (hint_start + i) as u16))?;
 +                    queue!(self.stdout, MoveTo(0, (hint_start + i) as u16))?;
                      let padded = format!("{:<width$}", hint, width = width);
 -                    execute!(
 +                    queue!(
                          self.stdout,
                          SetBackgroundColor(BG_COLOR),
                          SetForegroundColor(Color::DarkGrey),
+             }
          } else {
              if hint_start < text_rows {
 -                execute!(self.stdout, MoveTo(0, hint_start as u16))?;
 +                queue!(self.stdout, MoveTo(0, hint_start as u16))?;
                  let hint = "ctrl-/:hints";
                  let padded = format!("{:<width$}", hint, width = width);
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(BG_COLOR),
                      SetForegroundColor(Color::DarkGrey),
          // Fill the status bar row for fuss mode column (prevents terminal bleed-through)
          let status_row = self.rows.saturating_sub(1);
 -        execute!(self.stdout, MoveTo(0, status_row))?;
 +        queue!(self.stdout, MoveTo(0, status_row))?;
          let status_fill = " ".repeat(width);
 -        execute!(
 +        queue!(
              self.stdout,
              SetBackgroundColor(BG_COLOR),
              Print(&status_fill),
          top_offset: u16,
          is_modified: bool,
      ) -> Result<()> {
 -        // Hide cursor during render to prevent flicker
 -        execute!(self.stdout, Hide)?;
+-
          let available_cols = self.cols.saturating_sub(left_offset) as usize;
          let line_num_width = self.line_number_width(buffer.line_count());
          let text_cols = available_cols.saturating_sub(line_num_width + 1);
          for row in 0..text_rows {
              let line_idx = viewport_line + row;
              let is_current_line = line_idx == primary.line;
 -            execute!(self.stdout, MoveTo(left_offset, (row as u16) + top_offset))?;
 +            queue!(self.stdout, MoveTo(left_offset, (row as u16) + top_offset))?;
              if line_idx < buffer.line_count() {
                  let line_num_fg = if is_current_line {
                  };
                  let line_bg = if is_current_line { CURRENT_LINE_BG } else { BG_COLOR };
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(line_bg),
                      SetForegroundColor(line_num_fg),
                      )?;
+                 }
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(line_bg),
                      Clear(ClearType::UntilNewLine),
                      ResetColor
                  )?;
              } else {
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(BG_COLOR),
                      SetForegroundColor(Color::DarkBlue),
          // Render the gap row (empty line between text and status bar)
          let gap_row = text_rows as u16 + top_offset;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(left_offset, gap_row),
              SetBackgroundColor(BG_COLOR),
          // Status bar
          self.render_status_bar_with_offset(cursors, filename, message, left_offset, is_modified)?;
 -        // Position hardware cursor at primary cursor
 +        // Position hardware cursor at primary cursor (but don't show - caller handles that)
          let cursor_row = (primary.line.saturating_sub(viewport_line) as u16) + top_offset;
          let cursor_col = left_offset as usize + line_num_width + 1 + primary.col;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(cursor_col as u16, cursor_row),
 -            Show
          )?;
 -        self.stdout.flush()?;
          Ok(())
+     }
          highlighter: &mut Highlighter,
          ghost_text: Option<&str>,
      ) -> Result<()> {
 -        execute!(self.stdout, Hide)?;
+-
          let available_cols = self.cols.saturating_sub(left_offset) as usize;
          let line_num_width = self.line_number_width(buffer.line_count());
          let text_cols = available_cols.saturating_sub(line_num_width + 1);
          for row in 0..text_rows {
              let line_idx = viewport_line + row;
              let is_current_line = line_idx == primary.line;
 -            execute!(self.stdout, MoveTo(left_offset, (row as u16) + top_offset))?;
 +            queue!(self.stdout, MoveTo(left_offset, (row as u16) + top_offset))?;
              if line_idx < buffer.line_count() {
                  let line_num_fg = if is_current_line {
                  };
                  let line_bg = if is_current_line { CURRENT_LINE_BG } else { BG_COLOR };
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(line_bg),
                      SetForegroundColor(line_num_fg),
                              if remaining_cols > 0 {
                                  // Truncate ghost text if it doesn't fit
                                  let ghost_display: String = ghost.chars().take(remaining_cols).collect();
 -                                execute!(
 +                                queue!(
                                      self.stdout,
                                      SetBackgroundColor(line_bg),
                                      SetForegroundColor(Color::AnsiValue(240)), // Dim gray
+                     }
+                 }
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(line_bg),
                      Clear(ClearType::UntilNewLine),
                      ResetColor
                  )?;
              } else {
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(BG_COLOR),
                      SetForegroundColor(Color::DarkBlue),
          // Render the gap row (empty line between text and status bar)
          let gap_row = text_rows as u16 + top_offset;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(left_offset, gap_row),
              SetBackgroundColor(BG_COLOR),
          // Status bar
          self.render_status_bar_with_offset(cursors, filename, message, left_offset, is_modified)?;
 -        // Position hardware cursor (adjusted for horizontal scroll)
 +        // Position hardware cursor (adjusted for horizontal scroll, but don't show - caller handles that)
          let cursor_row = (primary.line.saturating_sub(viewport_line) as u16) + top_offset;
          let cursor_col = left_offset as usize + line_num_width + 1 + primary.col.saturating_sub(viewport_col);
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(cursor_col as u16, cursor_row),
 -            Show
          )?;
 -        self.stdout.flush()?;
          Ok(())
+     }
      ) -> Result<()> {
          let status_row = self.rows.saturating_sub(1);
          let available_cols = self.cols.saturating_sub(offset) as usize;
 -        execute!(self.stdout, MoveTo(offset, status_row))?;
 +        queue!(self.stdout, MoveTo(offset, status_row))?;
 -        execute!(
 +        queue!(
              self.stdout,
              SetBackgroundColor(Color::DarkGrey),
              SetForegroundColor(Color::White)
          let padding = available_cols.saturating_sub(left.len() + right.len());
          let middle = " ".repeat(padding);
 -        execute!(
 +        queue!(
              self.stdout,
              Print(&left),
              Print(&middle),
          items: &[(String, String, bool, bool)], // (label, path, is_selected, is_current_dir)
          scroll: usize,
      ) -> Result<()> {
 -        execute!(self.stdout, Hide)?;
 +        queue!(self.stdout, Hide)?;
          let cols = self.cols as usize;
          let rows = self.rows as usize;
          // Fill background
          for row in 0..rows {
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(0, row as u16),
                  SetBackgroundColor(BG_COLOR),
          let top_border = format!("╭{}╮", "─".repeat(box_width.saturating_sub(2)));
          let bottom_border = format!("╰{}╯", "─".repeat(box_width.saturating_sub(2)));
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(box_x as u16, box_y as u16),
              SetBackgroundColor(BG_COLOR),
          let title = "Welcome to fackr";
          let title_row = box_y + 1;
          let title_x = box_x + (box_width.saturating_sub(title.len())) / 2;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(box_x as u16, title_row as u16),
              SetForegroundColor(Color::DarkGrey),
          )?;
          let padding_left = title_x.saturating_sub(box_x + 1);
          let padding_right = box_width.saturating_sub(2).saturating_sub(padding_left + title.len());
 -        execute!(
 +        queue!(
              self.stdout,
              Print(&" ".repeat(padding_left)),
              Print(title),
          // Subtitle
          let subtitle = "Select a workspace:";
          let subtitle_row = box_y + 2;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(box_x as u16, subtitle_row as u16),
              SetForegroundColor(Color::DarkGrey),
          )?;
          let padding_left = (box_width.saturating_sub(2).saturating_sub(subtitle.len())) / 2;
          let padding_right = box_width.saturating_sub(2).saturating_sub(padding_left + subtitle.len());
 -        execute!(
 +        queue!(
              self.stdout,
              Print(&" ".repeat(padding_left)),
              Print(subtitle),
          // Separator
          let separator_row = box_y + 3;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(box_x as u16, separator_row as u16),
              SetForegroundColor(Color::DarkGrey),
              let row = list_start_row + i;
              let item_idx = scroll + i;
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(box_x as u16, row as u16),
                  SetForegroundColor(Color::DarkGrey),
                  let padded = format!("{:<width$}", display_label, width = inner_width);
                  if *is_selected {
 -                    execute!(
 +                    queue!(
                          self.stdout,
                          SetBackgroundColor(Color::DarkGrey),
                          SetForegroundColor(Color::White),
                          SetBackgroundColor(BG_COLOR),
                      )?;
                  } else if *is_current_dir {
 -                    execute!(
 +                    queue!(
                          self.stdout,
                          SetForegroundColor(Color::Cyan),
                          Print(&padded),
                      )?;
                  } else {
 -                    execute!(
 +                    queue!(
                          self.stdout,
                          SetForegroundColor(Color::Reset),
                          Print(&padded),
                      // Clear and show path below
+                 }
              } else {
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetForegroundColor(Color::Reset),
                      Print(&" ".repeat(inner_width)),
                  )?;
+             }
 -            execute!(
 +            queue!(
                  self.stdout,
                  SetForegroundColor(Color::DarkGrey),
                  Print(" │"),
          // Path display row (show selected path)
          let path_row = list_start_row + list_height;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(box_x as u16, path_row as u16),
              SetForegroundColor(Color::DarkGrey),
          // Show selected path
          let selected_item = items.iter().find(|(_, _, sel, _)| *sel);
          let path_display_row = path_row + 1;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(box_x as u16, path_display_row as u16),
              SetForegroundColor(Color::DarkGrey),
          if let Some((_, path, _, _)) = selected_item {
              let truncated_path: String = path.chars().take(inner_width).collect();
              let padded_path = format!("{:<width$}", truncated_path, width = inner_width);
 -            execute!(
 +            queue!(
                  self.stdout,
                  SetForegroundColor(Color::AnsiValue(240)),
                  Print(&padded_path),
              )?;
          } else {
 -            execute!(
 +            queue!(
                  self.stdout,
                  Print(&" ".repeat(inner_width)),
              )?;
+         }
 -        execute!(
 +        queue!(
              self.stdout,
              SetForegroundColor(Color::DarkGrey),
              Print(" │"),
          // Bottom border
          let bottom_row = path_display_row + 1;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(box_x as u16, bottom_row as u16),
              SetForegroundColor(Color::DarkGrey),
          let hint_row = bottom_row + 1;
          let hints = "↑/↓: navigate  Enter: select  ESC: quit";
          let hints_x = (cols.saturating_sub(hints.len())) / 2;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(hints_x as u16, hint_row as u16),
              SetForegroundColor(Color::AnsiValue(240)),
              let is_selected = i + scroll_offset == selected_index;
              let bg = if is_selected { selected_bg } else { popup_bg };
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(popup_col, row),
                  SetBackgroundColor(bg),
              write!(self.stdout, "{:<width$}", truncated_label, width = label_width - detail.len().min(15))?;
              if !detail.is_empty() {
 -                execute!(self.stdout, SetForegroundColor(detail_fg))?;
 +                queue!(self.stdout, SetForegroundColor(detail_fg))?;
                  let truncated_detail: String = if detail.len() > 12 {
                      format!("{}...", &detail[..9])
                  } else {
+             }
              // Clear to popup width
 -            execute!(self.stdout, ResetColor)?;
 +            queue!(self.stdout, ResetColor)?;
+         }
          // Show scroll indicator if needed
          if completions.len() > max_items {
              let indicator_row = popup_row + max_items as u16;
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(popup_col, indicator_row),
                  SetBackgroundColor(popup_bg),
                  };
                  // Draw indicator at the start of the line (before line number)
 -                execute!(
 +                queue!(
                      self.stdout,
                      MoveTo(left_offset, row),
                      SetForegroundColor(color),
              let row = popup_row + i as u16;
              // Background and border
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(popup_col, row),
                  SetBackgroundColor(Color::AnsiValue(238)),
                  format!(" {:width$} ", line, width = popup_width)
              };
 -            execute!(self.stdout, Print(&display_line), ResetColor)?;
 +            queue!(self.stdout, Print(&display_line), ResetColor)?;
+         }
          // Show indicator if content is truncated
          if lines.len() > popup_height {
              let row = popup_row + popup_height as u16;
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(popup_col, row),
                  SetBackgroundColor(Color::AnsiValue(238)),
          let input_bg = Color::AnsiValue(238);
          // Draw top border
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row as u16),
              SetBackgroundColor(bg),
          // Draw title row
          let title_padding = (modal_width - 2 - title.len()) / 2;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row as u16 + 1),
              SetBackgroundColor(bg),
          )?;
          // Draw separator
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row as u16 + 2),
              SetBackgroundColor(bg),
          )?;
          // Draw "From:" row
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row as u16 + 3),
              SetBackgroundColor(bg),
          // Draw "To:" row with input field
          let input_width = modal_width - 4 - to_label.len();
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row as u16 + 4),
              SetBackgroundColor(bg),
          )?;
          // Draw bottom border
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row as u16 + 5),
              SetBackgroundColor(bg),
          // Position cursor in the input field
          let cursor_col = start_col + 2 + to_label.len() + new_name.len();
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(cursor_col as u16, start_row as u16 + 4),
              SetBackgroundColor(input_bg),
              crossterm::cursor::Show,
          )?;
 +        self.stdout.flush()?;
          Ok(())
+     }
          let status_row = self.rows.saturating_sub(1);
          let available_cols = (self.cols.saturating_sub(left_offset)) as usize;
 -        execute!(self.stdout, MoveTo(left_offset, status_row))?;
 +        queue!(self.stdout, MoveTo(left_offset, status_row))?;
          // Colors
          let bg = Color::DarkGrey;
          let input_width = input_width.max(10).min(40);
          // Start with background
 -        execute!(self.stdout, SetBackgroundColor(bg))?;
 +        queue!(self.stdout, SetBackgroundColor(bg))?;
          // Find label and input
          let find_bg = if active_field { active_bg } else { inactive_bg };
          let find_label_color = if active_field { active_label } else { label_color };
 -        execute!(
 +        queue!(
              self.stdout,
              SetForegroundColor(find_label_color),
              Print(find_label),
          } else {
              format!("{:<width$}", find_query, width = input_width)
          };
 -        execute!(self.stdout, Print(&find_display))?;
 +        queue!(self.stdout, Print(&find_display))?;
          // Replace label and input
          let replace_bg = if !active_field { active_bg } else { inactive_bg };
          let replace_label_color = if !active_field { active_label } else { label_color };
 -        execute!(
 +        queue!(
              self.stdout,
              SetBackgroundColor(bg),
              SetForegroundColor(replace_label_color),
          } else {
              format!("{:<width$}", replace_text, width = input_width)
          };
 -        execute!(self.stdout, Print(&replace_display))?;
 +        queue!(self.stdout, Print(&replace_display))?;
          // Toggle buttons
 -        execute!(self.stdout, SetBackgroundColor(bg))?;
 +        queue!(self.stdout, SetBackgroundColor(bg))?;
          // Regex toggle [.*]
          let regex_color = if regex_mode { toggle_on } else { toggle_off };
 -        execute!(
 +        queue!(
              self.stdout,
              Print(" "),
              SetForegroundColor(regex_color),
          // Case sensitivity toggle [Aa]
          let case_color = if case_insensitive { toggle_on } else { toggle_off };
 -        execute!(
 +        queue!(
              self.stdout,
              Print(" "),
              SetForegroundColor(case_color),
          )?;
          // Match count
 -        execute!(self.stdout, SetForegroundColor(label_color))?;
 +        queue!(self.stdout, SetForegroundColor(label_color))?;
          if match_count > 0 {
 -            execute!(
 +            queue!(
                  self.stdout,
                  Print(format!(" {}/{}", current_match + 1, match_count)),
              )?;
          } else if !find_query.is_empty() {
 -            execute!(self.stdout, Print(" No matches"))?;
 +            queue!(self.stdout, Print(" No matches"))?;
+         }
          // Fill remaining space
              else if !find_query.is_empty() { 11 }
              else { 0 };
          let remaining = available_cols.saturating_sub(used);
 -        execute!(
 +        queue!(
              self.stdout,
              Print(" ".repeat(remaining)),
              ResetColor,
          } else {
              left_offset as usize + find_label.len() + input_width + replace_label.len() + replace_text.len().min(input_width)
          };
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(cursor_col as u16, status_row),
              crossterm::cursor::Show,
          )?;
 +        self.stdout.flush()?;
          Ok(())
+     }
              path_str.to_string()
          };
          let title = format!(" {} ", display_path);
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row as u16),
              SetBackgroundColor(bg),
          )?;
          // Draw filter input row
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, (start_row + 1) as u16),
              SetBackgroundColor(bg),
          )?;
          // Draw separator
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, (start_row + 2) as u16),
              SetBackgroundColor(bg),
                  name.clone()
              };
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(start_col as u16, row),
                  SetBackgroundColor(item_bg),
          let items_drawn = filtered.len().saturating_sub(scroll).min(visible_rows);
          for i in items_drawn..visible_rows {
              let row = (start_row + 3 + i) as u16;
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(start_col as u16, row),
                  SetBackgroundColor(bg),
          // Draw help text row
          let help_row = (start_row + 3 + visible_rows) as u16;
          let help_text = "←:up  →/Enter:open  ↑↓:nav  Esc:close";
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, help_row),
              SetBackgroundColor(bg),
          )?;
          // Draw bottom border
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, help_row + 1),
              SetBackgroundColor(bg),
          )?;
          // Hide cursor when in fortress modal
 -        execute!(self.stdout, Hide)?;
 +        queue!(self.stdout, Hide)?;
          self.stdout.flush()?;
          Ok(())
          // Draw top border with title
          let title = " Search in Files (F4) ";
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row as u16),
              SetBackgroundColor(bg),
              "Type query, press Enter"
          };
          let input_width = modal_width.saturating_sub(14 + status.len());
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, (start_row + 1) as u16),
              SetBackgroundColor(bg),
          } else {
              format!(" {} results ", results.len())
          };
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, (start_row + 2) as u16),
              SetBackgroundColor(bg),
                  content.clone()
              };
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(start_col as u16, row),
                  SetBackgroundColor(item_bg),
              // Calculate remaining width and print content with padding
              let used = display_path.len() + 1 + line_str.len() + 2 + 2;
              let remaining = modal_width.saturating_sub(used + 2);
 -            execute!(
 +            queue!(
                  self.stdout,
                  Print(format!("{:<width$}", display_content, width = remaining)),
                  SetForegroundColor(border_color),
          let items_drawn = results.len().saturating_sub(scroll).min(visible_rows);
          for i in items_drawn..visible_rows {
              let row = (start_row + 3 + i) as u16;
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(start_col as u16, row),
                  SetBackgroundColor(bg),
          // Draw help text row
          let help_row = (start_row + 3 + visible_rows) as u16;
          let help_text = "Enter:search/open  ↑↓:nav  PgUp/Dn:scroll  Esc:close";
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, help_row),
              SetBackgroundColor(bg),
          )?;
          // Draw bottom border
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, help_row + 1),
              SetBackgroundColor(bg),
          )?;
          // Hide cursor when in modal
 -        execute!(self.stdout, Hide)?;
 +        queue!(self.stdout, Hide)?;
          self.stdout.flush()?;
          Ok(())
          let prompt_color = Color::Yellow;
          // Draw top border with subtle styling
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row as u16),
              SetBackgroundColor(bg),
          // Draw search input row with > prefix
          let display_query = if query.is_empty() { "" } else { query };
          let input_display_width = modal_width.saturating_sub(6);
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, (start_row + 1) as u16),
              SetBackgroundColor(bg),
          )?;
          // Draw separator
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, (start_row + 2) as u16),
              SetBackgroundColor(bg),
                  name.clone()
              };
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(start_col as u16, row),
                  SetBackgroundColor(item_bg),
              // Print name with padding
              let name_padding = name_width.saturating_sub(display_name.len());
 -            execute!(
 +            queue!(
                  self.stdout,
                  Print(&display_name),
                  Print(format!("{:width$}", "", width = name_padding)),
          let items_drawn = commands.len().saturating_sub(scroll).min(visible_rows);
          for i in items_drawn..visible_rows {
              let row = (start_row + 3 + i) as u16;
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(start_col as u16, row),
                  SetBackgroundColor(bg),
          } else {
              format!("{} commands", commands.len())
          };
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, help_row),
              SetBackgroundColor(bg),
          )?;
          // Draw bottom border
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, help_row + 1),
              SetBackgroundColor(bg),
          )?;
          // Show help in lighter text at bottom
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, help_row + 2),
              SetForegroundColor(Color::AnsiValue(243)),
          )?;
          // Hide cursor when in modal
 -        execute!(self.stdout, Hide)?;
 +        queue!(self.stdout, Hide)?;
          self.stdout.flush()?;
          Ok(())
          // Draw top border with title (show indicator when viewing alternates)
          let title = if show_alt { " Keybindings [/] " } else { " Keybindings " };
          let title_padding = (modal_width.saturating_sub(title.len() + 2)) / 2;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row as u16),
              SetBackgroundColor(bg),
          let display_query = if query.is_empty() { "Type to filter..." } else { query };
          let input_display_width = modal_width.saturating_sub(5);
          let placeholder_color = if query.is_empty() { Color::AnsiValue(243) } else { Color::White };
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, (start_row + 1) as u16),
              SetBackgroundColor(bg),
          )?;
          // Draw separator
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, (start_row + 2) as u16),
              SetBackgroundColor(bg),
                  shortcut.clone()
              };
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(start_col as u16, row),
                  SetBackgroundColor(item_bg),
          // Fill remaining rows
          for i in row_offset..visible_rows {
              let row = (start_row + 3 + i) as u16;
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(start_col as u16, row),
                  SetBackgroundColor(bg),
          } else {
              format!("{} keybinds", keybinds.len())
          };
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, info_row),
              SetBackgroundColor(bg),
          )?;
          // Draw bottom border
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, info_row + 1),
              SetBackgroundColor(bg),
          } else {
              "↑↓:scroll  PgUp/PgDn:page  Home/End:jump  /:alt binds  Esc:close"
          };
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, info_row + 2),
              SetForegroundColor(Color::AnsiValue(243)),
          )?;
          // Hide cursor when in modal
 -        execute!(self.stdout, Hide)?;
 +        queue!(self.stdout, Hide)?;
          self.stdout.flush()?;
          Ok(())
          // Draw top border with title
          let title = format!(" References ({}) ", filtered.len());
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row),
              SetBackgroundColor(bg),
          )?;
          // Draw filter input row
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 1),
              SetBackgroundColor(bg),
          )?;
          // Draw separator
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 2),
              SetBackgroundColor(bg),
              // The remaining padding goes after line_info
              let remaining = panel_width.saturating_sub(max_path_width + line_info.len() + 4);
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(start_col as u16, row),
                  SetBackgroundColor(item_bg),
          let items_drawn = filtered.len().saturating_sub(scroll_offset).min(visible_rows);
          for i in items_drawn..visible_rows {
              let row = start_row + 3 + i as u16;
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(start_col as u16, row),
                  SetBackgroundColor(bg),
          // Draw help text row
          let help_row = start_row + 3 + visible_rows as u16;
          let help_text = "↑↓:nav  Enter:go  Esc:close";
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, help_row),
              SetBackgroundColor(bg),
          )?;
          // Draw bottom border
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, help_row + 1),
              SetBackgroundColor(bg),
          )?;
          // Hide cursor when in references panel
 -        execute!(self.stdout, Hide)?;
 +        queue!(self.stdout, Hide)?;
          self.stdout.flush()?;
          Ok(())
+         }
          // Top border
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row),
              SetForegroundColor(Color::Cyan),
          )?;
          // Header
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 1),
              SetForegroundColor(Color::Cyan),
          )?;
          let header_len = 25;
          let padding = panel_width - header_len - 7;
 -        execute!(
 +        queue!(
              self.stdout,
              Print(" ".repeat(padding)),
              Print("Alt+M"),
          )?;
          // Header separator
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 2),
              SetForegroundColor(Color::Cyan),
              let row = start_row + 3 + i as u16;
              let is_selected = idx == panel.selected_index;
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(start_col as u16, row),
                  SetForegroundColor(Color::Cyan),
              // Highlight selected row
              if is_selected {
 -                execute!(self.stdout, SetAttribute(Attribute::Reverse))?;
 +                queue!(self.stdout, SetAttribute(Attribute::Reverse))?;
+             }
              // Status icon
 -            execute!(self.stdout, Print(" "))?;
 +            queue!(self.stdout, Print(" "))?;
              if server.is_installed {
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetForegroundColor(Color::Green),
                      Print("✓"),
                  )?;
              } else {
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetForegroundColor(Color::Red),
                      Print("✗"),
                  format!(" {} ({})", server.name, server.language)
              };
              let name_len = name_lang.len().min(panel_width - 20);
 -            execute!(
 +            queue!(
                  self.stdout,
                  SetForegroundColor(if is_installing { Color::Yellow } else { Color::White }),
                  Print(&name_lang[..name_len]),
              let used = 1 + 1 + name_len + status.len() + 1;
              let content_width = panel_width - 2;
              let status_padding = content_width.saturating_sub(used);
 -            execute!(self.stdout, Print(" ".repeat(status_padding)))?;
 +            queue!(self.stdout, Print(" ".repeat(status_padding)))?;
              if server.is_installed {
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetForegroundColor(Color::DarkGrey),
                      Print(status),
                  )?;
              } else {
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetForegroundColor(Color::Yellow),
                      Print(status),
+             }
              if is_selected {
 -                execute!(self.stdout, SetAttribute(Attribute::Reset))?;
 +                queue!(self.stdout, SetAttribute(Attribute::Reset))?;
+             }
 -            execute!(
 +            queue!(
                  self.stdout,
                  Print(" "),
                  SetForegroundColor(Color::Cyan),
          // Fill remaining rows
          for i in (visible_end - panel.scroll_offset)..max_visible {
              let row = start_row + 3 + i as u16;
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(start_col as u16, row),
                  SetForegroundColor(Color::Cyan),
          // Footer separator
          let footer_row = start_row + 3 + max_visible as u16;
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, footer_row),
              SetForegroundColor(Color::Cyan),
          )?;
          // Status or help
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, footer_row + 1),
              SetForegroundColor(Color::Cyan),
                  msg.clone()
              };
              let display_width = msg_display.width();
 -            execute!(
 +            queue!(
                  self.stdout,
                  SetForegroundColor(Color::Yellow),
                  Print(format!(" {}", msg_display)),
              )?;
              // We printed 1 space + msg_display, need to fill to content_width
              let pad = content_width.saturating_sub(1 + display_width);
 -            execute!(self.stdout, Print(" ".repeat(pad)))?;
 +            queue!(self.stdout, Print(" ".repeat(pad)))?;
          } else {
              let help_text = " ↑↓ Navigate  Enter Install  r Refresh  Esc Close ";
              let help_width = help_text.width();
 -            execute!(
 +            queue!(
                  self.stdout,
                  SetForegroundColor(Color::DarkGrey),
                  Print(help_text),
              // Content width is panel_width - 2 (for borders)
              let content_width = panel_width - 2;
              let pad = content_width.saturating_sub(help_width);
 -            execute!(self.stdout, Print(" ".repeat(pad)))?;
 +            queue!(self.stdout, Print(" ".repeat(pad)))?;
+         }
 -        execute!(
 +        queue!(
              self.stdout,
              SetForegroundColor(Color::Cyan),
              Print("│"),
          )?;
          // Bottom border
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, footer_row + 2),
              SetForegroundColor(Color::Cyan),
          };
          // Top border
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row),
              SetForegroundColor(Color::Cyan),
          // Title
          let title = format!(" Install {}? ", server.name);
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 1),
              SetForegroundColor(Color::Cyan),
              SetAttribute(Attribute::Reset),
          )?;
          let pad = panel_width - 2 - title.len();
 -        execute!(
 +        queue!(
              self.stdout,
              Print(" ".repeat(pad)),
              SetForegroundColor(Color::Cyan),
          )?;
          // Blank line
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 2),
              SetForegroundColor(Color::Cyan),
          } else {
              server.install_cmd.to_string()
          };
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 3),
              SetForegroundColor(Color::Cyan),
              Print(&cmd_display),
          )?;
          let pad = panel_width - 12 - cmd_display.len();
 -        execute!(
 +        queue!(
              self.stdout,
              Print(" ".repeat(pad)),
              SetForegroundColor(Color::Cyan),
          )?;
          // Blank line
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 4),
              SetForegroundColor(Color::Cyan),
          )?;
          // Buttons
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 5),
              SetForegroundColor(Color::Cyan),
          )?;
          let button_text = "[Y]es    [N]o";
          let button_pad = (panel_width - 2 - button_text.len()) / 2;
 -        execute!(
 +        queue!(
              self.stdout,
              Print(" ".repeat(button_pad)),
              Print("["),
          )?;
          // Bottom border
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 6),
              SetForegroundColor(Color::Cyan),
          let instructions = server.install_cmd.trim_start_matches('#').trim();
          // Top border
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row),
              SetForegroundColor(Color::Cyan),
          // Title
          let title = format!(" {} - Manual Installation ", server.name);
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 1),
              SetForegroundColor(Color::Cyan),
              SetAttribute(Attribute::Reset),
          )?;
          let pad = panel_width - 2 - title.len();
 -        execute!(
 +        queue!(
              self.stdout,
              Print(" ".repeat(pad)),
              SetForegroundColor(Color::Cyan),
          )?;
          // Separator
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 2),
              SetForegroundColor(Color::Cyan),
          )?;
          // Language
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 3),
              SetForegroundColor(Color::Cyan),
              Print(server.language),
          )?;
          let lang_pad = panel_width - 13 - server.language.len();
 -        execute!(
 +        queue!(
              self.stdout,
              Print(" ".repeat(lang_pad)),
              SetForegroundColor(Color::Cyan),
          )?;
          // Blank line
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 4),
              SetForegroundColor(Color::Cyan),
          )?;
          // Instructions label
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 5),
              SetForegroundColor(Color::Cyan),
              SetForegroundColor(Color::White),
              Print(" Installation:"),
          )?;
 -        execute!(
 +        queue!(
              self.stdout,
              Print(" ".repeat(panel_width - 16)),
              SetForegroundColor(Color::Cyan),
              } else {
                  line.to_string()
              };
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(start_col as u16, row),
                  SetForegroundColor(Color::Cyan),
                  Print(format!("   {}", display_line)),
              )?;
              let line_pad = panel_width - 5 - display_line.len();
 -            execute!(
 +            queue!(
                  self.stdout,
                  Print(" ".repeat(line_pad)),
                  SetForegroundColor(Color::Cyan),
          // Fill remaining instruction lines if less than 3
          for i in instr_lines.len()..3 {
              let row = start_row + 6 + i as u16;
 -            execute!(
 +            queue!(
                  self.stdout,
                  MoveTo(start_col as u16, row),
                  SetForegroundColor(Color::Cyan),
+         }
          // Blank line
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 9),
              SetForegroundColor(Color::Cyan),
          )?;
          // Status or help line
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 10),
              SetForegroundColor(Color::Cyan),
          )?;
          if panel.copied_to_clipboard {
 -            execute!(
 +            queue!(
                  self.stdout,
                  SetForegroundColor(Color::Green),
                  Print(" ✓ Copied to clipboard!"),
              )?;
 -            execute!(self.stdout, Print(" ".repeat(panel_width - 26)))?;
 +            queue!(self.stdout, Print(" ".repeat(panel_width - 26)))?;
          } else {
 -            execute!(
 +            queue!(
                  self.stdout,
                  SetForegroundColor(Color::DarkGrey),
                  Print(" [C] Copy to clipboard  [Esc] Close"),
              )?;
 -            execute!(self.stdout, Print(" ".repeat(panel_width - 38)))?;
 +            queue!(self.stdout, Print(" ".repeat(panel_width - 38)))?;
+         }
 -        execute!(
 +        queue!(
              self.stdout,
              SetForegroundColor(Color::Cyan),
              Print("│"),
          )?;
          // Bottom border
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(start_col as u16, start_row + 11),
              SetForegroundColor(Color::Cyan),
      /// Render the integrated terminal panel
      pub fn render_terminal(&mut self, terminal: &TerminalPanel, left_offset: u16) -> Result<()> {
 -        // Hide cursor during render to prevent flicker
 -        execute!(self.stdout, Hide)?;
+-
          let start_row = terminal.render_start_row(self.rows);
          let height = terminal.height;
          let terminal_width = self.cols.saturating_sub(left_offset) as usize;
          // Draw terminal border (top line with title)
 -        execute!(
 +        queue!(
              self.stdout,
              MoveTo(left_offset, start_row),
              SetBackgroundColor(Color::AnsiValue(237)),
                  .unwrap_or_else(|| "Terminal".to_string());
              let title = format!(" {} ", name);
              let separator = "─".repeat(terminal_width.saturating_sub(title.len() + 2) / 2);
 -            execute!(
 +            queue!(
                  self.stdout,
                  Print(&separator),
                  SetAttribute(Attribute::Bold),
              // Pad to end of line
              let printed = separator.chars().count() * 2 + title.len();
              if printed < terminal_width {
 -                execute!(self.stdout, Print(" ".repeat(terminal_width - printed)))?;
 +                queue!(self.stdout, Print(" ".repeat(terminal_width - printed)))?;
+             }
          } else {
              // Multiple sessions: render tab bar
                  // Set colors based on active state
                  if is_active {
 -                    execute!(
 +                    queue!(
                          self.stdout,
                          SetBackgroundColor(Color::AnsiValue(238)),
                          SetForegroundColor(Color::White),
                          SetAttribute(Attribute::Bold),
                      )?;
                  } else {
 -                    execute!(
 +                    queue!(
                          self.stdout,
                          SetBackgroundColor(Color::AnsiValue(235)),
                          SetForegroundColor(Color::AnsiValue(245)),
                  let padding = tab_width.saturating_sub(tab_content.len());
                  let left_pad = padding / 2;
                  let right_pad = padding - left_pad;
 -                execute!(
 +                queue!(
                      self.stdout,
                      Print(" ".repeat(left_pad)),
                      Print(&tab_content),
                  // Separator between tabs
                  if i < session_count - 1 {
 -                    execute!(
 +                    queue!(
                          self.stdout,
                          SetBackgroundColor(Color::AnsiValue(237)),
                          SetForegroundColor(Color::AnsiValue(240)),
              // Fill remaining space
              if printed < available_width {
 -                execute!(
 +                queue!(
                      self.stdout,
                      SetBackgroundColor(Color::AnsiValue(237)),
                      SetForegroundColor(Color::White),
          let mut current_underline = false;
          // Set initial colors
 -        execute!(
 +        queue!(
              self.stdout,
              SetBackgroundColor(default_bg),
              SetForegroundColor(default_fg)
          )?;
          for row in 0..(height - 1) {
 -            execute!(self.stdout, MoveTo(left_offset, start_row + 1 + row))?;
 +            queue!(self.stdout, MoveTo(left_offset, start_row + 1 + row))?;
              // Build a string of characters with same attributes to batch print
              let mut batch = String::new();
                      if !batch.is_empty() {
                          // Apply batch attributes if different from current
                          if batch_fg != current_fg {
 -                            execute!(self.stdout, SetForegroundColor(batch_fg))?;
 +                            queue!(self.stdout, SetForegroundColor(batch_fg))?;
                              current_fg = batch_fg;
+                         }
                          if batch_bg != current_bg {
 -                            execute!(self.stdout, SetBackgroundColor(batch_bg))?;
 +                            queue!(self.stdout, SetBackgroundColor(batch_bg))?;
                              current_bg = batch_bg;
+                         }
                          if batch_bold != current_bold {
                              if batch_bold {
 -                                execute!(self.stdout, SetAttribute(Attribute::Bold))?;
 +                                queue!(self.stdout, SetAttribute(Attribute::Bold))?;
                              } else {
 -                                execute!(self.stdout, SetAttribute(Attribute::NoBold))?;
 +                                queue!(self.stdout, SetAttribute(Attribute::NoBold))?;
+                             }
                              current_bold = batch_bold;
+                         }
                          if batch_underline != current_underline {
                              if batch_underline {
 -                                execute!(self.stdout, SetAttribute(Attribute::Underlined))?;
 +                                queue!(self.stdout, SetAttribute(Attribute::Underlined))?;
                              } else {
 -                                execute!(self.stdout, SetAttribute(Attribute::NoUnderline))?;
 +                                queue!(self.stdout, SetAttribute(Attribute::NoUnderline))?;
+                             }
                              current_underline = batch_underline;
+                         }
 -                        execute!(self.stdout, Print(&batch))?;
 +                        queue!(self.stdout, Print(&batch))?;
                          batch.clear();
+                     }
                      batch_fg = fg;
              // Flush remaining batch for this row
              if !batch.is_empty() {
                  if batch_fg != current_fg {
 -                    execute!(self.stdout, SetForegroundColor(batch_fg))?;
 +                    queue!(self.stdout, SetForegroundColor(batch_fg))?;
                      current_fg = batch_fg;
+                 }
                  if batch_bg != current_bg {
 -                    execute!(self.stdout, SetBackgroundColor(batch_bg))?;
 +                    queue!(self.stdout, SetBackgroundColor(batch_bg))?;
                      current_bg = batch_bg;
+                 }
                  if batch_bold != current_bold {
                      if batch_bold {
 -                        execute!(self.stdout, SetAttribute(Attribute::Bold))?;
 +                        queue!(self.stdout, SetAttribute(Attribute::Bold))?;
                      } else {
 -                        execute!(self.stdout, SetAttribute(Attribute::NoBold))?;
 +                        queue!(self.stdout, SetAttribute(Attribute::NoBold))?;
+                     }
                      current_bold = batch_bold;
+                 }
                  if batch_underline != current_underline {
                      if batch_underline {
 -                        execute!(self.stdout, SetAttribute(Attribute::Underlined))?;
 +                        queue!(self.stdout, SetAttribute(Attribute::Underlined))?;
                      } else {
 -                        execute!(self.stdout, SetAttribute(Attribute::NoUnderline))?;
 +                        queue!(self.stdout, SetAttribute(Attribute::NoUnderline))?;
+                     }
                      current_underline = batch_underline;
+                 }
 -                execute!(self.stdout, Print(&batch))?;
 +                queue!(self.stdout, Print(&batch))?;
+             }
+         }
 -        // Position cursor in terminal (offset by left_offset)
 -        execute!(
 +        // Position cursor in terminal (offset by left_offset, but don't show - caller handles that)
 +        queue!(
              self.stdout,
              MoveTo(left_offset + cursor_col, start_row + 1 + cursor_row),
 -            Show,
              ResetColor
          )?;