Add missing ViewId related updates

* swap contents of views except id and area
* update selection information stored in Document on swap

Author: zen3ger

helix-view/src/document.rs

@@ -636,6 +636,26 @@ impl Document {
             .insert(view_id, selection.ensure_invariants(self.text().slice(..)));
     }
 
+    pub fn swap_selection_in_views(&mut self, view_a: ViewId, view_b: ViewId) {
+        let selection_a = self.selections.remove(&view_a);
+        let selection_b = self.selections.remove(&view_b);
+
+        match (selection_a, selection_b) {
+            (Some(selection_a), Some(selection_b)) => {
+                // swapped same document with different views
+                self.selections.insert(view_a, selection_b);
+                self.selections.insert(view_b, selection_a);
+            }
+            (Some(selection_a), _) => {
+                self.selections.insert(view_b, selection_a);
+            }
+            (_, Some(selection_b)) => {
+                self.selections.insert(view_a, selection_b);
+            }
+            _ => unreachable!(),
+        }
+    }
+
     /// Apply a [`Transaction`] to the [`Document`] to change its text.
     fn apply_impl(&mut self, transaction: &Transaction, view_id: ViewId) -> bool {
         let old_doc = self.text().clone();

helix-view/src/editor.rs

@@ -885,20 +885,31 @@ impl Editor {
         self.tree.focus_direction(tree::Direction::Down);
     }
 
+    fn swap_in_direction(&mut self, direction: tree::Direction) {
+        if let Some(update) = self.tree.swap_split_in_direction(direction) {
+            for doc_id in &update.documents {
+                if let Some(doc) = self.document_mut(*doc_id) {
+                    let [view_a, view_b] = update.views;
+                    doc.swap_selection_in_views(view_a, view_b);
+                }
+            }
+        }
+    }
+
     pub fn swap_right(&mut self) {
-        self.tree.swap_split_in_direction(tree::Direction::Right);
+        self.swap_in_direction(tree::Direction::Right);
     }
 
     pub fn swap_left(&mut self) {
-        self.tree.swap_split_in_direction(tree::Direction::Left);
+        self.swap_in_direction(tree::Direction::Left);
     }
 
     pub fn swap_up(&mut self) {
-        self.tree.swap_split_in_direction(tree::Direction::Up);
+        self.swap_in_direction(tree::Direction::Up);
     }
 
     pub fn swap_down(&mut self) {
-        self.tree.swap_split_in_direction(tree::Direction::Down);
+        self.swap_in_direction(tree::Direction::Down);
     }
 
     pub fn should_close(&self) -> bool {

helix-view/src/tree.rs

@@ -1,4 +1,4 @@
-use crate::{graphics::Rect, View, ViewId};
+use crate::{graphics::Rect, DocumentId, View, ViewId};
 use slotmap::HopSlotMap;
 
 // the dimensions are recomputed on window resize/tree change.
@@ -29,6 +29,12 @@ pub enum Content {
     Container(Box<Container>),
 }
 
+#[derive(Debug)]
+pub struct ViewSwap {
+    pub documents: [DocumentId; 2],
+    pub views: [ViewId; 2],
+}
+
 impl Node {
     pub fn container(layout: Layout) -> Self {
         Self {
@@ -526,14 +532,18 @@ impl Tree {
         }
     }
 
-    pub fn swap_split_in_direction(&mut self, direction: Direction) {
+    pub fn swap_split_in_direction(&mut self, direction: Direction) -> Option<ViewSwap> {
         if let Some(id) = self.find_split_in_direction(self.focus, direction) {
             if let Some([focused, target]) = self.nodes.get_disjoint_mut([self.focus, id]) {
                 match (&mut focused.content, &mut target.content) {
                     (Content::View(focused), Content::View(target)) => {
-                        std::mem::swap(&mut focused.doc, &mut target.doc);
-                        std::mem::swap(&mut focused.id, &mut target.id);
+                        View::swap_content(focused, target);
                         self.focus = id;
+
+                        return Some(ViewSwap {
+                            documents: [focused.doc, target.doc],
+                            views: [focused.id, target.id],
+                        });
                     }
                     // self.focus always points to a view which has a content of Content::View
                     // and find_split_in_direction() only returns a view which has content of
@@ -542,6 +552,7 @@ impl Tree {
                 }
             }
         }
+        None
     }
 
     pub fn area(&self) -> Rect {

helix-view/src/view.rs

@@ -117,6 +117,21 @@ impl View {
         }
     }
 
+    pub fn swap_content(view_a: &mut View, view_b: &mut View) {
+        std::mem::swap(&mut view_a.doc, &mut view_b.doc);
+        std::mem::swap(&mut view_a.offset, &mut view_b.offset);
+        std::mem::swap(&mut view_a.jumps, &mut view_b.jumps);
+        std::mem::swap(
+            &mut view_a.docs_access_history,
+            &mut view_b.docs_access_history,
+        );
+        std::mem::swap(
+            &mut view_a.last_modified_docs,
+            &mut view_b.last_modified_docs,
+        );
+        std::mem::swap(&mut view_a.gutters, &mut view_b.gutters);
+    }
+
     pub fn add_to_history(&mut self, id: DocumentId) {
         if let Some(pos) = self.docs_access_history.iter().position(|&doc| doc == id) {
             self.docs_access_history.remove(pos);