diff --git a/src/boundaries.rs b/src/boundaries.rs index 6d5eb3bc..498a3731 100644 --- a/src/boundaries.rs +++ b/src/boundaries.rs @@ -372,7 +372,7 @@ impl Boundaries { boundary_characters: HashMap::new(), } } - pub fn add_rect(&mut self, rect: &Box) { + pub fn add_rect(&mut self, rect: &dyn Pane) { if self.rect_right_boundary_is_before_screen_edge(rect) { // let boundary_x_coords = self.rect_right_boundary_x_coords(rect); let boundary_x_coords = rect.right_boundary_x_coords(); @@ -429,20 +429,20 @@ impl Boundaries { } vte_output } - fn rect_right_boundary_is_before_screen_edge(&self, rect: &Box) -> bool { + fn rect_right_boundary_is_before_screen_edge(&self, rect: &dyn Pane) -> bool { rect.x() + rect.columns() < self.columns } - fn rect_bottom_boundary_is_before_screen_edge(&self, rect: &Box) -> bool { + fn rect_bottom_boundary_is_before_screen_edge(&self, rect: &dyn Pane) -> bool { rect.y() + rect.rows() < self.rows } - fn rect_right_boundary_row_start(&self, rect: &Box) -> usize { + fn rect_right_boundary_row_start(&self, rect: &dyn Pane) -> usize { if rect.y() == 0 { 0 } else { rect.y() - 1 } } - fn rect_right_boundary_row_end(&self, rect: &Box) -> usize { + fn rect_right_boundary_row_end(&self, rect: &dyn Pane) -> usize { let rect_bottom_row = rect.y() + rect.rows(); // we do this because unless we're on the screen edge, we'd like to go one extra row to // connect to whatever boundary is beneath us @@ -452,14 +452,14 @@ impl Boundaries { rect_bottom_row + 1 } } - fn rect_bottom_boundary_col_start(&self, rect: &Box) -> usize { + fn rect_bottom_boundary_col_start(&self, rect: &dyn Pane) -> usize { if rect.x() == 0 { 0 } else { rect.x() - 1 } } - fn rect_bottom_boundary_col_end(&self, rect: &Box) -> usize { + fn rect_bottom_boundary_col_end(&self, rect: &dyn Pane) -> usize { let rect_right_col = rect.x() + rect.columns(); // we do this because unless we're on the screen edge, we'd like to go one extra column to // connect to whatever boundary is right of us diff --git a/src/command_is_executing.rs b/src/command_is_executing.rs index 0cf47c05..93c44eb6 100644 --- a/src/command_is_executing.rs +++ b/src/command_is_executing.rs @@ -1,3 +1,4 @@ +#![allow(clippy::mutex_atomic)] use std::sync::{Arc, Condvar, Mutex}; #[derive(Clone)] diff --git a/src/errors.rs b/src/errors.rs index 92ea7a41..04c25ee0 100644 --- a/src/errors.rs +++ b/src/errors.rs @@ -89,6 +89,12 @@ impl ErrorContext { } } +impl Default for ErrorContext { + fn default() -> Self { + Self::new() + } +} + impl Display for ErrorContext { fn fmt(&self, f: &mut Formatter) -> Result<(), Error> { writeln!(f, "Originating Thread(s):")?; diff --git a/src/main.rs b/src/main.rs index 395859df..01d0f232 100644 --- a/src/main.rs +++ b/src/main.rs @@ -24,6 +24,7 @@ use std::thread; use panes::PaneId; use serde::{Deserialize, Serialize}; use structopt::StructOpt; +use wasm_vm::PluginInstruction; use crate::command_is_executing::CommandIsExecuting; use crate::errors::{AppContext, ContextType, ErrorContext, PtyContext, ScreenContext}; @@ -38,7 +39,7 @@ use crate::utils::{ }; use std::cell::RefCell; -thread_local!(static OPENCALLS: RefCell = RefCell::new(ErrorContext::new())); +thread_local!(static OPENCALLS: RefCell = RefCell::default()); #[derive(Serialize, Deserialize, Debug)] enum ApiCommand { @@ -48,6 +49,9 @@ enum ApiCommand { MoveFocus, } +pub type ChannelWithContext = (Sender<(T, ErrorContext)>, Receiver<(T, ErrorContext)>); +pub type SyncChannelWithContext = (SyncSender<(T, ErrorContext)>, Receiver<(T, ErrorContext)>); + #[derive(Clone)] enum SenderType { Sender(Sender<(T, ErrorContext)>), @@ -146,35 +150,27 @@ pub fn start(mut os_input: Box, opts: Opt) { let command_is_executing = CommandIsExecuting::new(); let full_screen_ws = os_input.get_terminal_size_using_fd(0); - os_input.into_raw_mode(0); - let (send_screen_instructions, receive_screen_instructions): ( - Sender<(ScreenInstruction, ErrorContext)>, - Receiver<(ScreenInstruction, ErrorContext)>, - ) = channel(); + os_input.set_raw_mode(0); + let (send_screen_instructions, receive_screen_instructions): ChannelWithContext< + ScreenInstruction, + > = channel(); let err_ctx = OPENCALLS.with(|ctx| *ctx.borrow()); let mut send_screen_instructions = SenderWithContext::new(err_ctx, SenderType::Sender(send_screen_instructions)); - let (send_pty_instructions, receive_pty_instructions): ( - Sender<(PtyInstruction, ErrorContext)>, - Receiver<(PtyInstruction, ErrorContext)>, - ) = channel(); + + let (send_pty_instructions, receive_pty_instructions): ChannelWithContext = + channel(); let mut send_pty_instructions = SenderWithContext::new(err_ctx, SenderType::Sender(send_pty_instructions)); - use crate::wasm_vm::PluginInstruction; - - let (send_plugin_instructions, receive_plugin_instructions): ( - Sender<(PluginInstruction, ErrorContext)>, - Receiver<(PluginInstruction, ErrorContext)>, - ) = channel(); - + let (send_plugin_instructions, receive_plugin_instructions): ChannelWithContext< + PluginInstruction, + > = channel(); let send_plugin_instructions = SenderWithContext::new(err_ctx, SenderType::Sender(send_plugin_instructions)); - let (send_app_instructions, receive_app_instructions): ( - SyncSender<(AppInstruction, ErrorContext)>, - Receiver<(AppInstruction, ErrorContext)>, - ) = sync_channel(0); + let (send_app_instructions, receive_app_instructions): SyncChannelWithContext = + sync_channel(0); let send_app_instructions = SenderWithContext::new(err_ctx, SenderType::SyncSender(send_app_instructions)); diff --git a/src/os_input_output.rs b/src/os_input_output.rs index 89ba6c72..41ee3b3c 100644 --- a/src/os_input_output.rs +++ b/src/os_input_output.rs @@ -75,6 +75,7 @@ fn handle_command_exit(mut child: Child) { } for signal in signals.pending() { + // FIXME: We need to handle more signals here! match signal { signal_hook::SIGINT => { child.kill().unwrap(); @@ -141,7 +142,7 @@ pub struct OsInputOutput { pub trait OsApi: Send + Sync { fn get_terminal_size_using_fd(&self, pid: RawFd) -> PositionAndSize; fn set_terminal_size_using_fd(&mut self, pid: RawFd, cols: u16, rows: u16); - fn into_raw_mode(&mut self, pid: RawFd); + fn set_raw_mode(&mut self, pid: RawFd); fn unset_raw_mode(&mut self, pid: RawFd); fn spawn_terminal(&mut self, file_to_open: Option) -> (RawFd, RawFd); fn read_from_tty_stdout(&mut self, pid: RawFd, buf: &mut [u8]) -> Result; @@ -160,7 +161,7 @@ impl OsApi for OsInputOutput { fn set_terminal_size_using_fd(&mut self, pid: RawFd, cols: u16, rows: u16) { set_terminal_size_using_fd(pid, cols, rows); } - fn into_raw_mode(&mut self, pid: RawFd) { + fn set_raw_mode(&mut self, pid: RawFd) { into_raw_mode(pid); } fn unset_raw_mode(&mut self, pid: RawFd) { diff --git a/src/panes/scroll.rs b/src/panes/scroll.rs index 05252b03..2dedd1e7 100644 --- a/src/panes/scroll.rs +++ b/src/panes/scroll.rs @@ -1,5 +1,8 @@ use std::collections::VecDeque; -use std::fmt::{self, Debug, Formatter}; +use std::{ + cmp::max, + fmt::{self, Debug, Formatter}, +}; use crate::panes::terminal_character::{ CharacterStyles, TerminalCharacter, EMPTY_TERMINAL_CHARACTER, @@ -341,10 +344,8 @@ impl Scroll { if lines_to_skip > 0 { lines_to_skip -= 1; } else { - for _ in line.len()..self.total_columns { - // pad line if needed - line.push(EMPTY_TERMINAL_CHARACTER); - } + // pad line if needed + line.resize(self.total_columns, EMPTY_TERMINAL_CHARACTER); lines.push_front(line); } if lines.len() == self.lines_in_view { @@ -477,9 +478,14 @@ impl Scroll { count }; - for _ in current_fragment.characters.len()..current_cursor_column_position + move_count { - current_fragment.characters.push(EMPTY_TERMINAL_CHARACTER); - } + current_fragment.characters.resize( + max( + current_fragment.characters.len(), + current_cursor_column_position + move_count, + ), + EMPTY_TERMINAL_CHARACTER, + ); + self.cursor_position.move_forward(move_count); } pub fn move_cursor_back(&mut self, count: usize) { @@ -645,9 +651,10 @@ impl Scroll { .get_mut(current_line_wrap_position) .expect("cursor out of bounds"); - for _ in current_fragment.characters.len()..col { - current_fragment.characters.push(EMPTY_TERMINAL_CHARACTER); - } + current_fragment.characters.resize( + max(current_fragment.characters.len(), col), + EMPTY_TERMINAL_CHARACTER, + ); self.cursor_position.move_to_column(col); } pub fn move_cursor_to_column(&mut self, col: usize) { @@ -680,9 +687,7 @@ impl Scroll { self.scroll_region = None; } fn scroll_region_absolute_indices(&mut self) -> Option<(usize, usize)> { - if self.scroll_region.is_none() { - return None; - }; + self.scroll_region?; if self.canonical_lines.len() > self.lines_in_view { let absolute_top = self.canonical_lines.len() - 1 - self.lines_in_view; let absolute_bottom = self.canonical_lines.len() - 1; diff --git a/src/panes/terminal_character.rs b/src/panes/terminal_character.rs index 28d638f9..80c3162b 100644 --- a/src/panes/terminal_character.rs +++ b/src/panes/terminal_character.rs @@ -390,7 +390,7 @@ impl CharacterStyles { } } if let Some(next_params) = ansi_params.get(params_used..) { - if next_params.len() > 0 { + if !next_params.is_empty() { self.add_style_from_ansi_params(next_params); } } @@ -536,14 +536,9 @@ impl Display for CharacterStyles { write!(f, "\u{1b}[2m")?; } AnsiCode::Reset => { - if let Some(bold) = self.bold { + if let Some(AnsiCode::Reset) = self.bold { // we only reset dim if both dim and bold should be reset - match bold { - AnsiCode::Reset => { - write!(f, "\u{1b}[22m")?; - } - _ => {} - } + write!(f, "\u{1b}[22m")?; } } _ => {} diff --git a/src/panes/terminal_pane.rs b/src/panes/terminal_pane.rs index 70eb216a..6bd39a3f 100644 --- a/src/panes/terminal_pane.rs +++ b/src/panes/terminal_pane.rs @@ -442,12 +442,10 @@ impl vte::Perform for TerminalPane { } else { (params[0] as usize - 1, params[0] as usize) } + } else if params[0] == 0 { + (0, params[1] as usize - 1) } else { - if params[0] == 0 { - (0, params[1] as usize - 1) - } else { - (params[0] as usize - 1, params[1] as usize - 1) - } + (params[0] as usize - 1, params[1] as usize - 1) }; self.scroll.move_cursor_to(row, col); } else if c == 'A' { @@ -607,11 +605,8 @@ impl vte::Perform for TerminalPane { } fn esc_dispatch(&mut self, intermediates: &[u8], _ignore: bool, byte: u8) { - match (byte, intermediates.get(0)) { - (b'M', None) => { - self.scroll.move_cursor_up_in_scroll_region(1); - } - _ => {} + if let (b'M', None) = (byte, intermediates.get(0)) { + self.scroll.move_cursor_up_in_scroll_region(1); } } } diff --git a/src/screen.rs b/src/screen.rs index 4a9bc00c..365d1d7a 100644 --- a/src/screen.rs +++ b/src/screen.rs @@ -123,7 +123,7 @@ impl Screen { let active_tab_id = self.get_active_tab().unwrap().index; let tab_ids: Vec = self.tabs.keys().copied().collect(); let first_tab = tab_ids.get(0).unwrap(); - let last_tab = tab_ids.get(tab_ids.len() - 1).unwrap(); + let last_tab = tab_ids.last().unwrap(); let active_tab_id_position = tab_ids.iter().position(|id| id == &active_tab_id).unwrap(); if active_tab_id == *first_tab { @@ -143,7 +143,7 @@ impl Screen { self.send_pty_instructions .send(PtyInstruction::CloseTab(pane_ids)) .unwrap(); - if self.tabs.len() == 0 { + if self.tabs.is_empty() { self.active_tab_index = None; self.render(); } diff --git a/src/tab.rs b/src/tab.rs index bfb7ee49..bd5be8c5 100644 --- a/src/tab.rs +++ b/src/tab.rs @@ -4,8 +4,11 @@ use crate::{boundaries::Boundaries, panes::PluginPane}; use crate::{layout::Layout, wasm_vm::PluginInstruction}; use crate::{os_input_output::OsApi, utils::shared::pad_to_size}; use crate::{AppInstruction, SenderWithContext}; -use std::collections::{BTreeMap, HashSet}; use std::os::unix::io::RawFd; +use std::{ + cmp::Reverse, + collections::{BTreeMap, HashSet}, +}; use std::{io::Write, sync::mpsc::channel}; /* @@ -98,30 +101,30 @@ pub trait Pane { fn bottom_boundary_y_coords(&self) -> usize { self.y() + self.rows() } - fn is_directly_right_of(&self, other: &Box) -> bool { + fn is_directly_right_of(&self, other: &dyn Pane) -> bool { self.x() == other.x() + other.columns() + 1 } - fn is_directly_left_of(&self, other: &Box) -> bool { + fn is_directly_left_of(&self, other: &dyn Pane) -> bool { self.x() + self.columns() + 1 == other.x() } - fn is_directly_below(&self, other: &Box) -> bool { + fn is_directly_below(&self, other: &dyn Pane) -> bool { self.y() == other.y() + other.rows() + 1 } - fn is_directly_above(&self, other: &Box) -> bool { + fn is_directly_above(&self, other: &dyn Pane) -> bool { self.y() + self.rows() + 1 == other.y() } - fn horizontally_overlaps_with(&self, other: &Box) -> bool { + fn horizontally_overlaps_with(&self, other: &dyn Pane) -> bool { (self.y() >= other.y() && self.y() <= (other.y() + other.rows())) || ((self.y() + self.rows()) <= (other.y() + other.rows()) && (self.y() + self.rows()) > other.y()) || (self.y() <= other.y() && (self.y() + self.rows() >= (other.y() + other.rows()))) || (other.y() <= self.y() && (other.y() + other.rows() >= (self.y() + self.rows()))) } - fn get_horizontal_overlap_with(&self, other: &Box) -> usize { + fn get_horizontal_overlap_with(&self, other: &dyn Pane) -> usize { std::cmp::min(self.y() + self.rows(), other.y() + other.rows()) - std::cmp::max(self.y(), other.y()) } - fn vertically_overlaps_with(&self, other: &Box) -> bool { + fn vertically_overlaps_with(&self, other: &dyn Pane) -> bool { (self.x() >= other.x() && self.x() <= (other.x() + other.columns())) || ((self.x() + self.columns()) <= (other.x() + other.columns()) && (self.x() + self.columns()) > other.x()) @@ -130,7 +133,7 @@ pub trait Pane { || (other.x() <= self.x() && (other.x() + other.columns() >= (self.x() + self.columns()))) } - fn get_vertical_overlap_with(&self, other: &Box) -> usize { + fn get_vertical_overlap_with(&self, other: &dyn Pane) -> usize { std::cmp::min(self.x() + self.columns(), other.x() + other.columns()) - std::cmp::max(self.x(), other.x()) } @@ -440,9 +443,9 @@ impl Tab { } } } - pub fn get_active_pane(&self) -> Option<&Box> { + pub fn get_active_pane(&self) -> Option<&dyn Pane> { match self.get_active_pane_id() { - Some(active_pane) => self.panes.get(&active_pane), + Some(active_pane) => self.panes.get(&active_pane).map(Box::as_ref), None => None, } } @@ -551,7 +554,7 @@ impl Tab { ); for (kind, terminal) in self.panes.iter_mut() { if !self.panes_to_hide.contains(&terminal.pid()) { - boundaries.add_rect(&terminal); + boundaries.add_rect(terminal.as_ref()); if let Some(vte_output) = terminal.render() { let vte_output = if let PaneId::Terminal(_) = kind { vte_output @@ -668,37 +671,37 @@ impl Tab { Some(ids) } } - fn panes_top_aligned_with_pane(&self, pane: &Box) -> Vec<&Box> { + fn panes_top_aligned_with_pane(&self, pane: &dyn Pane) -> Vec<&dyn Pane> { self.panes .keys() - .map(|t_id| self.panes.get(&t_id).unwrap()) + .map(|t_id| self.panes.get(&t_id).unwrap().as_ref()) .filter(|terminal| terminal.pid() != pane.pid() && terminal.y() == pane.y()) .collect() } - fn panes_bottom_aligned_with_pane(&self, pane: &Box) -> Vec<&Box> { + fn panes_bottom_aligned_with_pane(&self, pane: &dyn Pane) -> Vec<&dyn Pane> { self.panes .keys() - .map(|t_id| self.panes.get(&t_id).unwrap()) + .map(|t_id| self.panes.get(&t_id).unwrap().as_ref()) .filter(|terminal| { terminal.pid() != pane.pid() && terminal.y() + terminal.rows() == pane.y() + pane.rows() }) .collect() } - fn panes_right_aligned_with_pane(&self, pane: &Box) -> Vec<&Box> { + fn panes_right_aligned_with_pane(&self, pane: &dyn Pane) -> Vec<&dyn Pane> { self.panes .keys() - .map(|t_id| self.panes.get(&t_id).unwrap()) + .map(|t_id| self.panes.get(&t_id).unwrap().as_ref()) .filter(|terminal| { terminal.pid() != pane.pid() && terminal.x() + terminal.columns() == pane.x() + pane.columns() }) .collect() } - fn panes_left_aligned_with_pane(&self, pane: &&Box) -> Vec<&Box> { + fn panes_left_aligned_with_pane(&self, pane: &dyn Pane) -> Vec<&dyn Pane> { self.panes .keys() - .map(|t_id| self.panes.get(&t_id).unwrap()) + .map(|t_id| self.panes.get(&t_id).unwrap().as_ref()) .filter(|terminal| terminal.pid() != pane.pid() && terminal.x() == pane.x()) .collect() } @@ -708,10 +711,14 @@ impl Tab { terminal_borders_to_the_right: &HashSet, ) -> BorderAndPaneIds { let mut terminals = vec![]; - let terminal_to_check = self.panes.get(id).expect("terminal id does not exist"); - let mut right_aligned_terminals = self.panes_right_aligned_with_pane(&terminal_to_check); + let terminal_to_check = self + .panes + .get(id) + .expect("terminal id does not exist") + .as_ref(); + let mut right_aligned_terminals = self.panes_right_aligned_with_pane(terminal_to_check); // terminals that are next to each other up to current - right_aligned_terminals.sort_by(|a, b| b.y().cmp(&a.y())); + right_aligned_terminals.sort_by_key(|a| Reverse(a.y())); for terminal in right_aligned_terminals { let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); if terminal.y() + terminal.rows() + 1 == terminal_to_check.y() { @@ -747,10 +754,14 @@ impl Tab { terminal_borders_to_the_right: &HashSet, ) -> BorderAndPaneIds { let mut terminals = vec![]; - let terminal_to_check = self.panes.get(id).expect("terminal id does not exist"); - let mut right_aligned_terminals = self.panes_right_aligned_with_pane(&terminal_to_check); + let terminal_to_check = self + .panes + .get(id) + .expect("terminal id does not exist") + .as_ref(); + let mut right_aligned_terminals = self.panes_right_aligned_with_pane(terminal_to_check); // terminals that are next to each other up to current - right_aligned_terminals.sort_by(|a, b| a.y().cmp(&b.y())); + right_aligned_terminals.sort_by_key(|a| a.y()); for terminal in right_aligned_terminals { let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); if terminal.y() == terminal_to_check.y() + terminal_to_check.rows() + 1 { @@ -786,10 +797,14 @@ impl Tab { terminal_borders_to_the_left: &HashSet, ) -> BorderAndPaneIds { let mut terminals = vec![]; - let terminal_to_check = self.panes.get(id).expect("terminal id does not exist"); - let mut left_aligned_terminals = self.panes_left_aligned_with_pane(&terminal_to_check); + let terminal_to_check = self + .panes + .get(id) + .expect("terminal id does not exist") + .as_ref(); + let mut left_aligned_terminals = self.panes_left_aligned_with_pane(terminal_to_check); // terminals that are next to each other up to current - left_aligned_terminals.sort_by(|a, b| b.y().cmp(&a.y())); + left_aligned_terminals.sort_by_key(|a| Reverse(a.y())); for terminal in left_aligned_terminals { let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); if terminal.y() + terminal.rows() + 1 == terminal_to_check.y() { @@ -825,10 +840,14 @@ impl Tab { terminal_borders_to_the_left: &HashSet, ) -> BorderAndPaneIds { let mut terminals = vec![]; - let terminal_to_check = self.panes.get(id).expect("terminal id does not exist"); - let mut left_aligned_terminals = self.panes_left_aligned_with_pane(&terminal_to_check); + let terminal_to_check = self + .panes + .get(id) + .expect("terminal id does not exist") + .as_ref(); + let mut left_aligned_terminals = self.panes_left_aligned_with_pane(terminal_to_check); // terminals that are next to each other up to current - left_aligned_terminals.sort_by(|a, b| a.y().cmp(&b.y())); + left_aligned_terminals.sort_by_key(|a| a.y()); for terminal in left_aligned_terminals { let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); if terminal.y() == terminal_to_check.y() + terminal_to_check.rows() + 1 { @@ -867,10 +886,14 @@ impl Tab { terminal_borders_above: &HashSet, ) -> BorderAndPaneIds { let mut terminals = vec![]; - let terminal_to_check = self.panes.get(id).expect("terminal id does not exist"); - let mut top_aligned_terminals = self.panes_top_aligned_with_pane(&terminal_to_check); + let terminal_to_check = self + .panes + .get(id) + .expect("terminal id does not exist") + .as_ref(); + let mut top_aligned_terminals = self.panes_top_aligned_with_pane(terminal_to_check); // terminals that are next to each other up to current - top_aligned_terminals.sort_by(|a, b| b.x().cmp(&a.x())); + top_aligned_terminals.sort_by_key(|a| Reverse(a.x())); for terminal in top_aligned_terminals { let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); if terminal.x() + terminal.columns() + 1 == terminal_to_check.x() { @@ -906,10 +929,10 @@ impl Tab { terminal_borders_above: &HashSet, ) -> BorderAndPaneIds { let mut terminals = vec![]; - let terminal_to_check = self.panes.get(id).unwrap(); - let mut top_aligned_terminals = self.panes_top_aligned_with_pane(&terminal_to_check); + let terminal_to_check = self.panes.get(id).unwrap().as_ref(); + let mut top_aligned_terminals = self.panes_top_aligned_with_pane(terminal_to_check); // terminals that are next to each other up to current - top_aligned_terminals.sort_by(|a, b| a.x().cmp(&b.x())); + top_aligned_terminals.sort_by_key(|a| a.x()); for terminal in top_aligned_terminals { let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); if terminal.x() == terminal_to_check.x() + terminal_to_check.columns() + 1 { @@ -945,9 +968,9 @@ impl Tab { terminal_borders_below: &HashSet, ) -> BorderAndPaneIds { let mut terminals = vec![]; - let terminal_to_check = self.panes.get(id).unwrap(); - let mut bottom_aligned_terminals = self.panes_bottom_aligned_with_pane(&terminal_to_check); - bottom_aligned_terminals.sort_by(|a, b| b.x().cmp(&a.x())); + let terminal_to_check = self.panes.get(id).unwrap().as_ref(); + let mut bottom_aligned_terminals = self.panes_bottom_aligned_with_pane(terminal_to_check); + bottom_aligned_terminals.sort_by_key(|a| Reverse(a.x())); // terminals that are next to each other up to current for terminal in bottom_aligned_terminals { let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); @@ -984,9 +1007,9 @@ impl Tab { terminal_borders_below: &HashSet, ) -> BorderAndPaneIds { let mut terminals = vec![]; - let terminal_to_check = self.panes.get(id).unwrap(); - let mut bottom_aligned_terminals = self.panes_bottom_aligned_with_pane(&terminal_to_check); - bottom_aligned_terminals.sort_by(|a, b| a.x().cmp(&b.x())); + let terminal_to_check = self.panes.get(id).unwrap().as_ref(); + let mut bottom_aligned_terminals = self.panes_bottom_aligned_with_pane(terminal_to_check); + bottom_aligned_terminals.sort_by_key(|a| a.x()); // terminals that are next to each other up to current for terminal in bottom_aligned_terminals { let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); @@ -1421,9 +1444,9 @@ impl Tab { let next_index = terminals .enumerate() .filter(|(_, (_, c))| { - c.is_directly_left_of(&active) && c.horizontally_overlaps_with(&active) + c.is_directly_left_of(active) && c.horizontally_overlaps_with(active) }) - .max_by_key(|(_, (_, c))| c.get_horizontal_overlap_with(&active)) + .max_by_key(|(_, (_, c))| c.get_horizontal_overlap_with(active)) .map(|(_, (pid, _))| pid); match next_index { Some(&p) => { @@ -1451,9 +1474,9 @@ impl Tab { let next_index = terminals .enumerate() .filter(|(_, (_, c))| { - c.is_directly_below(&active) && c.vertically_overlaps_with(&active) + c.is_directly_below(active) && c.vertically_overlaps_with(active) }) - .max_by_key(|(_, (_, c))| c.get_vertical_overlap_with(&active)) + .max_by_key(|(_, (_, c))| c.get_vertical_overlap_with(active)) .map(|(_, (pid, _))| pid); match next_index { Some(&p) => { @@ -1481,9 +1504,9 @@ impl Tab { let next_index = terminals .enumerate() .filter(|(_, (_, c))| { - c.is_directly_above(&active) && c.vertically_overlaps_with(&active) + c.is_directly_above(active) && c.vertically_overlaps_with(active) }) - .max_by_key(|(_, (_, c))| c.get_vertical_overlap_with(&active)) + .max_by_key(|(_, (_, c))| c.get_vertical_overlap_with(active)) .map(|(_, (pid, _))| pid); match next_index { Some(&p) => { @@ -1511,9 +1534,9 @@ impl Tab { let next_index = terminals .enumerate() .filter(|(_, (_, c))| { - c.is_directly_right_of(&active) && c.horizontally_overlaps_with(&active) + c.is_directly_right_of(active) && c.horizontally_overlaps_with(active) }) - .max_by_key(|(_, (_, c))| c.get_horizontal_overlap_with(&active)) + .max_by_key(|(_, (_, c))| c.get_horizontal_overlap_with(active)) .map(|(_, (pid, _))| pid); match next_index { Some(&p) => { diff --git a/src/tests/fakes.rs b/src/tests/fakes.rs index d15b8a88..821183b6 100644 --- a/src/tests/fakes.rs +++ b/src/tests/fakes.rs @@ -130,7 +130,7 @@ impl OsApi for FakeInputOutput { .unwrap() .push(IoEvent::SetTerminalSizeUsingFd(pid, cols, rows)); } - fn into_raw_mode(&mut self, pid: RawFd) { + fn set_raw_mode(&mut self, pid: RawFd) { self.io_events .lock() .unwrap()