Rebase on new libcosmic and iced

Cargo.toml

@@ -30,6 +30,10 @@ default-features = false
 features = ["multi-window", "tokio", "winit"]
 #path = "../libcosmic"
 
+[dependencies.smol_str]
+version = "0.2.1"
+features = ["serde"]
+
 #TODO: clean up and send changes upstream
 [dependencies.systemicons]
 git = "https://github.com/jackpot51/systemicons"
@@ -38,11 +42,6 @@ git = "https://github.com/jackpot51/systemicons"
 default = ["wgpu"]
 wgpu = ["libcosmic/wgpu"]
 
-[patch.crates-io]
-smithay-client-toolkit = { git = "https://github.com/pop-os/client-toolkit", branch = "wayland-resize" }
-# https://github.com/gfx-rs/wgpu/pull/4959
-wgpu = { git = "https://github.com/pop-os/wgpu", branch = "v0.18" }
-
 [profile.release-with-debug]
 inherits = "release"
 debug = true

src/app.rs

@@ -8,7 +8,7 @@ use cosmic::{
     iced::{
         event,
         futures::{self, SinkExt},
-        keyboard::{Event as KeyEvent, KeyCode, Modifiers},
+        keyboard::{Event as KeyEvent, Key, Modifiers},
         subscription::{self, Subscription},
         window, Event, Length, Point,
     },
@@ -104,7 +104,7 @@ pub enum Message {
     Config(Config),
     Copy(Option<segmented_button::Entity>),
     Cut(Option<segmented_button::Entity>),
-    Key(Modifiers, KeyCode),
+    Key(Modifiers, Key),
     Modifiers(Modifiers),
     MoveToTrash(Option<segmented_button::Entity>),
     NewFile(Option<segmented_button::Entity>),
@@ -564,10 +564,10 @@ impl Application for App {
             Message::Cut(entity_opt) => {
                 log::warn!("TODO: CUT");
             }
-            Message::Key(modifiers, key_code) => {
+            Message::Key(modifiers, key) => {
                 let entity = self.tab_model.active();
                 for (key_bind, action) in self.key_binds.iter() {
-                    if key_bind.matches(modifiers, key_code) {
+                    if key_bind.matches(modifiers, &key) {
                         return self.update(action.message(Some(entity)));
                     }
                 }
@@ -937,10 +937,9 @@ impl Application for App {
 
         let mut subscriptions = vec![
             event::listen_with(|event, _status| match event {
-                Event::Keyboard(KeyEvent::KeyPressed {
+                Event::Keyboard(KeyEvent::KeyPressed { key, modifiers, .. }) => {
-                    key_code,
+                    Some(Message::Key(modifiers, key))
-                    modifiers,
+                }
-                }) => Some(Message::Key(modifiers, key_code)),
                 Event::Keyboard(KeyEvent::ModifiersChanged(modifiers)) => {
                     Some(Message::Modifiers(modifiers))
                 }

src/key_bind.rs

@@ -1,4 +1,7 @@
-use cosmic::iced::keyboard::{KeyCode, Modifiers};
+use cosmic::{
+    iced::keyboard::{Key, Modifiers},
+    iced_core::keyboard::key::Named,
+};
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, fmt};
 
@@ -15,12 +18,12 @@ pub enum Modifier {
 #[derive(Clone, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
 pub struct KeyBind {
     pub modifiers: Vec<Modifier>,
-    pub key_code: KeyCode,
+    pub key: Key,
 }
 
 impl KeyBind {
-    pub fn matches(&self, modifiers: Modifiers, key_code: KeyCode) -> bool {
+    pub fn matches(&self, modifiers: Modifiers, key: &Key) -> bool {
-        self.key_code == key_code
+        key == &self.key
             && modifiers.logo() == self.modifiers.contains(&Modifier::Super)
             && modifiers.control() == self.modifiers.contains(&Modifier::Ctrl)
             && modifiers.alt() == self.modifiers.contains(&Modifier::Alt)
@@ -33,7 +36,11 @@ impl fmt::Display for KeyBind {
         for modifier in self.modifiers.iter() {
             write!(f, "{:?} + ", modifier)?;
         }
-        write!(f, "{:?}", self.key_code)
+        match &self.key {
+            Key::Character(c) => write!(f, "{}", c.to_uppercase()),
+            Key::Named(named) => write!(f, "{:?}", named),
+            other => write!(f, "{:?}", other),
+        }
     }
 }
 
@@ -42,30 +49,30 @@ pub fn key_binds() -> HashMap<KeyBind, Action> {
     let mut key_binds = HashMap::new();
 
     macro_rules! bind {
-        ([$($modifier:ident),+ $(,)?], $key_code:ident, $action:ident) => {{
+        ([$($modifier:ident),+ $(,)?], $key:expr, $action:ident) => {{
             key_binds.insert(
                 KeyBind {
                     modifiers: vec![$(Modifier::$modifier),+],
-                    key_code: KeyCode::$key_code,
+                    key: $key,
                 },
                 Action::$action,
             );
         }};
     }
 
-    bind!([Ctrl], C, Copy);
+    bind!([Ctrl], Key::Character("c".into()), Copy);
-    bind!([Ctrl], X, Cut);
+    bind!([Ctrl], Key::Character("x".into()), Cut);
-    bind!([Alt], Right, HistoryNext);
+    bind!([Alt], Key::Named(Named::ArrowRight), HistoryNext);
-    bind!([Alt], Left, HistoryPrevious);
+    bind!([Alt], Key::Named(Named::ArrowLeft), HistoryPrevious);
-    bind!([Alt], Up, LocationUp);
+    bind!([Alt], Key::Named(Named::ArrowUp), LocationUp);
-    bind!([Ctrl], V, Paste);
+    bind!([Ctrl], Key::Character("v".into()), Paste);
-    bind!([Ctrl], A, SelectAll);
+    bind!([Ctrl], Key::Character("a".into()), SelectAll);
-    bind!([Ctrl], W, TabClose);
+    bind!([Ctrl], Key::Character("w".into()), TabClose);
-    bind!([Ctrl], T, TabNew);
+    bind!([Ctrl], Key::Character("t".into()), TabNew);
-    bind!([Ctrl], Tab, TabNext);
+    bind!([Ctrl], Key::Named(Named::Tab), TabNext);
-    bind!([Ctrl, Shift], Tab, TabPrev);
+    bind!([Ctrl, Shift], Key::Named(Named::Tab), TabPrev);
-    bind!([Ctrl], Q, WindowClose);
+    bind!([Ctrl], Key::Character("q".into()), WindowClose);
-    bind!([Ctrl], N, WindowNew);
+    bind!([Ctrl], Key::Character("n".into()), WindowNew);
 
     key_binds
 }

src/menu.rs

@@ -2,7 +2,7 @@
 
 use cosmic::{
     //TODO: export iced::widget::horizontal_rule in cosmic::widget
-    iced::{widget::horizontal_rule, Alignment, Background, Length},
+    iced::{widget::horizontal_rule, Alignment, Background, Border, Length},
     theme,
     widget::{
         self,
@@ -85,9 +85,12 @@ pub fn context_menu<'a>(entity: segmented_button::Entity, tab: &Tab) -> Element<
                 icon_color: Some(component.on.into()),
                 text_color: Some(component.on.into()),
                 background: Some(Background::Color(component.base.into())),
-                border_radius: 8.0.into(),
+                border: Border {
-                border_width: 1.0,
+                    radius: 8.0.into(),
-                border_color: component.divider.into(),
+                    width: 1.0,
+                    color: component.divider.into(),
+                },
+                ..Default::default()
             }
         }))
         .width(Length::Fixed(240.0))

src/mouse_area.rs

@@ -4,13 +4,13 @@ use cosmic::iced_core::{
     event::{self, Event},
     layout, mouse, overlay, renderer, touch,
     widget::{tree, Operation, OperationOutputWrapper, Tree},
-    {Clipboard, Element, Layout, Length, Point, Rectangle, Shell, Widget},
+    Size, {Clipboard, Element, Layout, Length, Point, Rectangle, Shell, Widget},
 };
 
 /// Emit messages on mouse events.
 #[allow(missing_debug_implementations)]
-pub struct MouseArea<'a, Message, Renderer> {
+pub struct MouseArea<'a, Message, Theme, Renderer> {
-    content: Element<'a, Message, Renderer>,
+    content: Element<'a, Message, Theme, Renderer>,
     on_drag: Option<Box<dyn Fn(Option<Point>) -> Message + 'a>>,
     on_press: Option<Box<dyn Fn(Option<Point>) -> Message + 'a>>,
     on_release: Option<Box<dyn Fn(Option<Point>) -> Message + 'a>>,
@@ -25,7 +25,7 @@ pub struct MouseArea<'a, Message, Renderer> {
     on_forward_release: Option<Box<dyn Fn(Option<Point>) -> Message + 'a>>,
 }
 
-impl<'a, Message, Renderer> MouseArea<'a, Message, Renderer> {
+impl<'a, Message, Theme, Renderer> MouseArea<'a, Message, Theme, Renderer> {
     /// The message to emit when a drag is initiated.
     #[must_use]
     pub fn on_drag(mut self, message: impl Fn(Option<Point>) -> Message + 'a) -> Self {
@@ -85,7 +85,7 @@ impl<'a, Message, Renderer> MouseArea<'a, Message, Renderer> {
         self
     }
 
-     /// The message to emit on a back button press.
+    /// The message to emit on a back button press.
     #[must_use]
     pub fn on_back_press(mut self, message: impl Fn(Option<Point>) -> Message + 'a) -> Self {
         self.on_back_press = Some(Box::new(message));
@@ -121,9 +121,9 @@ struct State {
     drag_initiated: Option<Point>,
 }
 
-impl<'a, Message, Renderer> MouseArea<'a, Message, Renderer> {
+impl<'a, Message, Theme, Renderer> MouseArea<'a, Message, Theme, Renderer> {
     /// Creates a [`MouseArea`] with the given content.
-    pub fn new(content: impl Into<Element<'a, Message, Renderer>>) -> Self {
+    pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) -> Self {
         MouseArea {
             content: content.into(),
             on_drag: None,
@@ -142,7 +142,8 @@ impl<'a, Message, Renderer> MouseArea<'a, Message, Renderer> {
     }
 }
 
-impl<'a, Message, Renderer> Widget<Message, Renderer> for MouseArea<'a, Message, Renderer>
+impl<'a, Message, Theme, Renderer> Widget<Message, Theme, Renderer>
+    for MouseArea<'a, Message, Theme, Renderer>
 where
     Renderer: renderer::Renderer,
     Message: Clone,
@@ -163,12 +164,8 @@ where
         tree.diff_children(std::slice::from_mut(&mut self.content));
     }
 
-    fn width(&self) -> Length {
+    fn size(&self) -> Size<Length> {
-        self.content.as_widget().width()
+        self.content.as_widget().size()
-    }
-
-    fn height(&self) -> Length {
-        self.content.as_widget().height()
     }
 
     fn layout(
@@ -249,7 +246,7 @@ where
         &self,
         tree: &Tree,
         renderer: &mut Renderer,
-        theme: &Renderer::Theme,
+        theme: &Theme,
         renderer_style: &renderer::Style,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
@@ -271,28 +268,31 @@ where
         tree: &'b mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-    ) -> Option<overlay::Element<'b, Message, Renderer>> {
+    ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
         self.content
             .as_widget_mut()
             .overlay(&mut tree.children[0], layout, renderer)
     }
 }
 
-impl<'a, Message, Renderer> From<MouseArea<'a, Message, Renderer>>
+impl<'a, Message, Theme, Renderer> From<MouseArea<'a, Message, Theme, Renderer>>
-    for Element<'a, Message, Renderer>
+    for Element<'a, Message, Theme, Renderer>
 where
     Message: 'a + Clone,
     Renderer: 'a + renderer::Renderer,
+    Theme: 'a,
 {
-    fn from(area: MouseArea<'a, Message, Renderer>) -> Element<'a, Message, Renderer> {
+    fn from(
+        area: MouseArea<'a, Message, Theme, Renderer>,
+    ) -> Element<'a, Message, Theme, Renderer> {
         Element::new(area)
     }
 }
 
 /// Processes the given [`Event`] and updates the [`State`] of an [`MouseArea`]
 /// accordingly.
-fn update<Message: Clone, Renderer>(
+fn update<Message: Clone, Theme, Renderer>(
-    widget: &mut MouseArea<'_, Message, Renderer>,
+    widget: &mut MouseArea<'_, Message, Theme, Renderer>,
     event: &Event,
     layout: Layout<'_>,
     cursor: mouse::Cursor,