changed the way virtual screens are stored

src/clients.rs

@@ -117,8 +117,6 @@ mod client {
 
 pub use client::*;
 
-use std::collections::VecDeque;
-
 type Clients = IndexMap<u64, Client, BuildIdentityHasher>;
 type ClientRef = u64;
 type ClientRefs = Vec<ClientRef>;
@@ -134,12 +132,12 @@ pub enum ClientEntry<T> {
     Vacant,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct ClientState {
     pub(self) clients: Clients,
     pub(self) floating_clients: Clients,
     focused: Option<ClientRef>,
-    pub(self) virtual_screens: VecDeque<VirtualScreen>,
+    pub(self) virtual_screens: VirtualScreenStore,
 
     pub(self) gap: i32,
     pub(self) screen_size: (i32, i32),
@@ -152,16 +150,19 @@ struct VirtualScreen {
     aux: ClientRefs,
 }
 
+#[derive(Debug)]
+struct VirtualScreenStore {
+    screens: Vec<VirtualScreen>,
+    current_idx: usize,
+}
+
 impl Default for ClientState {
     fn default() -> Self {
-        let mut vss = VecDeque::<VirtualScreen>::new();
-        vss.resize_with(1, Default::default);
-
         Self {
             clients: Default::default(),
             floating_clients: Default::default(),
             focused: None,
-            virtual_screens: vss,
+            virtual_screens: VirtualScreenStore::new(1),
             gap: 0,
             screen_size: (1, 1),
             master_size: 1.0,
@@ -186,11 +187,8 @@ impl ClientState {
     }
 
     pub fn with_virtualscreens(self, num: usize) -> Self {
-        let mut vss = VecDeque::<VirtualScreen>::new();
-        vss.resize_with(num, Default::default);
-
         Self {
-            virtual_screens: vss,
+            virtual_screens: VirtualScreenStore::new(num),
             ..self
         }
     }
@@ -216,9 +214,7 @@ impl ClientState {
         } else {
             self.clients.insert(key, client);
 
-            if let Some(vs) = self.virtual_screens.front_mut() {
+            self.virtual_screens.get_mut_current().insert(&key);
-                vs.insert(&key);
-            }
         }
 
         // adding a client changes the liling layout, rearrange
@@ -293,31 +289,27 @@ impl ClientState {
 
     #[allow(dead_code)]
     pub fn iter_current_screen(&self) -> impl Iterator<Item = (&u64, &Client)> {
-        self.clients
+        self.clients.iter().filter(move |&(k, _)| {
-            .iter()
+            self.virtual_screens.get_current().contains(k)
-            .filter(move |&(k, _)| self.current_vs().contains(k))
+        })
     }
 
     pub fn iter_master_stack(&self) -> impl Iterator<Item = (&u64, &Client)> {
-        self.current_vs()
+        self.virtual_screens
+            .get_current()
             .master
             .iter()
             .map(move |k| (k, self.get(k).unwrap()))
     }
 
     pub fn iter_aux_stack(&self) -> impl Iterator<Item = (&u64, &Client)> {
-        self.current_vs()
+        self.virtual_screens
+            .get_current()
             .aux
             .iter()
             .map(move |k| (k, self.get(k).unwrap()))
     }
 
-    /// Returns reference to the current `VirtualScreen`.
-    fn current_vs(&self) -> &VirtualScreen {
-        // there is always at least one (1) virtual screen.
-        self.virtual_screens.front().unwrap()
-    }
-
     fn is_client_visible<K>(&self, key: &K) -> bool
     where
         K: ClientKey,
@@ -330,7 +322,9 @@ impl ClientState {
                     true
                 }
             }
-            ClientEntry::Tiled(_) => self.current_vs().contains(key),
+            ClientEntry::Tiled(_) => {
+                self.virtual_screens.get_current().contains(key)
+            }
             _ => false,
         }
     }
@@ -426,9 +420,7 @@ impl ClientState {
 
                     false => {
                         self.clients.insert(key, floating_client);
-                        if let Some(vs) = self.virtual_screens.front_mut() {
+                        self.virtual_screens.get_mut_current().insert(&key);
-                            vs.insert(&key);
-                        }
                     }
                 }
             }
@@ -607,7 +599,7 @@ impl ClientState {
         let (width, height) = self.screen_size;
 
         // should be fine to unwrap since we will always have at least 1 virtual screen
-        if let Some(vs) = self.virtual_screens.front_mut() {
+        let vs = self.virtual_screens.get_mut_current();
         // if aux is empty -> width : width / 2
 
         let (master_width, aux_width) = {
@@ -619,8 +611,7 @@ impl ClientState {
                 self.master_size / 2.0
             };
 
-                let master_width =
+            let master_width = (effective_width as f32 * master_size) as i32;
-                    (effective_width as f32 * master_size) as i32;
             let aux_width = effective_width - master_width;
 
             (master_width, aux_width)
@@ -669,7 +660,6 @@ impl ClientState {
                 };
             }
         }
-        }
 
         // Should have xlib send those changes back to the x server after this function
     }
@@ -762,6 +752,54 @@ impl VirtualScreen {
     }
 }
 
+impl VirtualScreenStore {
+    fn new(n: usize) -> Self {
+        let mut screens = Vec::with_capacity(n);
+        screens.resize_with(n, Default::default);
+
+        Self {
+            screens,
+            current_idx: 0,
+        }
+    }
+
+    fn get_current(&self) -> &VirtualScreen {
+        &self.screens[self.current_idx]
+    }
+
+    fn get_mut_current(&mut self) -> &mut VirtualScreen {
+        &mut self.screens[self.current_idx]
+    }
+
+    fn len(&self) -> usize {
+        self.screens.len()
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &VirtualScreen> {
+        self.screens.iter()
+    }
+
+    fn iter_mut(&mut self) -> impl Iterator<Item = &mut VirtualScreen> {
+        self.screens.iter_mut()
+    }
+
+    fn rotate_left(&mut self, n: usize) {
+        let l = self.screens.len();
+        let a = n % l;
+        let b = self.current_idx % l;
+
+        self.current_idx = ((b + l) + a) % l;
+    }
+
+    fn rotate_right(&mut self, n: usize) {
+        let l = self.screens.len();
+        let a = n % l;
+        let b = self.current_idx % l;
+
+        self.current_idx = ((b + l) - a) % l;
+    }
+}
+
 impl<T> Into<Option<T>> for ClientEntry<T> {
     fn into(self) -> Option<T> {
         match self {