improv(stack): create and borrow tab models directly in the view

Author: mmstick

src/shell/element/stack.rs

@@ -92,6 +92,7 @@ impl fmt::Debug for CosmicStack {
 #[derive(Debug, Clone)]
 pub struct CosmicStackInternal {
     windows: Arc<Mutex<Vec<CosmicSurface>>>,
+    tab_models: Arc<[tab::Model]>,
     active: Arc<AtomicUsize>,
     activated: Arc<AtomicBool>,
     group_focused: Arc<AtomicBool>,
@@ -132,7 +133,11 @@ impl CosmicStack {
         handle: LoopHandle<'static, crate::state::State>,
         theme: cosmic::Theme,
     ) -> CosmicStack {
-        let windows = windows.map(Into::into).collect::<Vec<_>>();
+        let (tab_models, windows) = windows
+            .map(Into::into)
+            .map(|window| (tab::Model::from(&window), window))
+            .collect::<(Vec<_>, Vec<_>)>();
+
         assert!(!windows.is_empty());
 
         for window in &windows {
@@ -145,6 +150,7 @@ impl CosmicStack {
         CosmicStack(IcedElement::new(
             CosmicStackInternal {
                 windows: Arc::new(Mutex::new(windows)),
+                tab_models: Arc::from(tab_models),
                 active: Arc::new(AtomicUsize::new(0)),
                 activated: Arc::new(AtomicBool::new(false)),
                 group_focused: Arc::new(AtomicBool::new(false)),
@@ -795,6 +801,7 @@ pub enum Message {
     PotentialTabDragStart(usize),
     Activate(usize),
     Close(usize),
+    Refresh,
     ScrollForward,
     ScrollBack,
     Scrolled,
@@ -842,6 +849,15 @@ impl Program for CosmicStackInternal {
         last_seat: Option<&(Seat<State>, Serial)>,
     ) -> Task<Self::Message> {
         match message {
+            Message::Refresh => {
+                self.tab_models = self
+                    .windows
+                    .lock()
+                    .unwrap()
+                    .iter()
+                    .map(tab::Model::from)
+                    .collect();
+            }
             Message::DragStart => {
                 if let Some((seat, serial)) = last_seat.cloned() {
                     let active = self.active.load(Ordering::SeqCst);
@@ -1001,12 +1017,14 @@ impl Program for CosmicStackInternal {
     }
 
     fn view(&self) -> CosmicElement<'_, Self::Message> {
-        let windows = self.windows.lock().unwrap();
         if self.geometry.lock().unwrap().is_none() {
             return iced_widget::row(Vec::new()).into();
         };
+
         let active = self.active.load(Ordering::SeqCst);
+        let activated = self.activated.load(Ordering::SeqCst);
         let group_focused = self.group_focused.load(Ordering::SeqCst);
+        let maximized = self.windows.lock().unwrap()[active].is_maximized(false);
 
         let elements = vec![
             cosmic_widget::icon::from_name("window-stack-symbolic")
@@ -1033,20 +1051,14 @@ impl Program for CosmicStackInternal {
                 .into(),
             CosmicElement::new(
                 Tabs::new(
-                    windows.iter().enumerate().map(|(i, w)| {
-                        let user_data = w.user_data();
-                        user_data.insert_if_missing(Id::unique);
-                        Tab::new(
-                            w.title(),
-                            w.app_id(),
-                            user_data.get::<Id>().unwrap().clone(),
-                        )
-                        .on_press(Message::PotentialTabDragStart(i))
-                        .on_right_click(Message::TabMenu(i))
-                        .on_close(Message::Close(i))
+                    self.tab_models.iter().enumerate().map(|(i, tab)| {
+                        Tab::new(tab)
+                            .on_press(Message::PotentialTabDragStart(i))
+                            .on_right_click(Message::TabMenu(i))
+                            .on_close(Message::Close(i))
                     }),
                     active,
-                    windows[active].is_activated(false),
+                    activated,
                     group_focused,
                 )
                 .id(SCROLLABLE_ID.clone())
@@ -1068,7 +1080,7 @@ impl Program for CosmicStackInternal {
                 .into(),
         ];
 
-        let radius = if windows[active].is_maximized(false) {
+        let radius = if maximized {
             Radius::from(0.0)
         } else {
             Radius::from([8.0, 8.0, 0.0, 0.0])
@@ -1255,6 +1267,8 @@ impl SpaceElement for CosmicStack {
                 SpaceElement::refresh(w)
             });
         });
+
+        self.0.queue_message(Message::Refresh);
         SpaceElement::refresh(&self.0);
     }
 }

src/shell/element/stack/tab.rs

@@ -1,8 +1,10 @@
+use std::hash::{Hash, Hasher};
+
 use cosmic::{
     font::Font,
     iced::{
         widget::{self, container::draw_background, rule::FillMode},
-        Background,
+        Background, Padding,
     },
     iced_core::{
         alignment, event,
@@ -17,10 +19,12 @@ use cosmic::{
     },
     iced_widget::scrollable::AbsoluteOffset,
     theme,
-    widget::{icon::from_name, Icon},
+    widget::icon,
     Apply,
 };
 
+use crate::shell::CosmicSurface;
+
 use super::tab_text::tab_text;
 
 #[derive(Clone, Copy)]
@@ -115,14 +119,47 @@ pub trait TabMessage: Clone {
     fn scrolled() -> Self;
 }
 
+#[derive(Debug, Clone)]
+pub struct Model {
+    pub id: Id,
+    pub app_icon: cosmic::widget::icon::Handle,
+    pub title: String,
+    pub title_hash: u64,
+}
+
+impl Model {
+    pub fn new(id: Id, appid: String, title: String) -> Self {
+        // Pre-emptively cache the hash of each title for more efficient diffing.
+        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+        title.hash(&mut hasher);
+
+        Self {
+            id,
+            app_icon: icon::from_name(appid).size(16).handle(),
+            title,
+            title_hash: hasher.finish(),
+        }
+    }
+}
+
+impl From<&CosmicSurface> for Model {
+    fn from(window: &CosmicSurface) -> Self {
+        let user_data = window.user_data();
+        user_data.insert_if_missing(Id::unique);
+        Self::new(
+            user_data.get::<Id>().unwrap().clone(),
+            window.app_id(),
+            window.title(),
+        )
+    }
+}
+
 struct LocalState {
     hovered: bool,
 }
 
-pub struct Tab<Message: TabMessage> {
-    id: Id,
-    app_icon: Icon,
-    title: String,
+pub struct Tab<'a, Message: TabMessage> {
+    model: &'a Model,
     font: Font,
     close_message: Option<Message>,
     press_message: Option<Message>,
@@ -132,12 +169,10 @@ pub struct Tab<Message: TabMessage> {
     active: bool,
 }
 
-impl<Message: TabMessage + 'static> Tab<Message> {
-    pub fn new(title: impl Into<String>, app_id: impl Into<String>, id: Id) -> Self {
+impl<'a, Message: TabMessage + 'static> Tab<'a, Message> {
+    pub fn new(model: &'a Model) -> Self {
         Tab {
-            id,
-            app_icon: from_name(app_id.into()).size(16).icon(),
-            title: title.into(),
+            model,
             font: cosmic::font::default(),
             close_message: None,
             press_message: None,
@@ -183,8 +218,8 @@ impl<Message: TabMessage + 'static> Tab<Message> {
         self
     }
 
-    pub(super) fn internal<'a>(self, idx: usize) -> TabInternal<'a, Message> {
-        let mut close_button = from_name("window-close-symbolic")
+    pub(super) fn internal(self, idx: usize) -> TabInternal<'a, Message> {
+        let mut close_button = icon::from_name("window-close-symbolic")
             .size(16)
             .prefer_svg(true)
             .icon()
@@ -197,14 +232,14 @@ impl<Message: TabMessage + 'static> Tab<Message> {
 
         let items = vec![
             widget::vertical_rule(4).class(self.rule_theme).into(),
-            self.app_icon
+            cosmic::widget::icon(self.model.app_icon.clone())
                 .clone()
                 .apply(widget::container)
                 .width(Length::Shrink)
                 .padding([2, 4, 2, 8])
                 .center_y(Length::Fill)
                 .into(),
-            tab_text(self.title, self.active)
+            tab_text(&self.model, self.active)
                 .font(self.font)
                 .font_size(14.0)
                 .height(Length::Fill)
@@ -220,7 +255,7 @@ impl<Message: TabMessage + 'static> Tab<Message> {
         ];
 
         TabInternal {
-            id: self.id,
+            id: self.model.id.clone(),
             idx,
             active: self.active,
             background: self.background_theme,
@@ -299,6 +334,7 @@ where
             .min_height(size.height)
             .width(size.width)
             .height(size.height);
+
         cosmic::iced_core::layout::flex::resolve(
             cosmic::iced_core::layout::flex::Axis::Horizontal,
             renderer,

src/shell/element/stack/tab_text.rs

@@ -13,9 +13,11 @@ use cosmic::{
     },
 };
 
+use super::tab::Model;
+
 /// Text in a stack tab with an overflow gradient.
-pub fn tab_text(text: String, selected: bool) -> TabText {
-    TabText::new(text, selected)
+pub fn tab_text(model: &Model, selected: bool) -> TabText {
+    TabText::new(model, selected)
 }
 
 struct LocalState {
@@ -25,24 +27,24 @@ struct LocalState {
 }
 
 /// Text in a stack tab with an overflow gradient.
-pub struct TabText {
-    text: String,
+pub struct TabText<'a> {
+    model: &'a Model,
     font: cosmic::font::Font,
     font_size: f32,
     selected: bool,
     height: Length,
     width: Length,
 }
 
-impl TabText {
-    pub fn new(text: String, selected: bool) -> Self {
+impl<'a> TabText<'a> {
+    pub fn new(model: &'a Model, selected: bool) -> Self {
         TabText {
             width: Length::Shrink,
             height: Length::Shrink,
             font: cosmic::font::default(),
             font_size: 14.0,
             selected,
-            text,
+            model,
         }
     }
 
@@ -70,14 +72,14 @@ impl TabText {
 
     fn create_hash(&self) -> u64 {
         let mut hasher = std::collections::hash_map::DefaultHasher::new();
-        self.text.hash(&mut hasher);
+        self.model.title_hash.hash(&mut hasher);
         self.selected.hash(&mut hasher);
         hasher.finish()
     }
 
     fn create_paragraph(&self) -> <cosmic::Renderer as TextRenderer>::Paragraph {
         <cosmic::Renderer as TextRenderer>::Paragraph::with_text(Text {
-            content: &self.text,
+            content: &self.model.title,
             size: cosmic::iced_core::Pixels(self.font_size),
             bounds: Size::INFINITY,
             font: self.font,
@@ -90,7 +92,7 @@ impl TabText {
     }
 }
 
-impl<Message> Widget<Message, cosmic::Theme, cosmic::Renderer> for TabText {
+impl<'a, Message> Widget<Message, cosmic::Theme, cosmic::Renderer> for TabText<'a> {
     fn tag(&self) -> tree::Tag {
         tree::Tag::of::<LocalState>()
     }
@@ -204,8 +206,8 @@ impl<Message> Widget<Message, cosmic::Theme, cosmic::Renderer> for TabText {
     }
 }
 
-impl<Message: 'static> From<TabText> for cosmic::Element<'_, Message> {
-    fn from(value: TabText) -> Self {
+impl<'a, Message: 'static> From<TabText<'a>> for cosmic::Element<'a, Message> {
+    fn from(value: TabText<'a>) -> Self {
         Self::new(value)
     }
 }

src/shell/element/stack/tabs.rs

@@ -132,7 +132,7 @@ where
     Message: TabMessage + 'static,
 {
     pub fn new(
-        tabs: impl ExactSizeIterator<Item = Tab<Message>>,
+        tabs: impl ExactSizeIterator<Item = Tab<'a, Message>>,
         active: usize,
         activated: bool,
         group_focused: bool,