diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index 75df430a3..2bb2076da 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -37,7 +37,7 @@ use helix_view::{ info::Info, input::KeyEvent, keyboard::KeyCode, - tree, + tree::{self, Dimension, Resize}, view::View, Document, DocumentId, Editor, ViewId, }; @@ -351,6 +351,11 @@ impl MappableCommand { goto_prev_change, "Goto previous change", goto_first_change, "Goto first change", goto_last_change, "Goto last change", + grow_buffer_width, "Grow focused container width", + shrink_buffer_width, "Shrink focused container width", + grow_buffer_height, "Grow focused container height", + shrink_buffer_height, "Shrink focused container height", + toggle_focus_window, "Toggle focus mode on buffer", goto_line_start, "Goto line start", goto_line_end, "Goto line end", goto_next_buffer, "Goto next buffer", @@ -767,6 +772,25 @@ fn goto_line_start(cx: &mut Context) { ) } +fn grow_buffer_width(cx: &mut Context) { + cx.editor.resize_buffer(Resize::Grow, Dimension::Width); +} + +fn shrink_buffer_width(cx: &mut Context) { + cx.editor.resize_buffer(Resize::Shrink, Dimension::Width); +} +fn grow_buffer_height(cx: &mut Context) { + cx.editor.resize_buffer(Resize::Grow, Dimension::Height); +} + +fn shrink_buffer_height(cx: &mut Context) { + cx.editor.resize_buffer(Resize::Shrink, Dimension::Height); +} + +fn toggle_focus_window(cx: &mut Context) { + cx.editor.toggle_focus_window(); +} + fn goto_next_buffer(cx: &mut Context) { goto_buffer(cx.editor, Direction::Forward); } diff --git a/helix-term/src/keymap/default.rs b/helix-term/src/keymap/default.rs index 763ed4ae7..e02959fbd 100644 --- a/helix-term/src/keymap/default.rs +++ b/helix-term/src/keymap/default.rs @@ -26,6 +26,22 @@ pub fn default() -> HashMap { "home" => goto_line_start, "end" => goto_line_end, + "A-w" => { "Alter Window" + "A-h"|"A-left" |"h"|"left" => shrink_buffer_width, + "A-l"|"A-right"|"l"|"right" => grow_buffer_width, + "A-j"|"A-down" |"j"|"down" => shrink_buffer_height, + "A-k"|"A-up" |"k"|"up" => grow_buffer_height, + "A-f"|"f" => toggle_focus_window, + }, + + "A-W" => { "Alter Window" sticky=true + "h"|"left" => shrink_buffer_width, + "l"|"right" => grow_buffer_width, + "j"|"down" => shrink_buffer_height, + "k"|"up" => grow_buffer_height, + "f" => toggle_focus_window, + }, + "w" => move_next_word_start, "b" => move_prev_word_start, "e" => move_next_word_end, diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs index 7af28ccc6..fa3ea90a2 100644 --- a/helix-view/src/editor.rs +++ b/helix-view/src/editor.rs @@ -6,7 +6,7 @@ use crate::{ input::KeyEvent, register::Registers, theme::{self, Theme}, - tree::{self, Tree}, + tree::{self, Dimension, Resize, Tree}, view::ViewPosition, Align, Document, DocumentId, View, ViewId, }; @@ -1645,6 +1645,14 @@ impl Editor { self.tree.transpose(); } + pub fn resize_buffer(&mut self, resize_type: Resize, dimension: Dimension) { + self.tree.resize_buffer(resize_type, dimension); + } + + pub fn toggle_focus_window(&mut self) { + self.tree.toggle_focus_window(); + } + pub fn should_close(&self) -> bool { self.tree.is_empty() } diff --git a/helix-view/src/tree.rs b/helix-view/src/tree.rs index 4c9eba0fd..e0aebdf1c 100644 --- a/helix-view/src/tree.rs +++ b/helix-view/src/tree.rs @@ -29,6 +29,16 @@ pub enum Content { Container(Box), } +pub enum Resize { + Shrink, + Grow, +} + +pub enum Dimension { + Width, + Height, +} + impl Node { pub fn container(layout: Layout) -> Self { Self { @@ -65,6 +75,14 @@ pub struct Container { layout: Layout, children: Vec, area: Rect, + node_bounds: Vec, +} + +#[derive(Debug, Clone, Copy)] +pub struct ContainerBounds { + width: usize, + height: usize, + expand: bool, } impl Container { @@ -73,8 +91,80 @@ impl Container { layout, children: Vec::new(), area: Rect::default(), + node_bounds: Vec::new(), } } + + fn get_child_by_view_id(&mut self, node: ViewId) -> Option<&mut ContainerBounds> { + self.children + .iter() + .position(|child| child == &node) + .and_then(|index| self.node_bounds.get_mut(index)) + } + + fn push_child(&mut self, node: ViewId) -> &mut Self { + self.children.push(node); + self.add_child_bounds(); + self + } + + fn insert_child(&mut self, index: usize, node: ViewId) -> &mut Self { + self.children.insert(index, node); + self.insert_child_bounds(index); + self + } + + fn remove_child(&mut self, index: usize) -> &mut Self { + self.children.remove(index); + self.remove_child_bounds(index); + self + } + + fn add_child_bounds(&mut self) -> &mut Self { + self.node_bounds.push(ContainerBounds { + width: 10, + height: 10, + expand: false, + }); + self + } + + fn insert_child_bounds(&mut self, index: usize) -> &mut Self { + self.node_bounds.insert( + index, + ContainerBounds { + width: 10, + height: 10, + expand: false, + }, + ); + self + } + + fn remove_child_bounds(&mut self, index: usize) -> &mut Self { + self.node_bounds.remove(index); + self + } + + fn calculate_slots_width(&self) -> usize { + self.node_bounds + .iter() + .map(|bounds| match bounds.expand { + true => 40, + false => bounds.width, + }) + .sum() + } + + fn calculate_slots_height(&self) -> usize { + self.node_bounds + .iter() + .map(|bounds| match bounds.expand { + true => 40, + false => bounds.height, + }) + .sum() + } } impl Default for Container { @@ -131,7 +221,7 @@ impl Tree { pos + 1 }; - container.children.insert(pos, node); + container.insert_child(pos, node); // focus the new node self.focus = node; @@ -168,7 +258,7 @@ impl Tree { .unwrap(); pos + 1 }; - container.children.insert(pos, node); + container.insert_child(pos, node); self.nodes[node].parent = parent; } else { let mut split = Node::container(layout); @@ -182,8 +272,8 @@ impl Tree { } => container, _ => unreachable!(), }; - container.children.push(focus); - container.children.push(node); + container.push_child(focus); + container.push_child(node); self.nodes[focus].parent = split; self.nodes[node].parent = split; @@ -232,7 +322,7 @@ impl Tree { } = &mut self.nodes[parent_id] { if let Some(pos) = container.children.iter().position(|&child| child == index) { - container.children.remove(pos); + container.remove_child(pos); // TODO: if container now only has one child, remove it and place child in parent if container.children.is_empty() && parent_id != self.root { // if container now empty, remove it @@ -359,12 +449,17 @@ impl Tree { match container.layout { Layout::Horizontal => { let len = container.children.len(); - - let height = area.height / len as u16; - + let slots = container.calculate_slots_height(); + let slot_height = area.height as f32 / slots as f32; let mut child_y = area.y; for (i, child) in container.children.iter().enumerate() { + let bounds = container.node_bounds[i]; + let height = match bounds.expand { + true => (40.0 * slot_height) as u16, + false => (slot_height * bounds.height as f32).floor() as u16, + }; + let mut area = Rect::new( container.area.x, child_y, @@ -373,7 +468,7 @@ impl Tree { ); child_y += height; - // last child takes the remaining width because we can get uneven + // last child takes the remaining height because we can get uneven // space from rounding if i == len - 1 { area.height = container.area.y + container.area.height - area.y; @@ -384,15 +479,20 @@ impl Tree { } Layout::Vertical => { let len = container.children.len(); - - let width = area.width / len as u16; + let slots = container.calculate_slots_width(); + let slot_width: f32 = area.width as f32 / slots as f32; + let mut child_x = area.x; let inner_gap = 1u16; // let total_gap = inner_gap * (len as u16 - 1); - let mut child_x = area.x; - for (i, child) in container.children.iter().enumerate() { + let bounds = container.node_bounds[i]; + let width = match bounds.expand { + true => (40.0 * slot_width) as u16, + false => (slot_width * bounds.width as f32).floor() as u16, + }; + let mut area = Rect::new( child_x, container.area.y, @@ -571,6 +671,83 @@ impl Tree { } } + fn get_active_node_bounds_mut( + &mut self, + expect_layout: Layout, + ) -> Option<&mut ContainerBounds> { + let mut focus = self.focus; + let mut parent = self.nodes[focus].parent; + + // Parent expected to be container + if let Some(focused_layout) = match &self.nodes[parent].content { + Content::View(_) => unreachable!(), + Content::Container(node) => Some(node.layout), + } { + // if we want to make a width change and we have a `Horizontal` layout focused, + // alter the parent `Vertical` layout instead and vice versa + if focused_layout != expect_layout { + focus = parent; + parent = self.nodes[parent].parent; + } + + if let Content::Container(node) = &mut self.nodes[parent].content { + return node.as_mut().get_child_by_view_id(focus); + }; + } + None + } + + pub fn resize_buffer(&mut self, resize_type: Resize, dimension: Dimension) { + match dimension { + Dimension::Width => { + if let Some(bounds) = self.get_active_node_bounds_mut(Layout::Vertical) { + match resize_type { + Resize::Shrink => { + if bounds.width > 1 { + bounds.width -= 1; + } + } + Resize::Grow => { + if bounds.width < 20 { + bounds.width += 1; + } + } + }; + self.recalculate(); + } + } + Dimension::Height => { + if let Some(bounds) = self.get_active_node_bounds_mut(Layout::Horizontal) { + match resize_type { + Resize::Shrink => { + if bounds.height > 1 { + bounds.height -= 1; + } + } + Resize::Grow => { + if bounds.height < 20 { + bounds.height += 1; + } + } + }; + self.recalculate(); + } + } + } + } + + pub fn toggle_focus_window(&mut self) { + if let Some(bounds) = self.get_active_node_bounds_mut(Layout::Horizontal) { + bounds.expand = !bounds.expand; + } + + if let Some(bounds) = self.get_active_node_bounds_mut(Layout::Vertical) { + bounds.expand = !bounds.expand; + } + + self.recalculate(); + } + pub fn swap_split_in_direction(&mut self, direction: Direction) -> Option<()> { let focus = self.focus; let target = self.find_split_in_direction(focus, direction)?;