improv(circular): prevent caps from touching

Also matches previous behavior of both paddings being applied to subsequent items, rather than globally.

.github/workflows/ci.yml

@@ -33,16 +33,17 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        features:
-        - "" # for cosmic-comp, don't remove!
-        - 'winit_debug'
-        - 'winit_tokio'
-        - winit
-        - winit_wgpu
-        - wayland
-        - applet
-        - desktop,smol
-        - desktop,tokio
+        test_args:
+        - --no-default-features --features "" # for cosmic-comp, don't remove!
+        - --no-default-features --features "winit_debug"
+        - --no-default-features --features "winit_tokio"
+        - --no-default-features --features "winit"
+        - --no-default-features --features "winit_wgpu"
+        - --no-default-features --features "wayland"
+        - --no-default-features --features "applet"
+        - --no-default-features --features "desktop,smol"
+        - --no-default-features --features "desktop,tokio"
+        - -p cosmic-theme
     runs-on: ubuntu-22.04
     steps:
       - name: Checkout sources
@@ -66,7 +67,7 @@ jobs:
       - name: Rust toolchain
         uses: dtolnay/rust-toolchain@stable
       - name: Test features
-        run: cargo test --no-default-features --features "${{ matrix.features }}"
+        run: cargo test ${{ matrix.test_args }} -- --test-threads=1
         env:
           RUST_BACKTRACE: full
 
@@ -103,7 +104,7 @@ jobs:
         run: sudo apt-get update; sudo apt-get install -y libxkbcommon-dev libwayland-dev
       - name: Rust toolchain
         uses: dtolnay/rust-toolchain@stable
-      - name: Test example
+      - name: Check example
         run: cargo check -p "${{ matrix.examples }}"
         env:
           RUST_BACKTRACE: full

.github/workflows/pages.yml

@@ -7,19 +7,30 @@ on:
 
 jobs:
   pages:
-
     runs-on: ubuntu-latest
 
     steps:
-    - name: Checkout sources
-      uses: actions/checkout@v3
-      with:
-        submodules: recursive
-    - name: Build documentation
-      run: cargo doc --verbose --features tokio,winit
-    - name: Deploy documentation
-      uses: peaceiris/actions-gh-pages@v3
-      with:
-        github_token: ${{ secrets.GITHUB_TOKEN }}
-        publish_dir: ./target/doc
-        force_orphan: true
+      - name: Checkout sources
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+      - name: Install Rust nightly
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: nightly-2025-07-31
+      - name: System dependencies
+        run: sudo apt-get update; sudo apt-get install -y libxkbcommon-dev libwayland-dev
+      - name: Build documentation
+        run: |
+          RUSTDOCFLAGS="--cfg docsrs" \
+          cargo +nightly-2025-07-31 doc --no-deps \
+          -p cosmic-client-toolkit \
+          -p cosmic-protocols \
+          -p libcosmic \
+          --verbose --features tokio,winit,wayland,desktop,single-instance,applet,xdg-portal,multi-window
+      - name: Deploy documentation
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./target/doc
+          force_orphan: true

Cargo.toml

@@ -8,13 +8,29 @@ rust-version = "1.90"
 name = "cosmic"
 
 [features]
-default = ["dbus-config", "multi-window", "a11y"]
+default = [
+    "winit",
+    "tokio",
+    "a11y",
+    "dbus-config",
+    "x11",
+    "iced-wayland",
+    "multi-window",
+]
+advanced-shaping = ["iced/advanced-shaping"]
 # Accessibility support
 a11y = ["iced/a11y", "iced_accessibility"]
 # Enable about widget
 about = []
 # Builds support for animated images
-animated-image = ["dep:async-fs", "image/gif", "tokio?/io-util", "tokio?/fs"]
+animated-image = [
+    "dep:async-fs",
+    "image/gif",
+    "image/webp",
+    "image/png",
+    "tokio?/io-util",
+    "tokio?/fs",
+]
 # XXX autosize should not be used on winit windows unless dialogs
 autosize = []
 applet = [
@@ -42,6 +58,7 @@ desktop = [
     "process",
     "dep:cosmic-settings-config",
     "dep:freedesktop-desktop-entry",
+    "dep:image-extras",
     "dep:mime",
     "dep:shlex",
     "tokio?/io-util",
@@ -65,18 +82,24 @@ tokio = [
 ]
 # Tokio async runtime
 # Wayland window support
-wayland = [
+iced-wayland = [
     "ashpd?/wayland",
     "autosize",
-    "iced_runtime/wayland",
     "iced/wayland",
     "iced_winit/wayland",
-    "cctk",
     "surface-message",
 ]
+wayland = [
+    "iced-wayland",
+    "iced_runtime/cctk",
+    "iced_winit/cctk",
+    "iced_wgpu/cctk",
+    "iced/cctk",
+    "dep:cctk",
+]
 surface-message = []
 # multi-window support
-multi-window = ["iced/multi-window"]
+multi-window = []
 # Render with wgpu
 wgpu = ["iced/wgpu", "iced_wgpu"]
 # X11 window support via winit
@@ -96,14 +119,15 @@ async-std = [
     "zbus?/async-io",
     "iced/async-std",
 ]
+x11 = ["iced/x11", "iced_winit/x11"]
 
 [dependencies]
 apply = "0.3.0"
-ashpd = { version = "0.12.1", default-features = false, optional = true }
+ashpd = { version = "0.12.3", default-features = false, optional = true }
 async-fs = { version = "2.2", optional = true }
 async-std = { version = "1.13", optional = true }
-auto_enums = "0.8.7"
-cctk = { git = "https://github.com/pop-os/cosmic-protocols", package = "cosmic-client-toolkit", rev = "d0e95be", optional = true }
+auto_enums = "0.8.8"
+cctk = { git = "https://github.com/pop-os/cosmic-protocols", package = "cosmic-client-toolkit", rev = "160b086", optional = true }
 jiff = "0.2"
 cosmic-config = { path = "cosmic-config" }
 cosmic-settings-config = { git = "https://github.com/pop-os/cosmic-settings-daemon", optional = true }
@@ -115,17 +139,21 @@ i18n-embed = { version = "0.16.0", features = [
 i18n-embed-fl = "0.10"
 rust-embed = "8.11.0"
 css-color = "0.2.8"
-derive_setters = "0.1.8"
+derive_setters = "0.1.9"
 futures = "0.3"
-image = { version = "0.25.9", default-features = false, features = [
+image = { version = "0.25.10", default-features = false, features = [
+    "ico",
     "jpeg",
     "png",
 ] }
-libc = { version = "0.2.180", optional = true }
+image-extras = { version = "0.1.0", default-features = false, features = [
+    "xpm",
+    "xbm",
+], optional = true }
+libc = { version = "0.2.183", optional = true }
 log = "0.4"
 mime = { version = "0.3.17", optional = true }
 palette = "0.7.6"
-raw-window-handle = "0.6"
 rfd = { version = "0.16.0", default-features = false, features = [
     "xdg-portal",
 ], optional = true }
@@ -135,24 +163,25 @@ slotmap = "1.1.1"
 smol = { version = "2.0.2", optional = true }
 thiserror = "2.0.18"
 taffy = { version = "0.9.2", features = ["grid"] }
-tokio = { version = "1.49.0", optional = true }
+tokio = { version = "1.50.0", optional = true }
 tracing = "0.1.44"
 unicode-segmentation = "1.12"
 url = "2.5.8"
-zbus = { version = "5.13.2", default-features = false, optional = true }
+zbus = { version = "5.14.0", default-features = false, optional = true }
+float-cmp = "0.10.0"
 
 # Enable DBus feature on Linux targets
 [target.'cfg(target_os = "linux")'.dependencies]
 cosmic-config = { path = "cosmic-config", features = ["dbus"] }
 cosmic-settings-daemon = { git = "https://github.com/pop-os/dbus-settings-bindings" }
-zbus = { version = "5.13.2", default-features = false }
+zbus = { version = "5.14.0", default-features = false }
 
-[target.'cfg(unix)'.dependencies]
+[target.'cfg(all(unix, not(target_os = "macos")))'.dependencies]
 freedesktop-icons = { package = "cosmic-freedesktop-icons", git = "https://github.com/pop-os/freedesktop-icons" }
 freedesktop-desktop-entry = { version = "0.8.1", optional = true }
 shlex = { version = "1.3.0", optional = true }
 
-[target.'cfg(not(unix))'.dependencies]
+[target.'cfg(any(not(unix), target_os = "macos"))'.dependencies]
 # Used to embed bundled icons for non-unix platforms.
 phf = { version = "0.13.1", features = ["macros"] }
 
@@ -225,4 +254,4 @@ exclude = ["iced"]
 dirs = "6.0.0"
 
 [dev-dependencies]
-tempfile = "3.24.0"
+tempfile = "3.27.0"

build.rs

@@ -3,7 +3,9 @@ use std::env;
 fn main() {
     println!("cargo::rerun-if-changed=build.rs");
 
-    if env::var_os("CARGO_CFG_UNIX").is_none() {
+    if env::var_os("CARGO_CFG_UNIX").is_none()
+        || env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("macos")
+    {
         generate_bundled_icons();
     }
 }

cosmic-config/Cargo.toml

@@ -11,9 +11,9 @@ subscription = ["iced_futures"]
 
 [dependencies]
 cosmic-settings-daemon = { git = "https://github.com/pop-os/dbus-settings-bindings", optional = true }
-zbus = { version = "5.13.2", default-features = false, optional = true }
+zbus = { version = "5.14.0", default-features = false, optional = true }
 atomicwrites = { git = "https://github.com/jackpot51/rust-atomicwrites" }
-calloop = { version = "0.14.3", optional = true }
+calloop = { version = "0.14.4", optional = true }
 notify = "8.2.0"
 ron = "0.12.0"
 serde = "1.0.228"
@@ -22,7 +22,7 @@ iced = { path = "../iced/", default-features = false, optional = true }
 iced_futures = { path = "../iced/futures/", default-features = false, optional = true }
 futures-util = { version = "0.3", optional = true }
 dirs.workspace = true
-tokio = { version = "1.49", optional = true, features = ["time"] }
+tokio = { version = "1.50", optional = true, features = ["time"] }
 async-std = { version = "1.13", optional = true }
 tracing = "0.1"
 
@@ -30,4 +30,4 @@ tracing = "0.1"
 xdg = "3.0"
 
 [target.'cfg(windows)'.dependencies]
-known-folders = "1.4.0"
+known-folders = "1.4.2"

cosmic-config/src/dbus.rs

@@ -1,11 +1,11 @@
-use std::ops::Deref;
+use std::{any::TypeId, ops::Deref};
 
 use crate::{CosmicConfigEntry, Update};
 use cosmic_settings_daemon::{Changed, ConfigProxy, CosmicSettingsDaemonProxy};
 use futures_util::SinkExt;
 use iced_futures::{
     Subscription,
-    futures::{self, Stream, StreamExt, future::pending},
+    futures::{self, StreamExt, future::pending},
     stream,
 };
 
@@ -57,6 +57,20 @@ impl Watcher {
     }
 }
 
+#[derive(Clone)]
+struct Wrapper(
+    TypeId,
+    CosmicSettingsDaemonProxy<'static>,
+    &'static str,
+    bool,
+);
+
+impl std::hash::Hash for Wrapper {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.0.hash(state);
+    }
+}
+
 #[allow(clippy::too_many_lines)]
 pub fn watcher_subscription<T: CosmicConfigEntry + Send + Sync + Default + 'static + Clone>(
     settings_daemon: CosmicSettingsDaemonProxy<'static>,
@@ -64,166 +78,185 @@ pub fn watcher_subscription<T: CosmicConfigEntry + Send + Sync + Default + 'stat
     is_state: bool,
 ) -> iced_futures::Subscription<Update<T>> {
     let id = std::any::TypeId::of::<T>();
-    Subscription::run_with_id(
-        (id, config_id),
-        watcher_stream(settings_daemon, config_id, is_state),
-    )
-}
+    Subscription::run_with(
+        Wrapper(id, settings_daemon, config_id, is_state),
+        |&Wrapper(_, ref settings_daemon, ref config_id, ref is_state)| {
+            let is_state = *is_state;
+            let config_id = *config_id;
+            let settings_daemon = settings_daemon.clone();
+            enum Change {
+                Changes(Changed),
+                OwnerChanged(bool),
+            }
+            stream::channel(
+                5,
+                move |mut tx: futures::channel::mpsc::Sender<Update<T>>| async move {
+                    let version = T::VERSION;
 
-fn watcher_stream<T: CosmicConfigEntry + Send + Sync + Default + 'static + Clone>(
-    settings_daemon: CosmicSettingsDaemonProxy<'static>,
-    config_id: &'static str,
-    is_state: bool,
-) -> impl Stream<Item = Update<T>> {
-    enum Change {
-        Changes(Changed),
-        OwnerChanged(bool),
-    }
-    stream::channel(5, move |mut tx| async move {
-        let version = T::VERSION;
+                    let Ok(cosmic_config) = (if is_state {
+                        crate::Config::new_state(config_id, version)
+                    } else {
+                        crate::Config::new(config_id, version)
+                    }) else {
+                        pending::<()>().await;
+                        unreachable!();
+                    };
 
-        let Ok(cosmic_config) = (if is_state {
-            crate::Config::new_state(config_id, version)
-        } else {
-            crate::Config::new(config_id, version)
-        }) else {
-            pending::<()>().await;
-            unreachable!();
-        };
+                    let mut attempts = 0;
 
-        let mut attempts = 0;
+                    loop {
+                        let watcher = if is_state {
+                            Watcher::new_state(&settings_daemon, config_id, version).await
+                        } else {
+                            Watcher::new_config(&settings_daemon, config_id, version).await
+                        };
+                        let Ok(watcher) = watcher else {
+                            tracing::error!("Failed to create watcher for {config_id}");
 
-        loop {
-            let watcher = if is_state {
-                Watcher::new_state(&settings_daemon, config_id, version).await
-            } else {
-                Watcher::new_config(&settings_daemon, config_id, version).await
-            };
-            let Ok(watcher) = watcher else {
-                tracing::error!("Failed to create watcher for {config_id}");
+                            #[cfg(feature = "tokio")]
+                            ::tokio::time::sleep(::tokio::time::Duration::from_secs(
+                                2_u64.pow(attempts),
+                            ))
+                            .await;
+                            #[cfg(feature = "async-std")]
+                            async_std::task::sleep(std::time::Duration::from_secs(
+                                2_u64.pow(attempts),
+                            ))
+                            .await;
+                            #[cfg(not(any(feature = "tokio", feature = "async-std")))]
+                            {
+                                pending::<()>().await;
+                                unreachable!();
+                            }
+                            attempts += 1;
+                            // The settings daemon has exited
+                            continue;
+                        };
+                        let Ok(changes) = watcher.receive_changed().await else {
+                            tracing::error!("Failed to listen for changes for {config_id}");
 
-                #[cfg(feature = "tokio")]
-                ::tokio::time::sleep(::tokio::time::Duration::from_secs(2_u64.pow(attempts))).await;
-                #[cfg(feature = "async-std")]
-                async_std::task::sleep(std::time::Duration::from_secs(2_u64.pow(attempts))).await;
-                #[cfg(not(any(feature = "tokio", feature = "async-std")))]
-                {
-                    pending::<()>().await;
-                    unreachable!();
-                }
-                attempts += 1;
-                // The settings daemon has exited
-                continue;
-            };
-            let Ok(changes) = watcher.receive_changed().await else {
-                tracing::error!("Failed to listen for changes for {config_id}");
+                            #[cfg(feature = "tokio")]
+                            ::tokio::time::sleep(::tokio::time::Duration::from_secs(
+                                2_u64.pow(attempts),
+                            ))
+                            .await;
+                            #[cfg(feature = "async-std")]
+                            async_std::task::sleep(std::time::Duration::from_secs(
+                                2_u64.pow(attempts),
+                            ))
+                            .await;
+                            #[cfg(not(any(feature = "tokio", feature = "async-std")))]
+                            {
+                                pending::<()>().await;
+                                unreachable!();
+                            }
+                            attempts += 1;
+                            // The settings daemon has exited
+                            continue;
+                        };
 
-                #[cfg(feature = "tokio")]
-                ::tokio::time::sleep(::tokio::time::Duration::from_secs(2_u64.pow(attempts))).await;
-                #[cfg(feature = "async-std")]
-                async_std::task::sleep(std::time::Duration::from_secs(2_u64.pow(attempts))).await;
-                #[cfg(not(any(feature = "tokio", feature = "async-std")))]
-                {
-                    pending::<()>().await;
-                    unreachable!();
-                }
-                attempts += 1;
-                // The settings daemon has exited
-                continue;
-            };
+                        let mut changes = changes.map(Change::Changes).fuse();
 
-            let mut changes = changes.map(Change::Changes).fuse();
+                        let Ok(owner_changed) = watcher.inner().receive_owner_changed().await
+                        else {
+                            tracing::error!("Failed to listen for owner changes for {config_id}");
+                            #[cfg(feature = "tokio")]
+                            ::tokio::time::sleep(::tokio::time::Duration::from_secs(
+                                2_u64.pow(attempts),
+                            ))
+                            .await;
+                            #[cfg(feature = "async-std")]
+                            async_std::task::sleep(std::time::Duration::from_secs(
+                                2_u64.pow(attempts),
+                            ))
+                            .await;
+                            #[cfg(not(any(feature = "tokio", feature = "async-std")))]
+                            {
+                                pending::<()>().await;
+                                unreachable!();
+                            }
+                            attempts += 1;
+                            // The settings daemon has exited
+                            continue;
+                        };
+                        let mut owner_changed = owner_changed
+                            .map(|c| Change::OwnerChanged(c.is_some()))
+                            .fuse();
 
-            let Ok(owner_changed) = watcher.inner().receive_owner_changed().await else {
-                tracing::error!("Failed to listen for owner changes for {config_id}");
-                #[cfg(feature = "tokio")]
-                ::tokio::time::sleep(::tokio::time::Duration::from_secs(2_u64.pow(attempts))).await;
-                #[cfg(feature = "async-std")]
-                async_std::task::sleep(std::time::Duration::from_secs(2_u64.pow(attempts))).await;
-                #[cfg(not(any(feature = "tokio", feature = "async-std")))]
-                {
-                    pending::<()>().await;
-                    unreachable!();
-                }
-                attempts += 1;
-                // The settings daemon has exited
-                continue;
-            };
-            let mut owner_changed = owner_changed
-                .map(|c| Change::OwnerChanged(c.is_some()))
-                .fuse();
+                        // update now, just in case we missed changes while setting up stream
+                        let mut config = match T::get_entry(&cosmic_config) {
+                            Ok(config) => config,
+                            Err((errors, default)) => {
+                                for why in &errors {
+                                    if why.is_err() {
+                                        if let crate::Error::GetKey(_, err) = &why {
+                                            if err.kind() == std::io::ErrorKind::NotFound {
+                                                // No system default config installed; don't error
+                                                continue;
+                                            }
+                                        }
+                                        tracing::error!("error getting config: {config_id} {why}");
+                                    }
+                                }
+                                default
+                            }
+                        };
 
-            // update now, just in case we missed changes while setting up stream
-            let mut config = match T::get_entry(&cosmic_config) {
-                Ok(config) => config,
-                Err((errors, default)) => {
-                    for why in &errors {
-                        if why.is_err() {
-                            if let crate::Error::GetKey(_, err) = &why {
-                                if err.kind() == std::io::ErrorKind::NotFound {
-                                    // No system default config installed; don't error
-                                    continue;
+                        if let Err(err) = tx
+                            .send(Update {
+                                errors: Vec::new(),
+                                keys: Vec::new(),
+                                config: config.clone(),
+                            })
+                            .await
+                        {
+                            tracing::error!("Failed to send config: {err}");
+                        }
+
+                        loop {
+                            let change: Changed = futures::select! {
+                                c = changes.next() => {
+                                    let Some(Change::Changes(c)) = c else {
+                                        break;
+                                    };
+                                    c
+                                }
+                                c = owner_changed.next() => {
+                                    let Some(Change::OwnerChanged(cont)) = c else {
+                                        break;
+                                    };
+                                    if cont {
+                                        continue;
+                                    } else {
+                                        // The settings daemon has exited
+                                        break;
+                                    }
+                                },
+                            };
+
+                            // Reset the attempts counter if we received a change
+                            attempts = 0;
+                            let Ok(args) = change.args() else {
+                                // The settings daemon has exited
+                                break;
+                            };
+                            let (errors, keys) = config.update_keys(&cosmic_config, &[args.key]);
+                            if !keys.is_empty() {
+                                if let Err(err) = tx
+                                    .send(Update {
+                                        errors,
+                                        keys,
+                                        config: config.clone(),
+                                    })
+                                    .await
+                                {
+                                    tracing::error!("Failed to send config update: {err}");
                                 }
                             }
-                            tracing::error!("error getting config: {config_id} {why}");
                         }
                     }
-                    default
-                }
-            };
-
-            if let Err(err) = tx
-                .send(Update {
-                    errors: Vec::new(),
-                    keys: Vec::new(),
-                    config: config.clone(),
-                })
-                .await
-            {
-                tracing::error!("Failed to send config: {err}");
-            }
-
-            loop {
-                let change: Changed = futures::select! {
-                    c = changes.next() => {
-                        let Some(Change::Changes(c)) = c else {
-                            break;
-                        };
-                        c
-                    }
-                    c = owner_changed.next() => {
-                        let Some(Change::OwnerChanged(cont)) = c else {
-                            break;
-                        };
-                        if cont {
-                            continue;
-                        } else {
-                            // The settings daemon has exited
-                            break;
-                        }
-                    },
-                };
-
-                // Reset the attempts counter if we received a change
-                attempts = 0;
-                let Ok(args) = change.args() else {
-                    // The settings daemon has exited
-                    break;
-                };
-                let (errors, keys) = config.update_keys(&cosmic_config, &[args.key]);
-                if !keys.is_empty() {
-                    if let Err(err) = tx
-                        .send(Update {
-                            errors,
-                            keys,
-                            config: config.clone(),
-                        })
-                        .await
-                    {
-                        tracing::error!("Failed to send config update: {err}");
-                    }
-                }
-            }
-        }
-    })
+                },
+            )
+        },
+    )
 }

cosmic-config/src/subscription.rs

@@ -25,7 +25,24 @@ pub fn config_subscription<
     config_id: Cow<'static, str>,
     config_version: u64,
 ) -> iced_futures::Subscription<crate::Update<T>> {
-    iced_futures::Subscription::run_with_id(id, watcher_stream(config_id, config_version, false))
+    iced_futures::Subscription::run_with(
+        (id, config_id, config_version, false),
+        // FIXME there are type issues related to the 'static lifetime of the Cow if this is extracted to a named function...
+        |(_, config_id, config_version, is_state)| {
+            let config_id = config_id.clone();
+            let config_version = *config_version;
+            let is_state = *is_state;
+
+            stream::channel(100, move |mut output| async move {
+                let config_id = config_id.clone();
+                let mut state = ConfigState::Init(config_id, config_version, is_state);
+
+                loop {
+                    state = start_listening::<T>(state, &mut output).await;
+                }
+            })
+        },
+    )
 }
 
 #[cold]
@@ -37,25 +54,23 @@ pub fn config_state_subscription<
     config_id: Cow<'static, str>,
     config_version: u64,
 ) -> iced_futures::Subscription<crate::Update<T>> {
-    iced_futures::Subscription::run_with_id(id, watcher_stream(config_id, config_version, true))
-}
-
-fn watcher_stream<T: 'static + Send + Sync + PartialEq + Clone + CosmicConfigEntry>(
-    config_id: Cow<'static, str>,
-    config_version: u64,
-    is_state: bool,
-) -> impl Stream<Item = crate::Update<T>> {
-    stream::channel(100, move |mut output| {
-        let config_id = config_id.clone();
-        async move {
+    iced_futures::Subscription::run_with(
+        (id, config_id, config_version, true),
+        |(_, config_id, config_version, is_state)| {
             let config_id = config_id.clone();
-            let mut state = ConfigState::Init(config_id, config_version, is_state);
+            let config_version = *config_version;
+            let is_state = *is_state;
 
-            loop {
-                state = start_listening::<T>(state, &mut output).await;
-            }
-        }
-    })
+            stream::channel(100, move |mut output| async move {
+                let config_id = config_id.clone();
+                let mut state = ConfigState::Init(config_id, config_version, is_state);
+
+                loop {
+                    state = start_listening::<T>(state, &mut output).await;
+                }
+            })
+        },
+    )
 }
 
 async fn start_listening<T: 'static + Send + Sync + PartialEq + Clone + CosmicConfigEntry>(

cosmic-theme/Cargo.toml

@@ -22,7 +22,7 @@ serde_json = { version = "1.0.149", optional = true, features = [
     "preserve_order",
 ] }
 ron = "0.12.0"
-csscolorparser = { version = "0.8.1", features = ["serde"] }
+csscolorparser = { version = "0.8.3", features = ["serde"] }
 cosmic-config = { path = "../cosmic-config/", default-features = false, features = [
     "subscription",
     "macro",
@@ -30,3 +30,10 @@ cosmic-config = { path = "../cosmic-config/", default-features = false, features
 configparser = "3.1.0"
 dirs.workspace = true
 thiserror = "2.0.18"
+
+[dev-dependencies]
+insta = "1.47.2"
+
+[profile.dev.package]
+insta.opt-level = 3
+similar.opt-level = 3

cosmic-theme/src/model/theme.rs

@@ -986,19 +986,19 @@ impl ThemeBuilder {
         let success = if let Some(success) = success {
             success.into_color()
         } else {
-            palette.as_ref().accent_green
+            palette.as_ref().bright_green
         };
 
         let warning = if let Some(warning) = warning {
             warning.into_color()
         } else {
-            palette.as_ref().accent_yellow
+            palette.as_ref().bright_orange
         };
 
         let destructive = if let Some(destructive) = destructive {
             destructive.into_color()
         } else {
-            palette.as_ref().accent_red
+            palette.as_ref().bright_red
         };
 
         let text_steps_array = text_tint.map(|c| steps(c, NonZeroUsize::new(100).unwrap()));

cosmic-theme/src/output/mod.rs

@@ -46,8 +46,10 @@ impl Theme {
     pub fn write_exports(&self) -> Result<(), OutputError> {
         let gtk_res = self.write_gtk4();
         let qt_res = self.write_qt();
+        let qt56ct_res = self.write_qt56ct();
         gtk_res?;
         qt_res?;
+        qt56ct_res?;
         Ok(())
     }
 
@@ -56,8 +58,10 @@ impl Theme {
     pub fn reset_exports() -> Result<(), OutputError> {
         let gtk_res = Theme::reset_gtk();
         let qt_res = Theme::reset_qt();
+        let qt56ct_res = Theme::reset_qt56ct();
         gtk_res?;
         qt_res?;
+        qt56ct_res?;
         Ok(())
     }
 }

cosmic-theme/src/output/qt56ct_output.rs

@@ -1,8 +1,11 @@
 use crate::Theme;
 use configparser::ini::Ini;
+use palette::{Mix, Srgba, WithAlpha, blend::Compose, rgb::Rgba};
 use std::{
     fs::{self, File},
+    io::Write,
     path::PathBuf,
+    vec,
 };
 
 use super::{OutputError, qt_settings_ini_style};
@@ -15,7 +18,117 @@ impl Theme {
     /// Increment this value when changes to qt{5,6}ct.conf are needed.
     /// If the config's version is outdated, we update several sections.
     /// Otherwise, only the light/dark mode is updated.
-    const COSMIC_QT_VERSION: u64 = 1;
+    const COSMIC_QT_VERSION: u64 = 2;
+
+    /// Produces a QPalette ini file for qt5ct and qt6ct.
+    ///
+    /// Example file: https://github.com/trialuser02/qt6ct/blob/master/colors/airy.conf
+    #[must_use]
+    #[cold]
+    pub fn as_qpalette(&self) -> String {
+        let lightest = if self.is_dark {
+            self.background.on
+        } else {
+            self.background.base
+        };
+        let darkest = if self.is_dark {
+            self.background.base
+        } else {
+            self.background.on
+        };
+        let active = QPaletteGroup {
+            window_text: self.background.on,
+            button: self.button.base,
+            light: self.button.base.mix(lightest, 0.1),
+            midlight: self.button.base.mix(lightest, 0.05),
+            dark: self.button.base.mix(darkest, 0.1),
+            mid: self.button.base.mix(darkest, 0.05),
+            text: self.background.component.on,
+            bright_text: lightest,
+            button_text: self.button.on,
+            base: self.background.component.base,
+            window: self.background.base,
+            shadow: darkest,
+            // selection colors are swapped to fix menu bar contrast
+            highlight: self.background.component.selected_text,
+            highlighted_text: self.background.component.selected,
+            link: self.link_button.on,
+            link_visited: self.link_button.on.mix(self.secondary.component.base, 0.2),
+            alternate_base: self.background.base.mix(self.accent.base, 0.05),
+            no_role: self.background.component.disabled,
+            tool_tip_base: self.background.component.base,
+            tool_tip_text: self.background.component.on,
+            placeholder_text: self.background.component.on.with_alpha(0.5),
+        };
+        let inactive = QPaletteGroup {
+            window_text: active.window_text.with_alpha(0.8),
+            text: active.text.with_alpha(0.8),
+            highlighted_text: active.highlighted_text.with_alpha(0.8),
+            tool_tip_text: active.tool_tip_text.with_alpha(0.8),
+            ..active
+        };
+        let disabled = QPaletteGroup {
+            button: self.button.disabled,
+            text: self.background.component.on_disabled,
+            button_text: self.button.on_disabled,
+            base: self.background.component.disabled,
+            highlighted_text: active.highlighted_text.with_alpha(0.5),
+            link: self.link_button.on_disabled,
+            link_visited: self
+                .link_button
+                .on_disabled
+                .mix(self.secondary.component.disabled, 0.2),
+            alternate_base: self.background.base.mix(self.accent.disabled, 0.05),
+            tool_tip_base: self.background.component.disabled,
+            tool_tip_text: self.background.component.on_disabled,
+            placeholder_text: self.background.component.on_disabled.with_alpha(0.5),
+            ..inactive
+        };
+
+        format!(
+            r#"# GENERATED BY COSMIC
+
+[ColorScheme]
+active_colors={}
+disabled_colors={}
+inactive_colors={}
+"#,
+            active.as_list(),
+            disabled.as_list(),
+            inactive.as_list(),
+        )
+    }
+
+    /// Writes the QPalette ini files to:
+    /// - `~/.config/qt6ct/colors/`
+    /// - `~/.config/qt5ct/colors/`
+    #[cold]
+    pub fn write_qt56ct(&self) -> Result<(), OutputError> {
+        let qpalette = self.as_qpalette();
+        let qt5ct_res = self.write_ct("qt5ct", &qpalette);
+        let qt6ct_res = self.write_ct("qt6ct", &qpalette);
+        qt5ct_res?;
+        qt6ct_res?;
+        Ok(())
+    }
+    #[must_use]
+    #[cold]
+    fn write_ct(&self, ct: &str, qpalette: &str) -> Result<(), OutputError> {
+        let file_path = Self::get_qpalette_path(ct, self.is_dark)?;
+        let tmp_file_path = file_path.with_extension("conf.new");
+
+        let mut tmp_file = File::create(&tmp_file_path).map_err(OutputError::Io)?;
+        let res = tmp_file
+            .write_all(qpalette.as_bytes())
+            .and_then(|_| tmp_file.flush())
+            .and_then(|_| std::fs::rename(&tmp_file_path, file_path));
+        if let Err(e) = res {
+            _ = std::fs::remove_file(&tmp_file_path);
+            return Err(OutputError::Io(e));
+        }
+
+        Ok(())
+    }
 
     /// Edits qt{5,6}ct.conf to use COSMIC styles if needed.
     #[cold]
@@ -39,7 +152,7 @@ impl Theme {
             .map_err(OutputError::Ini)?
             .unwrap_or_default();
 
-        let color_scheme_path = Self::get_qt_colors_path(is_dark)?;
+        let color_scheme_path = Self::get_qpalette_path(ct, is_dark)?;
         let icon_theme = if is_dark { "breeze-dark" } else { "breeze" };
 
         ini.set(
@@ -91,11 +204,48 @@ impl Theme {
         Ok(())
     }
 
+    /// Reset the applied qt56ct config by removing COSMIC-specific entries from the config file.
+    #[cold]
+    pub fn reset_qt56ct() -> Result<(), OutputError> {
+        let qt5ct_res = Self::reset_ct("qt5ct");
+        let qt6ct_res = Self::reset_ct("qt6ct");
+        qt5ct_res?;
+        qt6ct_res?;
+        Ok(())
+    }
+    #[must_use]
+    #[cold]
+    fn reset_ct(ct: &str) -> Result<(), OutputError> {
+        let path = Self::get_conf_path(ct)?;
+        let file_content = fs::read_to_string(&path).map_err(OutputError::Io)?;
+        let mut ini = Ini::new_cs();
+        ini.read(file_content).map_err(OutputError::Ini)?;
+
+        let old_version = ini
+            .getuint("Appearance", "cosmic_qt_version")
+            .map_err(OutputError::Ini)?
+            .unwrap_or_default();
+        if old_version == 0 {
+            return Ok(());
+        }
+
+        ini.remove_key("Appearance", "cosmic_qt_version");
+        ini.remove_key("Appearance", "color_scheme_path");
+        ini.remove_key("Appearance", "icon_theme");
+
+        ini.pretty_write(path, &qt_settings_ini_style())
+            .map_err(OutputError::Io)?;
+        Ok(())
+    }
+
     /// Returns the file paths of the form `~/.config/ct/ct.conf`:
     /// e.g. `~/.config/qt6ct/qt6ct.conf`.
     ///
     /// The file and its parent directory are created if they don't exist.
+    #[cold]
     fn get_conf_path(ct: &str) -> Result<PathBuf, OutputError> {
+        assert!(ct == "qt5ct" || ct == "qt6ct");
+
         let Some(mut config_dir) = dirs::config_dir() else {
             return Err(OutputError::MissingConfigDir);
         };
@@ -111,4 +261,155 @@ impl Theme {
 
         Ok(file_path)
     }
+
+    /// Gets a path like `~/.config/qt6ct/colors/CosmicDark.conf`
+    ///
+    /// Its parent directory is created if it doesn't exist.
+    #[cold]
+    fn get_qpalette_path(ct: &str, is_dark: bool) -> Result<PathBuf, OutputError> {
+        assert!(ct == "qt5ct" || ct == "qt6ct");
+
+        let Some(mut config_dir) = dirs::config_dir() else {
+            return Err(OutputError::MissingConfigDir);
+        };
+        config_dir.push(&ct);
+        config_dir.push("colors");
+        if !config_dir.exists() {
+            fs::create_dir_all(&config_dir).map_err(OutputError::Io)?;
+        }
+
+        let file_name = if is_dark {
+            "CosmicDark.conf"
+        } else {
+            "CosmicLight.conf"
+        };
+
+        Ok(config_dir.join(file_name))
+    }
+}
+
+/// Defines the different symbolic color roles used in current GUIs.
+///
+/// qt5ct and qt6ct consume this as a list of colors, ordered by ColorRole:
+/// - https://doc.qt.io/qt-6/qpalette.html#ColorRole-enum
+/// - https://doc.qt.io/archives/qt-5.15/qpalette.html#ColorRole-enum
+struct QPaletteGroup {
+    /// A general foreground color.
+    window_text: Srgba,
+    /// The general button background color.
+    button: Srgba,
+    /// Lighter than [button] color, used mostly for 3D bevel and shadow effects.
+    light: Srgba,
+    /// Between [button] and [light], used mostly for 3D bevel and shadow effects.
+    midlight: Srgba,
+    /// Darker than [button], used mostly for 3D bevel and shadow effects.
+    dark: Srgba,
+    /// Between [button] and [dark], used mostly for 3D bevel and shadow effects.
+    mid: Srgba,
+    /// The foreground color used with [base].
+    text: Srgba,
+    /// A text color that is very different from [window_text], and contrasts well with e.g. [dark].
+    /// Typically used for text that needs to be drawn where [text] or [window_text] would give poor contrast, such as on pressed push buttons.
+    bright_text: Srgba,
+    /// A foreground color used with the [button] color.
+    button_text: Srgba,
+    /// Used mostly as the background color for text entry widgets, but can also be used for other painting -
+    /// such as the background of combobox drop down lists and toolbar handles.
+    base: Srgba,
+    /// A general background color.
+    window: Srgba,
+    /// A very dark color, used mostly for 3D bevel and shadow effects.
+    /// Opaque black by default.
+    shadow: Srgba,
+    /// A color to indicate a selected item or the current item.
+    highlight: Srgba,
+    /// A text color that contrasts with [highlight].
+    highlighted_text: Srgba,
+    /// A text color used for unvisited hyperlinks.
+    link: Srgba,
+    /// A text color used for already visited hyperlinks.
+    link_visited: Srgba,
+    /// Used as the alternate background color in views with alternating row colors.
+    alternate_base: Srgba,
+    /// No role; this special role is often used to indicate that a role has not been assigned.
+    no_role: Srgba,
+    /// Used as the background color for QToolTip and QWhatsThis.
+    /// Tool tips use the inactive color group of QPalette, because tool tips are not active windows.
+    tool_tip_base: Srgba,
+    /// Used as the foreground color for QToolTip and QWhatsThis.
+    /// Tool tips use the inactive color group of QPalette, because tool tips are not active windows.
+    tool_tip_text: Srgba,
+    /// Used as the placeholder color for various text input widgets.
+    placeholder_text: Srgba,
+    // /// [accent] only exists since Qt 6.6. Including it here breaks qt5ct.
+    // /// When omitted, it defaults to [highlight].
+    // accent: Srgba,
+}
+
+impl QPaletteGroup {
+    /// Returns a comma-separated list of the colors as hex codes.
+    /// E.g. `#ff000000, #ffdcdcdc, ...`
+    ///
+    /// Any transparent colors are flattened with [base] to avoid issues with
+    /// the Fusion style.
+    fn as_list(&self) -> String {
+        let colors = vec![
+            to_argb_hex(self.window_text.over(self.base)),
+            to_argb_hex(self.button.over(self.base)),
+            to_argb_hex(self.light.over(self.base)),
+            to_argb_hex(self.midlight.over(self.base)),
+            to_argb_hex(self.dark.over(self.base)),
+            to_argb_hex(self.mid.over(self.base)),
+            to_argb_hex(self.text.over(self.base)),
+            to_argb_hex(self.bright_text.over(self.base)),
+            to_argb_hex(self.button_text.over(self.base)),
+            to_argb_hex(self.base.over(self.base)),
+            to_argb_hex(self.window.over(self.base)),
+            to_argb_hex(self.shadow.over(self.base)),
+            to_argb_hex(self.highlight.over(self.base)),
+            to_argb_hex(self.highlighted_text.over(self.base)),
+            to_argb_hex(self.link.over(self.base)),
+            to_argb_hex(self.link_visited.over(self.base)),
+            to_argb_hex(self.alternate_base.over(self.base)),
+            to_argb_hex(self.no_role.over(self.base)),
+            to_argb_hex(self.tool_tip_base.over(self.base)),
+            to_argb_hex(self.tool_tip_text.over(self.base)),
+            to_argb_hex(self.placeholder_text.over(self.base)),
+        ];
+        colors.join(", ")
+    }
+}
+
+/// Converts a color to a hex string in the format `#AARRGGBB`.
+/// Do not use [to_hex] since that uses the format `RRGGBBAA`.
+fn to_argb_hex(c: Srgba) -> String {
+    let c_u8: Rgba<palette::encoding::Srgb, u8> = c.into_format();
+    format!(
+        "#{:02x}{:02x}{:02x}{:02x}",
+        c_u8.alpha, c_u8.red, c_u8.green, c_u8.blue
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_color_to_argb_hex() {
+        let color = Srgba::new(0x33, 0x55, 0x77, 0xff);
+        let argb = to_argb_hex(color.into());
+        assert_eq!(argb, "#ff335577");
+    }
+
+    #[test]
+    fn test_light_default_qpalette() {
+        let light_default_qpalette = Theme::light_default().as_qpalette();
+        insta::assert_snapshot!(light_default_qpalette);
+    }
+
+    #[test]
+    fn test_dark_default_qpalette() {
+        let dark_default_qpalette = Theme::dark_default().as_qpalette();
+        insta::assert_snapshot!(dark_default_qpalette);
+    }
 }

cosmic-theme/src/output/qt_output.rs

@@ -14,10 +14,11 @@ impl Theme {
     /// Produces a color scheme ini file for Qt.
     ///
     /// Some high-level documentation for this file can be found at:
-    /// https://web.archive.org/web/20250402234329/https://docs.kde.org/stable5/en/plasma-workspace/kcontrol/colors/
+    /// - https://api.kde.org/kcolorscheme.html
+    /// - https://web.archive.org/web/20250402234329/https://docs.kde.org/stable5/en/plasma-workspace/kcontrol/colors/
     #[must_use]
     #[cold]
-    pub fn as_qt(&self) -> String {
+    pub fn as_kcolorscheme(&self) -> String {
         // Usually, disabled elements will have strongly reduced contrast and are often notably darker or lighter
         let disabled_color_effects = IniColorEffects {
             color: self.button.disabled,
@@ -41,7 +42,7 @@ impl Theme {
 
         let bg = self.background.base;
         // the background container
-        let view_colors = IniColors {
+        let window_colors = IniColors {
             background_alternate: bg.mix(self.accent.base, 0.05),
             background_normal: bg,
             decoration_focus: self.accent_text_color(),
@@ -56,16 +57,17 @@ impl Theme {
             foreground_visited: self.accent_text_color(),
         };
         // components inside the background container
-        let window_colors = IniColors {
+        let view_colors = IniColors {
             background_alternate: self.background.component.base.mix(self.accent.base, 0.05),
             background_normal: self.background.component.base,
-            ..view_colors
+            ..window_colors
         };
 
         // selected text and items
         let selection_colors = {
-            let selected = self.background.component.selected;
-            let selected_text = self.background.component.selected_text;
+            // selection colors are swapped to fix menu bar contrast
+            let selected = self.background.component.selected_text;
+            let selected_text = self.background.component.selected;
             IniColors {
                 background_alternate: selected.mix(bg, 0.5),
                 background_normal: selected,
@@ -92,8 +94,11 @@ impl Theme {
         let complementary_colors = {
             let dark = if self.is_dark {
                 self.clone()
+            } else if cfg!(test) {
+                // For reproducible results in tests, use the default dark theme
+                Theme::dark_default()
             } else {
-                Theme::light_config()
+                Theme::dark_config()
                     .ok()
                     .as_ref()
                     .and_then(|conf| Theme::get_entry(conf).ok())
@@ -116,10 +121,10 @@ impl Theme {
         };
 
         // headers in cosmic don't have a background
-        let header_colors = &view_colors;
-        let header_colors_inactive = &view_colors;
+        let header_colors = &window_colors;
+        let header_colors_inactive = &window_colors;
         // tool tips, "What's This" tips, and similar elements
-        let tooltip_colors = &window_colors;
+        let tooltip_colors = &view_colors;
 
         let general_color_scheme = if self.is_dark {
             "CosmicDark"
@@ -198,7 +203,7 @@ widgetStyle=qt6ct-style
             format_ini_colors(&tooltip_colors, bg),
             format_ini_colors(&view_colors, bg),
             format_ini_colors(&window_colors, bg),
-            format_ini_wm_colors(&view_colors, self.is_dark),
+            format_ini_wm_colors(&window_colors, self.is_dark),
         )
     }
 
@@ -212,14 +217,14 @@ widgetStyle=qt6ct-style
     /// Returns an `OutputError` if there is an error writing the colors file.
     #[cold]
     pub fn write_qt(&self) -> Result<(), OutputError> {
-        let colors = self.as_qt();
-        let file_path = Self::get_qt_colors_path(self.is_dark)?;
+        let kcolorscheme = self.as_kcolorscheme();
+        let file_path = Self::get_kcolorscheme_path(self.is_dark)?;
         let tmp_file_path = file_path.with_extension("colors.new");
 
         // Write to tmp_file_path first, then move it to file_path
         let mut tmp_file = File::create(&tmp_file_path).map_err(OutputError::Io)?;
         let res = tmp_file
-            .write_all(colors.as_bytes())
+            .write_all(kcolorscheme.as_bytes())
             .and_then(|_| tmp_file.flush())
             .and_then(|_| std::fs::rename(&tmp_file_path, file_path));
         if let Err(e) = res {
@@ -245,7 +250,7 @@ widgetStyle=qt6ct-style
         let kdeglobals_file = config_dir.join("kdeglobals");
         let mut kdeglobals_ini = Self::read_ini(&kdeglobals_file)?;
 
-        let src_file = Self::get_qt_colors_path(is_dark)?;
+        let src_file = Self::get_kcolorscheme_path(is_dark)?;
         let src_ini = Self::read_ini(&src_file)?;
 
         Self::backup_non_cosmic_kdeglobals(&kdeglobals_ini, &kdeglobals_file)
@@ -288,7 +293,7 @@ widgetStyle=qt6ct-style
         }
 
         let is_dark = false; // doesn't matter since we're only reading keys
-        let src_file = Self::get_qt_colors_path(is_dark)?;
+        let src_file = Self::get_kcolorscheme_path(is_dark)?;
         let src_ini = Self::read_ini(&src_file)?;
 
         for (section, key_value) in src_ini.get_map_ref() {
@@ -303,8 +308,8 @@ widgetStyle=qt6ct-style
         Ok(())
     }
 
-    /// Gets a path like `~/.config/color-schemes/CosmicDark.colors`
-    pub fn get_qt_colors_path(is_dark: bool) -> Result<PathBuf, OutputError> {
+    /// Gets a path like `~/.local/share/color-schemes/CosmicDark.colors`
+    fn get_kcolorscheme_path(is_dark: bool) -> Result<PathBuf, OutputError> {
         let Some(mut data_dir) = dirs::data_dir() else {
             return Err(OutputError::MissingDataDir);
         };
@@ -520,3 +525,44 @@ impl ColorEffect {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_opaque_color_to_rgb() {
+        let color = Srgba::new(30.0 / 255.0, 50.0 / 255.0, 70.0 / 255.0, 1.0);
+        let bg = Srgba::new(1.0, 1.0, 1.0, 1.0);
+        let result = to_rgb(color, bg);
+        assert_eq!(result, "30,50,70");
+    }
+
+    #[test]
+    fn test_transparent_color_to_rgb() {
+        let color = Srgba::new(0.0, 0.0, 0.0, 0.0);
+        let bg = Srgba::new(1.0, 1.0, 1.0, 1.0);
+        let result = to_rgb(color, bg);
+        assert_eq!(result, "255,255,255");
+    }
+
+    #[test]
+    fn test_translucent_color_to_rgb() {
+        let color = Srgba::new(0.0, 0.0, 0.0, 0.9);
+        let bg = Srgba::new(1.0, 1.0, 1.0, 1.0);
+        let result = to_rgb(color, bg);
+        assert_eq!(result, "26,26,26");
+    }
+
+    #[test]
+    fn test_light_default_kcolorscheme() {
+        let light_default_kcolorscheme = Theme::light_default().as_kcolorscheme();
+        insta::assert_snapshot!(light_default_kcolorscheme);
+    }
+
+    #[test]
+    fn test_dark_default_kcolorscheme() {
+        let dark_default_kcolorscheme = Theme::dark_default().as_kcolorscheme();
+        insta::assert_snapshot!(dark_default_kcolorscheme);
+    }
+}

cosmic-theme/src/output/snapshots/cosmic_theme__output__qt56ct_output__tests__dark_default_qpalette.snap

@@ -0,0 +1,10 @@
+---
+source: cosmic-theme/src/output/qt56ct_output.rs
+expression: dark_default_qpalette
+---
+# GENERATED BY COSMIC
+
+[ColorScheme]
+active_colors=#ffe7e7e7, #ff4a4a4a, #ff555555, #ff505050, #ff4f4f4f, #ff4d4d4d, #ffc0c0c0, #ffe7e7e7, #ffc0c0c0, #ff2e2e2e, #ff1b1b1b, #ff1b1b1b, #ff63d0df, #ff434343, #ff63d0df, #ff5bb2be, #ff1f2425, #ff2e2e2e, #ff2e2e2e, #ffc0c0c0, #ff777777
+disabled_colors=#e6d3d3d3, #8f474747, #a9696969, #a4626262, #a95f5f5f, #a45d5d5d, #d2a1a1a1, #ffe7e7e7, #d2a1a1a1, #bf2e2e2e, #ff1b1b1b, #ff1b1b1b, #ff63d0df, #bf3c3c3c, #bf30555a, #bf324f53, #ff1f2425, #bf2e2e2e, #bf2e2e2e, #d2a1a1a1, #bf909090
+inactive_colors=#ffc2c2c2, #ff4a4a4a, #ff555555, #ff505050, #ff4f4f4f, #ff4d4d4d, #ffa3a3a3, #ffe7e7e7, #ffc0c0c0, #ff2e2e2e, #ff1b1b1b, #ff1b1b1b, #ff63d0df, #ff3f3f3f, #ff63d0df, #ff5bb2be, #ff1f2425, #ff2e2e2e, #ff2e2e2e, #ffa3a3a3, #ff777777

cosmic-theme/src/output/snapshots/cosmic_theme__output__qt56ct_output__tests__light_default_qpalette.snap

@@ -0,0 +1,10 @@
+---
+source: cosmic-theme/src/output/qt56ct_output.rs
+expression: light_default_qpalette
+---
+# GENERATED BY COSMIC
+
+[ColorScheme]
+active_colors=#ff121212, #ffc3c3c3, #ffbababa, #ffbebebe, #ffb3b3b3, #ffbbbbbb, #ff272727, #ffd7d7d7, #ff272727, #fff5f5f5, #ffd7d7d7, #ff121212, #ff00525a, #fff6f6f6, #ff00525a, #ff317379, #ffccd0d1, #fff5f5f5, #fff5f5f5, #ff272727, #ff8e8e8e
+disabled_colors=#e62b2b2b, #8fc9c9c9, #a99b9b9b, #a4a0a0a0, #a9929292, #a49b9b9b, #d2535353, #ffd7d7d7, #d2535353, #bff5f5f5, #ffd7d7d7, #ff121212, #ff00525a, #bff6f6f6, #bf526d70, #bf72888a, #ffccd0d1, #bff5f5f5, #bff5f5f5, #d2535353, #bf6c6c6c
+inactive_colors=#ff3f3f3f, #ffc3c3c3, #ffbababa, #ffbebebe, #ffb3b3b3, #ffbbbbbb, #ff505050, #ffd7d7d7, #ff272727, #fff5f5f5, #ffd7d7d7, #ff121212, #ff00525a, #fff6f6f6, #ff00525a, #ff317379, #ffccd0d1, #fff5f5f5, #fff5f5f5, #ff505050, #ff8e8e8e

cosmic-theme/src/output/snapshots/cosmic_theme__output__qt_output__tests__dark_default_kcolorscheme.snap

@@ -0,0 +1,157 @@
+---
+source: cosmic-theme/src/output/qt_output.rs
+expression: dark_default_kcolorscheme
+---
+# GENERATED BY COSMIC
+
+[ColorEffects:Disabled]
+Color=43,43,43
+ColorAmount=0
+ColorEffect=0
+ContrastAmount=0.65
+ContrastEffect=1
+IntensityAmount=0.1
+IntensityEffect=2
+
+[ColorEffects:Inactive]
+ChangeSelectionColor=false
+Enable=false
+Color=27,27,27
+ColorAmount=0.025
+ColorEffect=2
+ContrastAmount=0.1
+ContrastEffect=2
+IntensityAmount=0
+IntensityEffect=0
+
+[Colors:Button]
+BackgroundAlternate=99,208,223
+BackgroundNormal=60,60,60
+DecorationFocus=99,208,223
+DecorationHover=99,208,223
+ForegroundActive=99,208,223
+ForegroundInactive=211,211,211
+ForegroundLink=99,208,223
+ForegroundNegative=255,160,154
+ForegroundNeutral=255,163,125
+ForegroundNormal=231,231,231
+ForegroundPositive=94,219,140
+ForegroundVisited=99,208,223
+
+[Colors:Complementary]
+BackgroundAlternate=99,208,223
+BackgroundNormal=27,27,27
+DecorationFocus=99,208,223
+DecorationHover=99,208,223
+ForegroundActive=99,208,223
+ForegroundInactive=211,211,211
+ForegroundLink=99,208,223
+ForegroundNegative=255,160,154
+ForegroundNeutral=255,163,125
+ForegroundNormal=231,231,231
+ForegroundPositive=94,219,140
+ForegroundVisited=99,208,223
+
+[Colors:Header]
+BackgroundAlternate=31,36,37
+BackgroundNormal=27,27,27
+DecorationFocus=99,208,223
+DecorationHover=99,208,223
+ForegroundActive=99,208,223
+ForegroundInactive=211,211,211
+ForegroundLink=99,208,223
+ForegroundNegative=255,160,154
+ForegroundNeutral=255,163,125
+ForegroundNormal=231,231,231
+ForegroundPositive=94,219,140
+ForegroundVisited=99,208,223
+
+[Colors:Header][Inactive]
+BackgroundAlternate=31,36,37
+BackgroundNormal=27,27,27
+DecorationFocus=99,208,223
+DecorationHover=99,208,223
+ForegroundActive=99,208,223
+ForegroundInactive=211,211,211
+ForegroundLink=99,208,223
+ForegroundNegative=255,160,154
+ForegroundNeutral=255,163,125
+ForegroundNormal=231,231,231
+ForegroundPositive=94,219,140
+ForegroundVisited=99,208,223
+
+[Colors:Selection]
+BackgroundAlternate=63,118,125
+BackgroundNormal=99,208,223
+DecorationFocus=99,208,223
+DecorationHover=99,208,223
+ForegroundActive=67,67,67
+ForegroundInactive=83,138,145
+ForegroundLink=27,27,27
+ForegroundNegative=255,160,154
+ForegroundNeutral=255,163,125
+ForegroundNormal=67,67,67
+ForegroundPositive=94,219,140
+ForegroundVisited=99,208,223
+
+[Colors:Tooltip]
+BackgroundAlternate=49,55,55
+BackgroundNormal=46,46,46
+DecorationFocus=99,208,223
+DecorationHover=99,208,223
+ForegroundActive=99,208,223
+ForegroundInactive=211,211,211
+ForegroundLink=99,208,223
+ForegroundNegative=255,160,154
+ForegroundNeutral=255,163,125
+ForegroundNormal=231,231,231
+ForegroundPositive=94,219,140
+ForegroundVisited=99,208,223
+
+[Colors:View]
+BackgroundAlternate=49,55,55
+BackgroundNormal=46,46,46
+DecorationFocus=99,208,223
+DecorationHover=99,208,223
+ForegroundActive=99,208,223
+ForegroundInactive=211,211,211
+ForegroundLink=99,208,223
+ForegroundNegative=255,160,154
+ForegroundNeutral=255,163,125
+ForegroundNormal=231,231,231
+ForegroundPositive=94,219,140
+ForegroundVisited=99,208,223
+
+[Colors:Window]
+BackgroundAlternate=31,36,37
+BackgroundNormal=27,27,27
+DecorationFocus=99,208,223
+DecorationHover=99,208,223
+ForegroundActive=99,208,223
+ForegroundInactive=211,211,211
+ForegroundLink=99,208,223
+ForegroundNegative=255,160,154
+ForegroundNeutral=255,163,125
+ForegroundNormal=231,231,231
+ForegroundPositive=94,219,140
+ForegroundVisited=99,208,223
+
+[General]
+ColorScheme=CosmicDark
+Name=COSMIC Dark
+shadeSortColumn=true
+
+[Icons]
+Theme=breeze-dark
+
+[KDE]
+contrast=4
+widgetStyle=qt6ct-style
+
+[WM]
+activeBackground=27,27,27
+activeBlend=99,208,223
+activeForeground=99,208,223
+inactiveBackground=27,27,27
+inactiveBlend=99,208,223
+inactiveForeground=99,208,223

cosmic-theme/src/output/snapshots/cosmic_theme__output__qt_output__tests__light_default_kcolorscheme.snap

@@ -0,0 +1,157 @@
+---
+source: cosmic-theme/src/output/qt_output.rs
+expression: light_default_kcolorscheme
+---
+# GENERATED BY COSMIC
+
+[ColorEffects:Disabled]
+Color=194,194,194
+ColorAmount=0
+ColorEffect=0
+ContrastAmount=0.65
+ContrastEffect=1
+IntensityAmount=0.1
+IntensityEffect=2
+
+[ColorEffects:Inactive]
+ChangeSelectionColor=false
+Enable=false
+Color=215,215,215
+ColorAmount=0.025
+ColorEffect=2
+ContrastAmount=0.1
+ContrastEffect=2
+IntensityAmount=0
+IntensityEffect=0
+
+[Colors:Button]
+BackgroundAlternate=0,82,90
+BackgroundNormal=173,173,173
+DecorationFocus=0,82,90
+DecorationHover=0,82,90
+ForegroundActive=0,82,90
+ForegroundInactive=38,38,38
+ForegroundLink=0,82,90
+ForegroundNegative=137,4,24
+ForegroundNeutral=121,44,0
+ForegroundNormal=18,18,18
+ForegroundPositive=0,87,44
+ForegroundVisited=0,82,90
+
+[Colors:Complementary]
+BackgroundAlternate=99,208,223
+BackgroundNormal=27,27,27
+DecorationFocus=99,208,223
+DecorationHover=99,208,223
+ForegroundActive=99,208,223
+ForegroundInactive=211,211,211
+ForegroundLink=99,208,223
+ForegroundNegative=255,160,154
+ForegroundNeutral=255,163,125
+ForegroundNormal=231,231,231
+ForegroundPositive=94,219,140
+ForegroundVisited=99,208,223
+
+[Colors:Header]
+BackgroundAlternate=204,208,209
+BackgroundNormal=215,215,215
+DecorationFocus=0,82,90
+DecorationHover=0,82,90
+ForegroundActive=0,82,90
+ForegroundInactive=38,38,38
+ForegroundLink=0,82,90
+ForegroundNegative=137,4,24
+ForegroundNeutral=121,44,0
+ForegroundNormal=18,18,18
+ForegroundPositive=0,87,44
+ForegroundVisited=0,82,90
+
+[Colors:Header][Inactive]
+BackgroundAlternate=204,208,209
+BackgroundNormal=215,215,215
+DecorationFocus=0,82,90
+DecorationHover=0,82,90
+ForegroundActive=0,82,90
+ForegroundInactive=38,38,38
+ForegroundLink=0,82,90
+ForegroundNegative=137,4,24
+ForegroundNeutral=121,44,0
+ForegroundNormal=18,18,18
+ForegroundPositive=0,87,44
+ForegroundVisited=0,82,90
+
+[Colors:Selection]
+BackgroundAlternate=108,149,152
+BackgroundNormal=0,82,90
+DecorationFocus=0,82,90
+DecorationHover=0,82,90
+ForegroundActive=246,246,246
+ForegroundInactive=123,164,168
+ForegroundLink=215,215,215
+ForegroundNegative=137,4,24
+ForegroundNeutral=121,44,0
+ForegroundNormal=246,246,246
+ForegroundPositive=0,87,44
+ForegroundVisited=0,82,90
+
+[Colors:Tooltip]
+BackgroundAlternate=233,237,237
+BackgroundNormal=245,245,245
+DecorationFocus=0,82,90
+DecorationHover=0,82,90
+ForegroundActive=0,82,90
+ForegroundInactive=38,38,38
+ForegroundLink=0,82,90
+ForegroundNegative=137,4,24
+ForegroundNeutral=121,44,0
+ForegroundNormal=18,18,18
+ForegroundPositive=0,87,44
+ForegroundVisited=0,82,90
+
+[Colors:View]
+BackgroundAlternate=233,237,237
+BackgroundNormal=245,245,245
+DecorationFocus=0,82,90
+DecorationHover=0,82,90
+ForegroundActive=0,82,90
+ForegroundInactive=38,38,38
+ForegroundLink=0,82,90
+ForegroundNegative=137,4,24
+ForegroundNeutral=121,44,0
+ForegroundNormal=18,18,18
+ForegroundPositive=0,87,44
+ForegroundVisited=0,82,90
+
+[Colors:Window]
+BackgroundAlternate=204,208,209
+BackgroundNormal=215,215,215
+DecorationFocus=0,82,90
+DecorationHover=0,82,90
+ForegroundActive=0,82,90
+ForegroundInactive=38,38,38
+ForegroundLink=0,82,90
+ForegroundNegative=137,4,24
+ForegroundNeutral=121,44,0
+ForegroundNormal=18,18,18
+ForegroundPositive=0,87,44
+ForegroundVisited=0,82,90
+
+[General]
+ColorScheme=CosmicLight
+Name=COSMIC Light
+shadeSortColumn=true
+
+[Icons]
+Theme=breeze
+
+[KDE]
+contrast=4
+widgetStyle=qt6ct-style
+
+[WM]
+activeBackground=215,215,215
+activeBlend=215,215,215
+activeForeground=0,82,90
+inactiveBackground=215,215,215
+inactiveBlend=215,215,215
+inactiveForeground=0,82,90

cosmic-theme/src/steps.rs

@@ -145,7 +145,6 @@ pub fn is_valid_srgb(c: Srgba) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use almost::equal;
     use palette::{OklabHue, Srgba};
 
     use super::{is_valid_srgb, oklch_to_srgba_nearest_chroma};
@@ -173,57 +172,57 @@ mod tests {
     fn test_conversion_boundaries() {
         let c1 = palette::Oklcha::new(0.0, 0.288, OklabHue::from_degrees(0.0), 1.0);
         let srgb = oklch_to_srgba_nearest_chroma(c1);
-        equal(srgb.red, 0.0);
-        equal(srgb.blue, 0.0);
-        equal(srgb.green, 0.0);
+        almost::zero(srgb.red);
+        almost::zero(srgb.blue);
+        almost::zero(srgb.green);
 
         let c1 = palette::Oklcha::new(1.0, 0.288, OklabHue::from_degrees(0.0), 1.0);
         let srgb = oklch_to_srgba_nearest_chroma(c1);
 
-        equal(srgb.red, 1.0);
-        equal(srgb.blue, 1.0);
-        equal(srgb.green, 1.0);
+        almost::equal(srgb.red, 1.0);
+        almost::equal(srgb.blue, 1.0);
+        almost::equal(srgb.green, 1.0);
     }
 
     #[test]
     fn test_conversion_colors() {
         let c1 = palette::Oklcha::new(0.4608, 0.11111, OklabHue::new(57.31), 1.0);
         let srgb = oklch_to_srgba_nearest_chroma(c1).into_format::<u8, u8>();
-        assert!(srgb.red == 133);
-        assert!(srgb.green == 69);
-        assert!(srgb.blue == 0);
+        assert_eq!(srgb.red, 133);
+        assert_eq!(srgb.green, 69);
+        assert_eq!(srgb.blue, 0);
 
         let c1 = palette::Oklcha::new(0.30, 0.08, OklabHue::new(35.0), 1.0);
         let srgb = oklch_to_srgba_nearest_chroma(c1).into_format::<u8, u8>();
-        assert!(srgb.red == 78);
-        assert!(srgb.green == 27);
-        assert!(srgb.blue == 15);
+        assert_eq!(srgb.red, 78);
+        assert_eq!(srgb.green, 27);
+        assert_eq!(srgb.blue, 15);
 
         let c1 = palette::Oklcha::new(0.757, 0.146, OklabHue::new(301.2), 1.0);
         let srgb = oklch_to_srgba_nearest_chroma(c1).into_format::<u8, u8>();
-        assert!(srgb.red == 192);
-        assert!(srgb.green == 153);
-        assert!(srgb.blue == 253);
+        assert_eq!(srgb.red, 192);
+        assert_eq!(srgb.green, 153);
+        assert_eq!(srgb.blue, 253);
     }
 
     #[test]
     fn test_conversion_fallback_colors() {
         let c1 = palette::Oklcha::new(0.70, 0.284, OklabHue::new(35.0), 1.0);
         let srgb = oklch_to_srgba_nearest_chroma(c1).into_format::<u8, u8>();
-        assert!(srgb.red == 255);
-        assert!(srgb.green == 103);
-        assert!(srgb.blue == 65);
+        assert_eq!(srgb.red, 255);
+        assert_eq!(srgb.green, 102);
+        assert_eq!(srgb.blue, 65);
 
         let c1 = palette::Oklcha::new(0.757, 0.239, OklabHue::new(301.2), 1.0);
         let srgb = oklch_to_srgba_nearest_chroma(c1).into_format::<u8, u8>();
-        assert!(srgb.red == 193);
-        assert!(srgb.green == 152);
-        assert!(srgb.blue == 255);
+        assert_eq!(srgb.red, 193);
+        assert_eq!(srgb.green, 152);
+        assert_eq!(srgb.blue, 255);
 
         let c1 = palette::Oklcha::new(0.163, 0.333, OklabHue::new(141.0), 1.0);
         let srgb = oklch_to_srgba_nearest_chroma(c1).into_format::<u8, u8>();
-        assert!(srgb.red == 1);
-        assert!(srgb.green == 19);
-        assert!(srgb.blue == 0);
+        assert_eq!(srgb.red, 1);
+        assert_eq!(srgb.green, 19);
+        assert_eq!(srgb.blue, 0);
     }
 }

examples/about/src/main.rs

@@ -132,7 +132,7 @@ impl cosmic::Application for App {
     fn view(&self) -> Element<'_, Self::Message> {
         let show_about_button = widget::button::text("Show about").on_press(Message::ToggleAbout);
         let centered = cosmic::widget::container(
-            widget::column()
+            widget::column::with_capacity(1)
                 .push(show_about_button)
                 .width(Length::Fill)
                 .height(Length::Shrink)

examples/applet/Cargo.toml

@@ -13,6 +13,6 @@ env_logger = "0.10.2"
 log = "0.4.29"
 
 [dependencies.libcosmic]
-git = "https://github.com/pop-os/libcosmic"
+path = "../../"
 default-features = false
 features = ["applet-token"]

examples/applet/src/window.rs

@@ -1,8 +1,8 @@
 use cosmic::app::{Core, Task};
 
+use cosmic::iced::core::window;
 use cosmic::iced::window::Id;
 use cosmic::iced::{Length, Rectangle};
-use cosmic::iced_runtime::core::window;
 use cosmic::surface::action::{app_popup, destroy_popup};
 use cosmic::widget::{dropdown::popup_dropdown, list_column, settings, toggler};
 use cosmic::Element;
@@ -13,6 +13,7 @@ pub struct Window {
     core: Core,
     popup: Option<Id>,
     example_row: bool,
+    toggle: bool,
     selected: Option<usize>,
 }
 
@@ -22,6 +23,7 @@ impl Default for Window {
             core: Core::default(),
             popup: None,
             example_row: false,
+            toggle: false,
             selected: None,
         }
     }
@@ -33,6 +35,7 @@ pub enum Message {
     ToggleExampleRow(bool),
     Selected(usize),
     Surface(cosmic::surface::Action),
+    Toggle(bool),
 }
 
 impl cosmic::Application for Window {
@@ -71,7 +74,6 @@ impl cosmic::Application for Window {
             Message::ToggleExampleRow(toggled) => {
                 self.example_row = toggled;
             }
-
             Message::Surface(a) => {
                 return cosmic::task::message(cosmic::Action::Cosmic(
                     cosmic::app::Action::Surface(a),
@@ -80,6 +82,9 @@ impl cosmic::Application for Window {
             Message::Selected(i) => {
                 self.selected = Some(i);
             }
+            Message::Toggle(v) => {
+                self.toggle = v;
+            }
         };
         Task::none()
     }
@@ -123,9 +128,8 @@ impl cosmic::Application for Window {
                                     "Example row",
                                     cosmic::widget::container(
                                         toggler(state.example_row)
-                                            .on_toggle(|value| Message::ToggleExampleRow(value)),
-                                    )
-                                    .height(Length::Fixed(50.)),
+                                            .on_toggle(Message::ToggleExampleRow),
+                                    ),
                                 ))
                                 .add(popup_dropdown(
                                     &["1", "asdf", "hello", "test"],
@@ -155,7 +159,7 @@ impl cosmic::Application for Window {
         "oops".into()
     }
 
-    fn style(&self) -> Option<cosmic::iced_runtime::Appearance> {
+    fn style(&self) -> Option<cosmic::iced::theme::Style> {
         Some(cosmic::applet::style())
     }
 }

examples/application/Cargo.toml

@@ -8,9 +8,7 @@ default = ["wayland"]
 wayland = ["libcosmic/wayland"]
 
 [dependencies]
-tracing = "0.1.44"
-tracing-subscriber = "0.3.22"
-tracing-log = "0.2.0"
+env_logger = "0.11"
 
 [dependencies.libcosmic]
 path = "../../"
@@ -20,7 +18,8 @@ features = [
     "tokio",
     "xdg-portal",
     "a11y",
-    "wgpu",
     "single-instance",
     "surface-message",
+    "multi-window",
+    "wgpu",
 ]

examples/application/src/main.rs

@@ -54,8 +54,9 @@ impl widget::menu::Action for Action {
 /// Runs application with these settings
 #[rustfmt::skip]
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // tracing_subscriber::fmt::init();
-    // let _ = tracing_log::LogTracer::init();
+
+    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("warn")).init();
+
 
     let input = vec![
         (Page::Page1, "🖖 Hello from libcosmic.".into()),
@@ -66,9 +67,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let settings = Settings::default()
         .size(Size::new(1024., 768.));
-
-    cosmic::app::run::<App>(settings, input)?;
-
+    cosmic::app::run::<App>(settings, input).unwrap();
     Ok(())
 }
 
@@ -83,6 +82,7 @@ pub enum Message {
     Hi,
     Hi2,
     Hi3,
+    Tick,
 }
 
 /// The [`App`] stores application-specific state.
@@ -93,6 +93,7 @@ pub struct App {
     input_2: String,
     hidden: bool,
     keybinds: HashMap<KeyBind, Action>,
+    progress: f32,
 }
 
 /// Implement [`cosmic::Application`] to integrate with COSMIC.
@@ -134,6 +135,7 @@ impl cosmic::Application for App {
             input_2: String::new(),
             hidden: true,
             keybinds: HashMap::new(),
+            progress: 0.0,
         };
 
         let command = app.update_title();
@@ -179,10 +181,17 @@ impl cosmic::Application for App {
             Message::Hi3 => {
                 dbg!("hi 3");
             }
+            Message::Tick => {
+                self.progress = (self.progress + 0.01) % 1.0;
+            }
         }
         Task::none()
     }
 
+    fn subscription(&self) -> iced::Subscription<Self::Message> {
+        iced::time::every(std::time::Duration::from_millis(64)).map(|_| Message::Tick)
+    }
+
     /// Creates a view after each update.
     fn view(&self) -> Element<'_, Self::Message> {
         let page_content = self
@@ -191,7 +200,7 @@ impl cosmic::Application for App {
             .map_or("No page selected", String::as_str);
 
         let centered = widget::container(
-            widget::column()
+            widget::column::with_capacity(14)
                 .push(widget::text::body(page_content))
                 .push(
                     widget::text_input::text_input("", &self.input_1)
@@ -213,6 +222,47 @@ impl cosmic::Application for App {
                         .on_input(Message::Input2)
                         .on_clear(Message::Ignore),
                 )
+                .push(widget::progress_bar::circular::Circular::new().size(50.0))
+                .push(widget::progress_bar::circular::Circular::new().size(20.0))
+                .push(
+                    widget::progress_bar::linear::Linear::new()
+                        .girth(10.0)
+                        .width(Length::Fill),
+                )
+                .push(
+                    widget::progress_bar::circular::Circular::new()
+                        .bar_height(10.0)
+                        .size(50.0)
+                        .progress(self.progress),
+                )
+                .push(
+                    widget::progress_bar::linear::Linear::new()
+                        .girth(10.0)
+                        .progress(self.progress)
+                        .width(Length::Fill),
+                )
+                .push(
+                    widget::progress_bar::circular::Circular::new()
+                        .size(50.0)
+                        .progress(0.0),
+                )
+                .push(
+                    widget::progress_bar::linear::Linear::new()
+                        .girth(10.0)
+                        .progress(0.0)
+                        .width(Length::Fill),
+                )
+                .push(
+                    widget::progress_bar::circular::Circular::new()
+                        .size(50.0)
+                        .progress(1.0),
+                )
+                .push(
+                    widget::progress_bar::linear::Linear::new()
+                        .girth(10.0)
+                        .progress(1.0)
+                        .width(Length::Fill),
+                )
                 .spacing(cosmic::theme::spacing().space_s)
                 .width(Length::Fill)
                 .height(Length::Shrink)

examples/calendar/src/main.rs

@@ -85,8 +85,6 @@ impl cosmic::Application for App {
 
     /// Creates a view after each update.
     fn view(&self) -> Element<'_, Self::Message> {
-        let mut content = cosmic::widget::column().spacing(12);
-
         let calendar = cosmic::widget::calendar(
             &self.calendar_model,
             |date| Message::DateSelected(date),
@@ -95,9 +93,7 @@ impl cosmic::Application for App {
             Weekday::Sunday,
         );
 
-        content = content.push(calendar);
-
-        let centered = cosmic::widget::container(content)
+        let centered = cosmic::widget::container(calendar)
             .width(iced::Length::Fill)
             .height(iced::Length::Shrink)
             .align_x(iced::Alignment::Center)

examples/context-menu/src/main.rs

@@ -4,7 +4,7 @@
 //! Application API example
 
 use cosmic::app::{Core, Settings, Task};
-use cosmic::iced_core::Size;
+use cosmic::iced::Size;
 use cosmic::widget::menu;
 use cosmic::{executor, iced, ApplicationExt, Element};
 use std::collections::HashMap;

examples/cosmic/src/window/bluetooth.rs

@@ -28,13 +28,14 @@ impl State {
             column!(
                 list_column().add(settings::item(
                     "Bluetooth",
-                    toggler(None, self.enabled, Message::Enable)
+                    toggler(self.enabled).on_toggle(Message::Enable)
                 )),
                 text("Now visible as \"TODO\", just kidding")
             )
             .spacing(8)
             .into(),
-            settings::view_section("Devices")
+            settings::section()
+                .title("Devices")
                 .add(settings::item("No devices found", text("")))
                 .into(),
         ])

examples/cosmic/src/window/demo.rs

@@ -258,12 +258,13 @@ impl State {
             match self.tab_bar.active_data() {
                 None => panic!("no tab is active"),
                 Some(DemoView::TabA) => settings::view_column(vec![
-                    settings::view_section("Debug")
+                    settings::section()
+                        .title("Debug")
                         .add(settings::item("Debug theme", choose_theme))
                         .add(settings::item("Debug icon theme", choose_icon_theme))
                         .add(settings::item(
                             "Debug layout",
-                            toggler(None, window.debug, Message::Debug),
+                            toggler(window.debug).on_toggle(Message::Debug),
                         ))
                         .add(settings::item(
                             "Scaling Factor",
@@ -276,10 +277,11 @@ impl State {
                                 .into(),
                         ]))
                         .into(),
-                    settings::view_section("Controls")
+                    settings::section()
+                        .title("Controls")
                         .add(settings::item(
                             "Toggler",
-                            toggler(None, self.toggler_value, Message::TogglerToggled),
+                            toggler(self.toggler_value).on_toggle(Message::TogglerToggled),
                         ))
                         .add(settings::item(
                             "Pick List (TODO)",
@@ -299,15 +301,13 @@ impl State {
                         .add(settings::item(
                             "Progress",
                             progress_bar(0.0..=100.0, self.slider_value)
-                                .width(Length::Fixed(250.0))
-                                .height(Length::Fixed(4.0)),
+                                .length(Length::Fixed(250.0))
+                                .girth(Length::Fixed(4.0)),
                         ))
-                        .add(settings::item_row(vec![checkbox(
-                            "Checkbox",
-                            self.checkbox_value,
-                            Message::CheckboxToggled,
-                        )
-                        .into()]))
+                        .add(settings::item_row(vec![checkbox(self.checkbox_value)
+                            .label("Checkbox")
+                            .on_toggle(Message::CheckboxToggled)
+                            .into()]))
                         .add(settings::item(
                             format!(
                                 "Spin Button (Range {}:{})",
@@ -354,8 +354,7 @@ impl State {
                         .width(Length::Shrink)
                         .on_activate(Message::MultiSelection)
                         .apply(container)
-                        .center_x()
-                        .width(Length::Fill)
+                        .center_x(Length::Fill)
                         .into(),
                     text("Vertical With Spacing").into(),
                     cosmic::iced::widget::row(vec![
@@ -424,13 +423,12 @@ impl State {
                 ])
                 .padding(0)
                 .into(),
-                Some(DemoView::TabC) => {
-                    settings::view_column(vec![settings::view_section("Tab C")
-                        .add(text("Nothing here yet").width(Length::Fill))
-                        .into()])
-                    .padding(0)
-                    .into()
-                }
+                Some(DemoView::TabC) => settings::view_column(vec![settings::section()
+                    .title("Tab C")
+                    .add(text("Nothing here yet").width(Length::Fill))
+                    .into()])
+                .padding(0)
+                .into(),
             },
             container(text("Background container with some text").size(24))
                 .layer(cosmic_theme::Layer::Background)

examples/cosmic/src/window/desktop.rs

@@ -147,7 +147,8 @@ impl State {
     fn view_desktop_options<'a>(&'a self, window: &'a Window) -> Element<'a, Message> {
         settings::view_column(vec![
             window.parent_page_button(DesktopPage::DesktopOptions),
-            settings::view_section("Super Key Action")
+            settings::section()
+                .title("Super Key Action")
                 .add(settings::item("Launcher", horizontal_space(Length::Fill)))
                 .add(settings::item("Workspaces", horizontal_space(Length::Fill)))
                 .add(settings::item(
@@ -155,38 +156,34 @@ impl State {
                     horizontal_space(Length::Fill),
                 ))
                 .into(),
-            settings::view_section("Hot Corner")
+            settings::section()
+                .title("Hot Corner")
                 .add(settings::item(
                     "Enable top-left hot corner for Workspaces",
-                    toggler(None, self.top_left_hot_corner, Message::TopLeftHotCorner),
+                    toggler(self.top_left_hot_corner).on_toggle(Message::TopLeftHotCorner),
                 ))
                 .into(),
-            settings::view_section("Top Panel")
+            settings::section()
+                .title("Top Panel")
                 .add(settings::item(
                     "Show Workspaces Button",
-                    toggler(
-                        None,
-                        self.show_workspaces_button,
-                        Message::ShowWorkspacesButton,
-                    ),
+                    toggler(self.show_workspaces_button).on_toggle(Message::ShowWorkspacesButton),
                 ))
                 .add(settings::item(
                     "Show Applications Button",
-                    toggler(
-                        None,
-                        self.show_applications_button,
-                        Message::ShowApplicationsButton,
-                    ),
+                    toggler(self.show_applications_button)
+                        .on_toggle(Message::ShowApplicationsButton),
                 ))
                 .into(),
-            settings::view_section("Window Controls")
+            settings::section()
+                .title("Window Controls")
                 .add(settings::item(
                     "Show Minimize Button",
-                    toggler(None, self.show_minimize_button, Message::ShowMinimizeButton),
+                    toggler(self.show_minimize_button).on_toggle(Message::ShowMinimizeButton),
                 ))
                 .add(settings::item(
                     "Show Maximize Button",
-                    toggler(None, self.show_maximize_button, Message::ShowMaximizeButton),
+                    toggler(self.show_maximize_button).on_toggle(Message::ShowMaximizeButton),
                 ))
                 .into(),
         ])
@@ -245,12 +242,12 @@ impl State {
             list_column()
                 .add(settings::item(
                     "Same background on all displays",
-                    toggler(None, self.same_background, Message::SameBackground),
+                    toggler(self.same_background).on_toggle(Message::SameBackground),
                 ))
                 .add(settings::item("Background fit", text("TODO")))
                 .add(settings::item(
                     "Slideshow",
-                    toggler(None, self.slideshow, Message::Slideshow),
+                    toggler(self.slideshow).on_toggle(Message::Slideshow),
                 ))
                 .into(),
             column(image_column).spacing(16).into(),
@@ -261,7 +258,8 @@ impl State {
     fn view_desktop_workspaces<'a>(&'a self, window: &'a Window) -> Element<'a, Message> {
         settings::view_column(vec![
             window.parent_page_button(DesktopPage::Wallpaper),
-            settings::view_section("Workspace Behavior")
+            settings::section()
+                .title("Workspace Behavior")
                 .add(settings::item(
                     "Dynamic workspaces",
                     horizontal_space(Length::Fill),
@@ -271,7 +269,8 @@ impl State {
                     horizontal_space(Length::Fill),
                 ))
                 .into(),
-            settings::view_section("Multi-monitor Behavior")
+            settings::section()
+                .title("Multi-monitor Behavior")
                 .add(settings::item(
                     "Workspaces Span Displays",
                     horizontal_space(Length::Fill),

examples/cosmic/src/window/system_and_accounts.rs

@@ -69,14 +69,16 @@ impl State {
             list_column()
                 .add(settings::item("Device name", text("TODO")))
                 .into(),
-            settings::view_section("Hardware")
+            settings::section()
+                .title("Hardware")
                 .add(settings::item("Hardware model", text("TODO")))
                 .add(settings::item("Memory", text("TODO")))
                 .add(settings::item("Processor", text("TODO")))
                 .add(settings::item("Graphics", text("TODO")))
                 .add(settings::item("Disk Capacity", text("TODO")))
                 .into(),
-            settings::view_section("Operating System")
+            settings::section()
+                .title("Operating System")
                 .add(settings::item("Operating system", text("TODO")))
                 .add(settings::item(
                     "Operating system architecture",
@@ -85,7 +87,8 @@ impl State {
                 .add(settings::item("Desktop environment", text("TODO")))
                 .add(settings::item("Windowing system", text("TODO")))
                 .into(),
-            settings::view_section("Related settings")
+            settings::section()
+                .title("Related settings")
                 .add(settings::item("Get support", text("TODO")))
                 .into(),
         ])

examples/image-button/src/main.rs

@@ -80,7 +80,7 @@ impl cosmic::Application for App {
 
     /// Creates a view after each update.
     fn view(&self) -> Element<'_, Self::Message> {
-        let mut content = cosmic::widget::column().spacing(12);
+        let mut content = cosmic::widget::column::with_capacity(self.images.len()).spacing(12);
 
         for (id, image) in self.images.iter().enumerate() {
             content = content.push(

examples/menu/src/main.rs

@@ -7,10 +7,10 @@ use std::collections::HashMap;
 use std::{env, process};
 
 use cosmic::app::{Core, Settings, Task};
+use cosmic::iced::alignment::{Horizontal, Vertical};
+use cosmic::iced::keyboard::Key;
 use cosmic::iced::window;
-use cosmic::iced_core::alignment::{Horizontal, Vertical};
-use cosmic::iced_core::keyboard::Key;
-use cosmic::iced_core::{Length, Size};
+use cosmic::iced::{Length, Size};
 use cosmic::widget::menu::action::MenuAction;
 use cosmic::widget::menu::key_bind::KeyBind;
 use cosmic::widget::menu::key_bind::Modifier;

examples/multi-window/src/window.rs

@@ -2,9 +2,9 @@ use std::collections::HashMap;
 
 use cosmic::{
     app::Core,
+    iced::core::{id, Alignment, Length, Point},
+    iced::widget::{column, container, scrollable, text},
     iced::{self, event, window, Subscription},
-    iced_core::{id, Alignment, Length, Point},
-    iced_widget::{column, container, scrollable, text},
     prelude::*,
     widget::{button, header_bar},
 };

examples/nav-context/src/main.rs

@@ -6,7 +6,7 @@
 use std::collections::HashMap;
 
 use cosmic::app::{Core, Settings, Task};
-use cosmic::iced_core::Size;
+use cosmic::iced::Size;
 use cosmic::widget::{menu, nav_bar};
 use cosmic::{executor, iced, ApplicationExt, Element};
 

examples/open-dialog/src/main.rs

@@ -6,7 +6,7 @@
 use apply::Apply;
 use cosmic::app::{Core, Settings, Task};
 use cosmic::dialog::file_chooser::{self, FileFilter};
-use cosmic::iced_core::Length;
+use cosmic::iced::Length;
 use cosmic::widget::button;
 use cosmic::{executor, iced, ApplicationExt, Element};
 use std::sync::Arc;
@@ -207,7 +207,7 @@ impl cosmic::Application for App {
             );
 
             content.push(
-                iced::widget::vertical_space()
+                iced::widget::space::vertical()
                     .height(Length::Fixed(12.0))
                     .into(),
             );

examples/subscriptions/src/main.rs

@@ -64,7 +64,7 @@ impl cosmic::Application for App {
 
     /// Creates a view after each update.
     fn view(&self) -> Element<'_, Self::Message> {
-        widget::row().into()
+        widget::Row::new().into()
     }
 }
 

examples/table-view/src/main.rs

@@ -7,7 +7,7 @@ use std::collections::HashMap;
 
 use chrono::Datelike;
 use cosmic::app::{Core, Settings, Task};
-use cosmic::iced_core::Size;
+use cosmic::iced::Size;
 use cosmic::prelude::*;
 use cosmic::widget::table;
 use cosmic::widget::{self, nav_bar};

examples/text-input/src/main.rs

@@ -99,7 +99,9 @@ impl cosmic::Application for App {
 
         let inline = cosmic::widget::inline_input("", &self.input).on_input(Message::Input);
 
-        let column = cosmic::widget::column().push(editable).push(inline);
+        let column = cosmic::widget::column::with_capacity(2)
+            .push(editable)
+            .push(inline);
 
         let centered = cosmic::widget::container(column.width(200))
             .width(iced::Length::Fill)

i18n/de/libcosmic.ftl

@@ -6,7 +6,7 @@ links = Links
 developers = Entwickler(innen)
 designers = Designer(innen)
 artists = Künstler(innen)
-translators = Übersetzer*innen
+translators = Übersetzer(innen)
 documenters = Dokumentierer(innen)
 # Calendar
 january = Januar { $year }
@@ -21,8 +21,8 @@ september = September { $year }
 october = Oktober { $year }
 november = November { $year }
 december = Dezember { $year }
-monday = Mo
-tuesday = Di
+monday = Montag
+tuesday = Dienstag
 wednesday = Mittwoch
 thursday = Donnerstag
 friday = Freitag
@@ -33,3 +33,5 @@ thu = Do
 fri = Fr
 sat = Sa
 sun = So
+tue = Di
+mon = Mo

i18n/kab/libcosmic.ftl

@@ -0,0 +1,33 @@
+close = Mdel
+license = Turagt
+links = Iseɣwan
+developers = Ineflayen
+artists = Inaẓuren
+translators = Imsuqlen
+january = Yennayer { $year }
+february = Fuṛar { $year }
+march = Meɣres { $year }
+april = Yebrir { $year }
+may = Mayyu { $year }
+june = Yunyu { $year }
+july = Yulyu { $year }
+august = Ɣuct { $year }
+september = Ctembeṛ { $year }
+october = Tubeṛ { $year }
+november = Wambeṛ { $year }
+december = Dujembeṛ { $year }
+documenters = Imeskaren
+monday = Arim
+mon = Ari
+tuesday = Aram
+tue = Ara
+wednesday = Ahad
+wed = Aha
+thursday = Amhad
+thu = Amh
+friday = Sem
+fri = Sm
+saturday = Sed
+sat = Sd
+sunday = Acer
+sun = Ace

i18n/ko/libcosmic.ftl

@@ -2,26 +2,33 @@ february = { $year }년 2월
 close = 닫기
 documenters = 문서 작성자
 november = { $year }년 11월
-friday = 금
-tuesday = 화
+friday = 금요일
+tuesday = 화요일
 may = { $year }년 5월
-wednesday = 수
+wednesday = 수요일
 april = { $year }년 4월
-monday = 월
+monday = 월요일
 translators = 번역가
 artists = 아티스트
 license = 라이선스
 december = { $year }년 12월
-sunday = 일
+sunday = 일요일
 links = 링크
 march = { $year }년 3월
 june = { $year }년 6월
-saturday = 토
+saturday = 토요일
 august = { $year }년 8월
 developers = 개발자
 july = { $year }년 7월
-thursday = 목
+thursday = 목요일
 september = { $year }년 9월
 designers = 디자이너
 october = { $year }년 10월
 january = { $year }년 1월
+mon = 월
+tue = 화
+wed = 수
+thu = 목
+fri = 금
+sat = 토
+sun = 일

i18n/lt/libcosmic.ftl

@@ -2,26 +2,33 @@ february = Vasaris { $year }
 close = Uždaryti
 documenters = Dokumentuotojai
 november = Lapkritis { $year }
-friday = Penk
-tuesday = Antr
+friday = Penktadienis
+tuesday = Antradienis
 may = Gegužė { $year }
-wednesday = Treč
+wednesday = Trečiadienis
 april = Balandis { $year }
-monday = Pirm
+monday = Pirmadienis
 translators = Vertėjai
 artists = Menininkai
 license = Licencija
 december = Gruodis { $year }
-sunday = Sekm
+sunday = Sekmadienis
 links = Nuorodos
 march = Kovas { $year }
 june = Birželis { $year }
-saturday = Šešt
+saturday = Šeštadienis
 august = Rugpjūtis { $year }
 developers = Kūrėjai
 july = Liepa { $year }
-thursday = Ketv
+thursday = Ketvirtadienis
 september = Rugsėjis { $year }
 designers = Dizaineriai
 october = Spalis { $year }
 january = Sausis { $year }
+mon = Pirm
+tue = Antr
+wed = Treč
+thu = Ketv
+fri = Penkt
+sat = Šešt
+sun = Sekm

i18n/pa/libcosmic.ftl

@@ -0,0 +1,34 @@
+close = ਬੰਦ ਕਰੋ
+license = ਲਸੰਸ
+links = ਲਿੰਕ
+developers = ਡਿਵੈਲਪਰ
+designers = ਡਿਜ਼ਾਇਨਰ
+artists = ਕਲਾਕਾਰ
+translators = ਅਨੁਵਾਦਕ
+documenters = ਦਸਤਾਵੇਜ਼ ਤਿਆਰ ਕਰਤਾ
+january = ਜਨਵਰੀ { $year }
+february = ਫਰਵਰੀ { $year }
+march = ਮਾਰਚ { $year }
+april = ਅਪਰੈਲ { $year }
+may = ਮਈ { $year }
+june = ਜੂਨ { $year }
+july = ਜੁਲਾਈ { $year }
+august = ਅਗਸਤ { $year }
+september = ਸਤੰਬਰ { $year }
+october = ਅਕਤੂਬਰ { $year }
+november = ਨਵੰਬਰ { $year }
+december = ਦਸੰਬਰ { $year }
+monday = ਸੋਮਵਾਰ
+mon = ਸੋਮ
+tuesday = ਮੰਗਲਵਾਰ
+tue = ਮੰਗਲ
+wednesday = ਬੁੱਧਵਾਰ
+wed = ਬੁੱਧ
+thursday = ਵੀਰਵਾਰ
+thu = ਵੀਰ
+friday = ਸ਼ੁੱਕਰਵਾਰ
+fri = ਸ਼ੁੱਕਰ
+saturday = ਸ਼ਨਿੱਚਰਵਾਰ
+sat = ਸ਼ਨਿੱਚਰ
+sunday = ਐਤਵਾਰ
+sun = ਐਤ

i18n/zh-Hant/libcosmic.ftl

@@ -0,0 +1,34 @@
+close = 關閉
+developers = 開發人員
+designers = 設計人員
+artists = 美編設計
+translators = 翻譯人員
+documenters = 文件編輯人員
+january = { $year } 年 1 月
+monday = 星期一
+tuesday = 星期二
+wednesday = 星期三
+thursday = 星期四
+friday = 星期五
+saturday = 星期六
+sunday = 星期日
+mon = 週一
+tue = 週二
+wed = 週三
+thu = 週四
+fri = 週五
+sat = 週六
+sun = 週日
+license = 授權
+links = 連結
+february = { $year } 年 2 月
+march = { $year } 年 3 月
+april = { $year } 年 4 月
+may = { $year } 年 5 月
+june = { $year } 年 6 月
+july = { $year } 年 7 月
+august = { $year } 年 8 月
+september = { $year } 年 9 月
+october = { $year } 年 10 月
+november = { $year } 年 11 月
+december = { $year } 年 12 月

iced

@@ -1 +1 @@
-Subproject commit d36e4df47f2e277fafcd3505229d53438c7f128d
+Subproject commit 78caabba7ef91cd1030da6f70b41d266704ffece

src/anim.rs

@@ -0,0 +1,51 @@
+use std::time::{Duration, Instant};
+
+/// A simple linear interpolation calculation function.
+/// p = `percent_complete` in decimal form
+#[must_use]
+pub fn lerp(start: f32, end: f32, p: f32) -> f32 {
+    (1.0 - p) * start + p * end
+}
+
+/// A fast smooth interpolation calculation function.
+/// p = `percent_complete` in decimal form
+#[must_use]
+pub fn slerp(start: f32, end: f32, p: f32) -> f32 {
+    let t = smootherstep(p);
+    (1.0 - t) * start + t * end
+}
+
+/// utility function which maps a value [0, 1] -> [0, 1] using the smootherstep function
+pub fn smootherstep(t: f32) -> f32 {
+    (6.0 * t.powi(5) - 15.0 * t.powi(4) + 10.0 * t.powi(3)).clamp(0.0, 1.0)
+}
+
+#[derive(Default, Debug)]
+pub struct State {
+    pub last_change: Option<Instant>,
+}
+
+impl State {
+    pub fn changed(&mut self, dur: Duration) {
+        let t = self.t(dur, false);
+        let diff = dur.mul_f32(t.abs());
+        let now = Instant::now();
+        self.last_change = Some(now.checked_sub(diff).unwrap_or(now));
+    }
+
+    pub fn anim_done(&mut self, dur: Duration) {
+        if self
+            .last_change
+            .is_some_and(|t| Instant::now().duration_since(t) > dur)
+        {
+            self.last_change = None;
+        }
+    }
+
+    pub fn t(&self, dur: Duration, forward: bool) -> f32 {
+        let res = self.last_change.map_or(1., |t| {
+            Instant::now().duration_since(t).as_millis() as f32 / dur.as_millis() as f32
+        });
+        if forward { res } else { 1. - res }
+    }
+}

src/app/action.rs

@@ -5,11 +5,9 @@ use crate::surface;
 use crate::theme::Theme;
 use crate::widget::nav_bar;
 use crate::{config::CosmicTk, keyboard_nav};
-#[cfg(feature = "wayland")]
+#[cfg(all(feature = "wayland", target_os = "linux"))]
 use cctk::sctk::reexports::csd_frame::{WindowManagerCapabilities, WindowState};
 use cosmic_theme::ThemeMode;
-#[cfg(not(any(feature = "multi-window", feature = "wayland")))]
-use iced::Application as IcedApplication;
 
 /// A message managed internally by COSMIC.
 #[derive(Clone, Debug)]
@@ -71,10 +69,10 @@ pub enum Action {
     /// Updates the tracked window geometry.
     WindowResize(iced::window::Id, f32, f32),
     /// Tracks updates to window state.
-    #[cfg(feature = "wayland")]
+    #[cfg(all(feature = "wayland", target_os = "linux"))]
     WindowState(iced::window::Id, WindowState),
     /// Capabilities the window manager supports
-    #[cfg(feature = "wayland")]
+    #[cfg(all(feature = "wayland", target_os = "linux"))]
     WmCapabilities(iced::window::Id, WindowManagerCapabilities),
     #[cfg(feature = "xdg-portal")]
     DesktopSettings(crate::theme::portal::Desktop),

src/app/cosmic.rs

@@ -8,16 +8,16 @@ use std::sync::Arc;
 use super::{Action, Application, ApplicationExt, Subscription};
 use crate::theme::{THEME, Theme, ThemeType};
 use crate::{Core, Element, keyboard_nav};
-#[cfg(feature = "wayland")]
+#[cfg(all(feature = "wayland", target_os = "linux"))]
 use cctk::sctk::reexports::csd_frame::{WindowManagerCapabilities, WindowState};
 use cosmic_theme::ThemeMode;
-#[cfg(not(any(feature = "multi-window", feature = "wayland")))]
+#[cfg(not(any(feature = "multi-window", feature = "wayland", target_os = "linux")))]
 use iced::Application as IcedApplication;
-#[cfg(feature = "wayland")]
+#[cfg(all(feature = "wayland", target_os = "linux"))]
 use iced::event::wayland;
-use iced::{Task, window};
+use iced::{Task, theme, window};
 use iced_futures::event::listen_with;
-#[cfg(feature = "wayland")]
+#[cfg(all(feature = "wayland", target_os = "linux"))]
 use iced_winit::SurfaceIdWrapper;
 use palette::color_difference::EuclideanDistance;
 
@@ -49,8 +49,8 @@ pub fn windowing_system() -> Option<WindowingSystem> {
     WINDOWING_SYSTEM.get().copied()
 }
 
-fn init_windowing_system<M>(handle: raw_window_handle::WindowHandle) -> crate::Action<M> {
-    let raw: &raw_window_handle::RawWindowHandle = handle.as_ref();
+fn init_windowing_system<M>(handle: window::raw_window_handle::WindowHandle) -> crate::Action<M> {
+    let raw = handle.as_ref();
     let system = match raw {
         window::raw_window_handle::RawWindowHandle::UiKit(_) => WindowingSystem::UiKit,
         window::raw_window_handle::RawWindowHandle::AppKit(_) => WindowingSystem::AppKit,
@@ -83,7 +83,7 @@ fn init_windowing_system<M>(handle: raw_window_handle::WindowHandle) -> crate::A
 #[derive(Default)]
 pub struct Cosmic<App: Application> {
     pub app: App,
-    #[cfg(feature = "wayland")]
+    #[cfg(all(feature = "wayland", target_os = "linux"))]
     pub surface_views: HashMap<
         window::Id,
         (
@@ -138,7 +138,7 @@ where
     ) -> iced::Task<crate::Action<T::Message>> {
         #[cfg(feature = "surface-message")]
         match _surface_message {
-            #[cfg(feature = "wayland")]
+            #[cfg(all(feature = "wayland", target_os = "linux"))]
             crate::surface::Action::AppSubsurface(settings, view) => {
                 let Some(settings) = std::sync::Arc::try_unwrap(settings)
                     .ok()
@@ -168,7 +168,7 @@ where
                     iced_winit::commands::subsurface::get_subsurface(settings(&mut self.app))
                 }
             }
-            #[cfg(feature = "wayland")]
+            #[cfg(all(feature = "wayland", target_os = "linux"))]
             crate::surface::Action::Subsurface(settings, view) => {
                 let Some(settings) = std::sync::Arc::try_unwrap(settings)
                     .ok()
@@ -196,7 +196,7 @@ where
                     iced_winit::commands::subsurface::get_subsurface(settings())
                 }
             }
-            #[cfg(feature = "wayland")]
+            #[cfg(all(feature = "wayland", target_os = "linux"))]
             crate::surface::Action::AppPopup(settings, view) => {
                 let Some(settings) = std::sync::Arc::try_unwrap(settings)
                     .ok()
@@ -225,15 +225,26 @@ where
                     iced_winit::commands::popup::get_popup(settings(&mut self.app))
                 }
             }
-            #[cfg(feature = "wayland")]
+            #[cfg(all(feature = "wayland", target_os = "linux"))]
             crate::surface::Action::DestroyPopup(id) => {
                 iced_winit::commands::popup::destroy_popup(id)
             }
-            #[cfg(feature = "wayland")]
+            #[cfg(all(feature = "wayland", target_os = "linux"))]
+            crate::surface::Action::DestroyTooltipPopup => {
+                #[cfg(feature = "applet")]
+                {
+                    iced_winit::commands::popup::destroy_popup(*crate::applet::TOOLTIP_WINDOW_ID)
+                }
+                #[cfg(not(feature = "applet"))]
+                {
+                    Task::none()
+                }
+            }
+            #[cfg(all(feature = "wayland", target_os = "linux"))]
             crate::surface::Action::DestroySubsurface(id) => {
                 iced_winit::commands::subsurface::destroy_subsurface(id)
             }
-            #[cfg(feature = "wayland")]
+            #[cfg(all(feature = "wayland", target_os = "linux"))]
             crate::surface::Action::DestroyWindow(id) => iced::window::close(id),
             crate::surface::Action::ResponsiveMenuBar {
                 menu_bar,
@@ -244,7 +255,7 @@ where
                 core.menu_bars.insert(menu_bar, (limits, size));
                 iced::Task::none()
             }
-            #[cfg(feature = "wayland")]
+            #[cfg(all(feature = "wayland", target_os = "linux"))]
             crate::surface::Action::Popup(settings, view) => {
                 let Some(settings) = std::sync::Arc::try_unwrap(settings)
                     .ok()
@@ -271,7 +282,7 @@ where
                     iced_winit::commands::popup::get_popup(settings())
                 }
             }
-            #[cfg(feature = "wayland")]
+            #[cfg(all(feature = "wayland", target_os = "linux"))]
             crate::surface::Action::AppWindow(id, settings, view) => {
                 let Some(settings) = std::sync::Arc::try_unwrap(settings).ok().and_then(|s| {
                     s.downcast::<Box<dyn Fn(&mut T) -> iced::window::Settings + Send + Sync>>()
@@ -310,7 +321,7 @@ where
                     .discard()
                 }
             }
-            #[cfg(feature = "wayland")]
+            #[cfg(all(feature = "wayland", target_os = "linux"))]
             crate::surface::Action::Window(id, settings, view) => {
                 let Some(settings) = std::sync::Arc::try_unwrap(settings).ok().and_then(|s| {
                     s.downcast::<Box<dyn Fn() -> iced::window::Settings + Send + Sync>>()
@@ -397,15 +408,16 @@ where
         f64::from(self.app.core().scale_factor())
     }
 
-    pub fn style(&self, theme: &Theme) -> iced_runtime::Appearance {
+    pub fn style(&self, theme: &Theme) -> theme::Style {
         if let Some(style) = self.app.style() {
             style
         } else if self.app.core().window.is_maximized {
             let theme = THEME.lock().unwrap();
-            crate::style::iced::application::appearance(theme.borrow())
+            crate::style::iced::application::style(theme.borrow())
         } else {
             let theme = THEME.lock().unwrap();
-            iced_runtime::Appearance {
+
+            theme::Style {
                 background_color: iced_core::Color::TRANSPARENT,
                 icon_color: theme.cosmic().on_bg_color().into(),
                 text_color: theme.cosmic().on_bg_color().into(),
@@ -429,7 +441,7 @@ where
                 }
                 iced::Event::Window(window::Event::Focused) => return Some(Action::Focus(id)),
                 iced::Event::Window(window::Event::Unfocused) => return Some(Action::Unfocus(id)),
-                #[cfg(feature = "wayland")]
+                #[cfg(all(feature = "wayland", target_os = "linux"))]
                 iced::Event::PlatformSpecific(iced::event::PlatformSpecific::Wayland(event)) => {
                     match event {
                         wayland::Event::Popup(wayland::PopupEvent::Done, _, id)
@@ -442,7 +454,7 @@ where
                         ) => {
                             return Some(Action::SuggestedBounds(b));
                         }
-                        #[cfg(feature = "wayland")]
+                        #[cfg(all(feature = "wayland", target_os = "linux"))]
                         wayland::Event::Window(iced::event::wayland::WindowEvent::WindowState(
                             s,
                         )) => {
@@ -559,7 +571,7 @@ where
 
     #[cfg(feature = "multi-window")]
     pub fn view(&self, id: window::Id) -> Element<'_, crate::Action<T::Message>> {
-        #[cfg(feature = "wayland")]
+        #[cfg(all(feature = "wayland", target_os = "linux"))]
         if let Some((_, _, v)) = self.surface_views.get(&id) {
             return v(&self.app);
         }
@@ -610,7 +622,7 @@ impl<T: Application> Cosmic<T> {
     fn cosmic_update(&mut self, message: Action) -> iced::Task<crate::Action<T::Message>> {
         match message {
             Action::WindowMaximized(id, maximized) => {
-                #[cfg(not(feature = "wayland"))]
+                #[cfg(not(all(feature = "wayland", target_os = "linux")))]
                 if self
                     .app
                     .core()
@@ -635,12 +647,12 @@ impl<T: Application> Cosmic<T> {
                 self.app.on_window_resize(id, width, height);
 
                 //TODO: more efficient test of maximized (winit has no event for maximize if set by the OS)
-                return iced::window::get_maximized(id).map(move |maximized| {
+                return iced::window::is_maximized(id).map(move |maximized| {
                     crate::Action::Cosmic(Action::WindowMaximized(id, maximized))
                 });
             }
 
-            #[cfg(feature = "wayland")]
+            #[cfg(all(feature = "wayland", target_os = "linux"))]
             Action::WindowState(id, state) => {
                 if self
                     .app
@@ -692,7 +704,7 @@ impl<T: Application> Cosmic<T> {
                 }
             }
 
-            #[cfg(feature = "wayland")]
+            #[cfg(all(feature = "wayland", target_os = "linux"))]
             Action::WmCapabilities(id, capabilities) => {
                 if self
                     .app
@@ -711,10 +723,10 @@ impl<T: Application> Cosmic<T> {
 
             Action::KeyboardNav(message) => match message {
                 keyboard_nav::Action::FocusNext => {
-                    return iced::widget::focus_next().map(crate::Action::Cosmic);
+                    return iced::widget::operation::focus_next().map(crate::Action::Cosmic);
                 }
                 keyboard_nav::Action::FocusPrevious => {
-                    return iced::widget::focus_previous().map(crate::Action::Cosmic);
+                    return iced::widget::operation::focus_previous().map(crate::Action::Cosmic);
                 }
                 keyboard_nav::Action::Escape => return self.app.on_escape(),
                 keyboard_nav::Action::Search => return self.app.on_search(),
@@ -799,7 +811,7 @@ impl<T: Application> Cosmic<T> {
                         new_theme.theme_type.prefer_dark(prefer_dark);
 
                         cosmic_theme.set_theme(new_theme.theme_type);
-                        #[cfg(feature = "wayland")]
+                        #[cfg(all(feature = "wayland", target_os = "linux"))]
                         if self.app.core().sync_window_border_radii_to_theme() {
                             use iced_runtime::platform_specific::wayland::CornerRadius;
                             use iced_winit::platform_specific::commands::corner_radius::corner_radius;
@@ -945,7 +957,7 @@ impl<T: Application> Cosmic<T> {
                         // Only apply update if the theme is set to load a system theme
                         if let ThemeType::System { .. } = cosmic_theme.theme_type {
                             cosmic_theme.set_theme(new_theme.theme_type);
-                            #[cfg(feature = "wayland")]
+                            #[cfg(all(feature = "wayland", target_os = "linux"))]
                             if self.app.core().sync_window_border_radii_to_theme() {
                                 use iced_runtime::platform_specific::wayland::CornerRadius;
                                 use iced_winit::platform_specific::commands::corner_radius::corner_radius;
@@ -1039,7 +1051,7 @@ impl<T: Application> Cosmic<T> {
                     // Unminimize window before requesting to activate it.
                     let mut task = iced_runtime::window::minimize(id, false);
 
-                    #[cfg(feature = "wayland")]
+                    #[cfg(all(feature = "wayland", target_os = "linux"))]
                     {
                         task = task.chain(
                             iced_winit::platform_specific::commands::activation::activate(
@@ -1050,7 +1062,7 @@ impl<T: Application> Cosmic<T> {
                         )
                     }
 
-                    #[cfg(not(feature = "wayland"))]
+                    #[cfg(not(all(feature = "wayland", target_os = "linux")))]
                     {
                         task = task.chain(iced_runtime::window::gain_focus(id));
                     }
@@ -1067,7 +1079,7 @@ impl<T: Application> Cosmic<T> {
                     *v == 0
                 }) {
                     self.opened_surfaces.remove(&id);
-                    #[cfg(feature = "wayland")]
+                    #[cfg(all(feature = "wayland", target_os = "linux"))]
                     self.surface_views.remove(&id);
                     self.tracked_windows.remove(&id);
                 }
@@ -1189,7 +1201,8 @@ impl<T: Application> Cosmic<T> {
                 #[cfg(all(
                     feature = "wayland",
                     feature = "multi-window",
-                    feature = "surface-message"
+                    feature = "surface-message",
+                    target_os = "linux"
                 ))]
                 if let Some((
                     parent,
@@ -1234,7 +1247,7 @@ impl<T: Application> Cosmic<T> {
                 core.applet.suggested_bounds = b;
             }
             Action::Opened(id) => {
-                #[cfg(feature = "wayland")]
+                #[cfg(all(feature = "wayland", target_os = "linux"))]
                 if self.app.core().sync_window_border_radii_to_theme() {
                     use iced_runtime::platform_specific::wayland::CornerRadius;
                     use iced_winit::platform_specific::commands::corner_radius::corner_radius;
@@ -1283,14 +1296,14 @@ impl<App: Application> Cosmic<App> {
     pub fn new(app: App) -> Self {
         Self {
             app,
-            #[cfg(feature = "wayland")]
+            #[cfg(all(feature = "wayland", target_os = "linux"))]
             surface_views: HashMap::new(),
             tracked_windows: HashSet::new(),
             opened_surfaces: HashMap::new(),
         }
     }
 
-    #[cfg(feature = "wayland")]
+    #[cfg(all(feature = "wayland", target_os = "linux"))]
     /// Create a subsurface
     pub fn get_subsurface(
         &mut self,
@@ -1313,7 +1326,7 @@ impl<App: Application> Cosmic<App> {
         get_subsurface(settings)
     }
 
-    #[cfg(feature = "wayland")]
+    #[cfg(all(feature = "wayland", target_os = "linux"))]
     /// Create a subsurface
     pub fn get_popup(
         &mut self,
@@ -1335,7 +1348,7 @@ impl<App: Application> Cosmic<App> {
         get_popup(settings)
     }
 
-    #[cfg(feature = "wayland")]
+    #[cfg(all(feature = "wayland", target_os = "linux"))]
     /// Create a window surface
     pub fn get_window(
         &mut self,

src/app/mod.rs

@@ -11,9 +11,8 @@ pub use action::Action;
 use cosmic_config::CosmicConfigEntry;
 pub mod context_drawer;
 pub use context_drawer::{ContextDrawer, context_drawer};
+use iced::application::BootFn;
 pub mod cosmic;
-#[cfg(all(feature = "winit", feature = "multi-window"))]
-pub(crate) mod multi_window;
 pub mod settings;
 
 pub type Task<M> = iced::Task<crate::Action<M>>;
@@ -21,12 +20,13 @@ pub type Task<M> = iced::Task<crate::Action<M>>;
 pub use crate::Core;
 use crate::prelude::*;
 use crate::theme::THEME;
-use crate::widget::{container, horizontal_space, id_container, menu, nav_bar, popover};
+use crate::widget::{container, id_container, menu, nav_bar, popover, space};
 use apply::Apply;
-use iced::window;
 use iced::{Length, Subscription};
+use iced::{theme, window};
 pub use settings::Settings;
 use std::borrow::Cow;
+use std::{cell::RefCell, rc::Rc};
 
 #[cold]
 pub(crate) fn iced_settings<App: Application>(
@@ -82,7 +82,7 @@ pub(crate) fn iced_settings<App: Application>(
         window_settings.min_size = Some(min_size);
     }
     let max_size = settings.size_limits.max();
-    if max_size != iced::Size::INFINITY {
+    if max_size != iced::Size::INFINITE {
         window_settings.max_size = Some(max_size);
     }
 
@@ -90,51 +90,99 @@ pub(crate) fn iced_settings<App: Application>(
     (iced, (core, flags), window_settings)
 }
 
+pub(crate) struct BootDataInner<A: crate::app::Application> {
+    pub flags: A::Flags,
+    pub core: Core,
+    pub settings: window::Settings,
+}
+
+pub(crate) struct BootData<A: crate::app::Application>(pub Rc<RefCell<Option<BootDataInner<A>>>>);
+
+impl<A: crate::app::Application> BootFn<cosmic::Cosmic<A>, crate::Action<A::Message>>
+    for BootData<A>
+{
+    fn boot(&self) -> (cosmic::Cosmic<A>, iced::Task<crate::Action<A::Message>>) {
+        let mut data = self.0.borrow_mut();
+        let mut data = data.take().unwrap();
+        let mut tasks = Vec::new();
+        #[cfg(feature = "multi-window")]
+        if data.core.main_window_id().is_some() {
+            let window_task = iced_runtime::task::oneshot(|channel| {
+                iced_runtime::Action::Window(iced_runtime::window::Action::Open(
+                    window::Id::RESERVED,
+                    data.settings,
+                    channel,
+                ))
+            });
+            data.core.set_main_window_id(Some(window::Id::RESERVED));
+            tasks.push(window_task.discard());
+        }
+        let (a, t) = cosmic::Cosmic::<A>::init((data.core, data.flags));
+        tasks.push(t);
+        (a, Task::batch(tasks))
+    }
+}
 /// Launch a COSMIC application with the given [`Settings`].
 ///
 /// # Errors
 ///
 /// Returns error on application failure.
 pub fn run<App: Application>(settings: Settings, flags: App::Flags) -> iced::Result {
+    #[cfg(feature = "desktop")]
+    image_extras::register();
+
     #[cfg(all(target_env = "gnu", not(target_os = "windows")))]
     if let Some(threshold) = settings.default_mmap_threshold {
         crate::malloc::limit_mmap_threshold(threshold);
     }
 
     let default_font = settings.default_font;
-    let (settings, mut flags, window_settings) = iced_settings::<App>(settings, flags);
+    let (settings, (mut core, flags), window_settings) = iced_settings::<App>(settings, flags);
     #[cfg(not(feature = "multi-window"))]
     {
-        flags.0.main_window = Some(iced::window::Id::RESERVED);
+        core.main_window = Some(iced::window::Id::RESERVED);
+
         iced::application(
-            cosmic::Cosmic::title,
+            BootData(Rc::new(RefCell::new(Some(BootDataInner::<App> {
+                flags,
+                core,
+                settings: window_settings.clone(),
+            })))),
             cosmic::Cosmic::update,
             cosmic::Cosmic::view,
         )
         .subscription(cosmic::Cosmic::subscription)
+        .title(cosmic::Cosmic::title)
         .style(cosmic::Cosmic::style)
         .theme(cosmic::Cosmic::theme)
         .window_size((500.0, 800.0))
         .settings(settings)
         .window(window_settings)
-        .run_with(move || cosmic::Cosmic::<App>::init(flags))
+        .run()
     }
     #[cfg(feature = "multi-window")]
     {
-        let mut app = multi_window::multi_window::<_, _, _, _, App::Executor>(
-            cosmic::Cosmic::title,
+        let no_main_window = core.main_window.is_none();
+        if no_main_window {
+            // app = app.window(window_settings);
+            core.main_window = Some(iced_core::window::Id::RESERVED);
+        }
+        let app = iced::daemon(
+            BootData(Rc::new(RefCell::new(Some(BootDataInner::<App> {
+                flags,
+                core,
+                settings: window_settings,
+            })))),
             cosmic::Cosmic::update,
             cosmic::Cosmic::view,
         );
-        if flags.0.main_window.is_none() {
-            app = app.window(window_settings);
-            flags.0.main_window = Some(iced_core::window::Id::RESERVED);
-        }
+
         app.subscription(cosmic::Cosmic::subscription)
+            .title(cosmic::Cosmic::title)
             .style(cosmic::Cosmic::style)
             .theme(cosmic::Cosmic::theme)
             .settings(settings)
-            .run_with(move || cosmic::Cosmic::<App>::init(flags))
+            .run()
     }
 }
 
@@ -149,6 +197,9 @@ where
     App::Flags: CosmicFlags,
     App::Message: Clone + std::fmt::Debug + Send + 'static,
 {
+    #[cfg(feature = "desktop")]
+    image_extras::register();
+
     use std::collections::HashMap;
 
     let activation_token = std::env::var("XDG_ACTIVATION_TOKEN").ok();
@@ -204,13 +255,17 @@ where
         tracing::info!("Another instance is running");
         Ok(())
     } else {
-        let (settings, mut flags, window_settings) = iced_settings::<App>(settings, flags);
-        flags.0.single_instance = true;
+        let (settings, (mut core, flags), window_settings) = iced_settings::<App>(settings, flags);
+        core.single_instance = true;
 
         #[cfg(not(feature = "multi-window"))]
         {
             iced::application(
-                cosmic::Cosmic::title,
+                BootData(Rc::new(RefCell::new(Some(BootDataInner::<App> {
+                    flags,
+                    core,
+                    settings: window_settings.clone(),
+                })))),
                 cosmic::Cosmic::update,
                 cosmic::Cosmic::view,
             )
@@ -220,24 +275,31 @@ where
             .window_size((500.0, 800.0))
             .settings(settings)
             .window(window_settings)
-            .run_with(move || cosmic::Cosmic::<App>::init(flags))
+            .run()
         }
         #[cfg(feature = "multi-window")]
         {
-            let mut app = multi_window::multi_window::<_, _, _, _, App::Executor>(
-                cosmic::Cosmic::title,
+            let no_main_window = core.main_window.is_none();
+            if no_main_window {
+                // app = app.window(window_settings);
+                core.main_window = Some(iced_core::window::Id::RESERVED);
+            }
+            let mut app = iced::daemon(
+                BootData(Rc::new(RefCell::new(Some(BootDataInner::<App> {
+                    flags,
+                    core,
+                    settings: window_settings,
+                })))),
                 cosmic::Cosmic::update,
                 cosmic::Cosmic::view,
             );
-            if flags.0.main_window.is_none() {
-                app = app.window(window_settings);
-                flags.0.main_window = Some(iced_core::window::Id::RESERVED);
-            }
+
             app.subscription(cosmic::Cosmic::subscription)
                 .style(cosmic::Cosmic::style)
+                .title(cosmic::Cosmic::title)
                 .theme(cosmic::Cosmic::theme)
                 .settings(settings)
-                .run_with(move || cosmic::Cosmic::<App>::init(flags))
+                .run()
         }
     }
 }
@@ -329,9 +391,8 @@ where
                 .on_context(|id| crate::Action::Cosmic(Action::NavBarContext(id)))
                 .context_menu(self.nav_context_menu(self.core().nav_bar_context()))
                 .into_container()
-                // XXX both must be shrink to avoid flex layout from ignoring it
                 .width(iced::Length::Shrink)
-                .height(iced::Length::Shrink);
+                .height(iced::Length::Fill);
 
         if !self.core().is_condensed() {
             nav = nav.max_width(280);
@@ -428,7 +489,7 @@ where
     }
 
     /// Overrides the default style for applications
-    fn style(&self) -> Option<iced_runtime::Appearance> {
+    fn style(&self) -> Option<theme::Style> {
         None
     }
 
@@ -664,16 +725,17 @@ impl<App: Application> ApplicationExt for App {
                                 [0, 0, 0, 0]
                             })
                             .into(),
-                        )
+                        );
                     } else {
                         //TODO: this element is added to workaround state issues
-                        widgets.push(horizontal_space().width(Length::Shrink).into());
+                        widgets.push(space::horizontal().width(Length::Shrink).into());
                     }
                 }
             }
 
             widgets
         });
+
         let content_col = crate::widget::column::with_capacity(2)
             .push(content_row)
             .push_maybe(self.footer().map(|footer| {
@@ -686,7 +748,6 @@ impl<App: Application> ApplicationExt for App {
             }));
         let content: Element<_> = if content_container {
             content_col
-                .apply(container)
                 .width(iced::Length::Fill)
                 .height(iced::Length::Fill)
                 .apply(|w| id_container(w, iced_core::id::Id::new("COSMIC_content_container")))
@@ -716,8 +777,7 @@ impl<App: Application> ApplicationExt for App {
                         .title(&core.window.header_title)
                         .on_drag(crate::Action::Cosmic(Action::Drag))
                         .on_right_click(crate::Action::Cosmic(Action::ShowWindowMenu))
-                        .on_double_click(crate::Action::Cosmic(Action::Maximize))
-                        .is_condensed(is_condensed);
+                        .on_double_click(crate::Action::Cosmic(Action::Maximize));
 
                     if self.nav_model().is_some() {
                         let toggle = crate::widget::nav_bar_toggle()

src/app/multi_window.rs

@@ -1,244 +0,0 @@
-// Copyright 2024 System76 <info@system76.com>
-// SPDX-License-Identifier: MPL-2.0
-
-//! Create and run daemons that run in the background.
-//! Copied from iced 0.13, but adds optional initial window
-
-use iced::application;
-use iced::window;
-use iced::{
-    self, Program,
-    program::{self, with_style, with_subscription, with_theme, with_title},
-    runtime::{Appearance, DefaultStyle},
-};
-use iced::{Element, Result, Settings, Subscription, Task};
-
-use std::marker::PhantomData;
-
-pub(crate) struct Instance<State, Message, Theme, Renderer, Update, View, Executor> {
-    update: Update,
-    view: View,
-    _state: PhantomData<State>,
-    _message: PhantomData<Message>,
-    _theme: PhantomData<Theme>,
-    _renderer: PhantomData<Renderer>,
-    _executor: PhantomData<Executor>,
-}
-
-/// Creates an iced [`MultiWindow`] given its title, update, and view logic.
-pub fn multi_window<State, Message, Theme, Renderer, Executor>(
-    title: impl Title<State>,
-    update: impl application::Update<State, Message>,
-    view: impl for<'a> self::View<'a, State, Message, Theme, Renderer>,
-) -> MultiWindow<impl Program<State = State, Message = Message, Theme = Theme>>
-where
-    State: 'static,
-    Message: Send + std::fmt::Debug + 'static,
-    Theme: Default + DefaultStyle,
-    Renderer: program::Renderer,
-    Executor: iced::Executor,
-{
-    use std::marker::PhantomData;
-
-    impl<State, Message, Theme, Renderer, Update, View, Executor> Program
-        for Instance<State, Message, Theme, Renderer, Update, View, Executor>
-    where
-        Message: Send + std::fmt::Debug + 'static,
-        Theme: Default + DefaultStyle,
-        Renderer: program::Renderer,
-        Update: application::Update<State, Message>,
-        View: for<'a> self::View<'a, State, Message, Theme, Renderer>,
-        Executor: iced::Executor,
-    {
-        type State = State;
-        type Message = Message;
-        type Theme = Theme;
-        type Renderer = Renderer;
-        type Executor = Executor;
-
-        fn update(&self, state: &mut Self::State, message: Self::Message) -> Task<Self::Message> {
-            self.update.update(state, message).into()
-        }
-
-        fn view<'a>(
-            &self,
-            state: &'a Self::State,
-            window: window::Id,
-        ) -> Element<'a, Self::Message, Self::Theme, Self::Renderer> {
-            self.view.view(state, window).into()
-        }
-    }
-
-    MultiWindow {
-        raw: Instance {
-            update,
-            view,
-            _state: PhantomData,
-            _message: PhantomData,
-            _theme: PhantomData,
-            _renderer: PhantomData,
-            _executor: PhantomData::<Executor>,
-        },
-        settings: Settings::default(),
-        window: None,
-    }
-    .title(title)
-}
-
-/// The underlying definition and configuration of an iced daemon.
-///
-/// You can use this API to create and run iced applications
-/// step by step—without coupling your logic to a trait
-/// or a specific type.
-///
-/// You can create a [`MultiWindow`] with the [`daemon`] helper.
-#[derive(Debug)]
-pub struct MultiWindow<P: Program> {
-    raw: P,
-    settings: Settings,
-    window: Option<window::Settings>,
-}
-
-impl<P: Program> MultiWindow<P> {
-    #[cfg(any(feature = "winit", feature = "wayland"))]
-    /// Runs the [`MultiWindow`].
-    ///
-    /// The state of the [`MultiWindow`] must implement [`Default`].
-    /// If your state does not implement [`Default`], use [`run_with`]
-    /// instead.
-    ///
-    /// [`run_with`]: Self::run_with
-    pub fn run(self) -> Result
-    where
-        Self: 'static,
-        P::State: Default,
-    {
-        self.raw.run(self.settings, self.window)
-    }
-
-    #[cfg(any(feature = "winit", feature = "wayland"))]
-    /// Runs the [`MultiWindow`] with a closure that creates the initial state.
-    pub fn run_with<I>(self, initialize: I) -> Result
-    where
-        Self: 'static,
-        I: FnOnce() -> (P::State, Task<P::Message>) + 'static,
-    {
-        self.raw.run_with(self.settings, self.window, initialize)
-    }
-
-    /// Sets the [`Settings`] that will be used to run the [`MultiWindow`].
-    pub fn settings(self, settings: Settings) -> Self {
-        Self { settings, ..self }
-    }
-
-    /// Sets the [`Title`] of the [`MultiWindow`].
-    pub(crate) fn title(
-        self,
-        title: impl Title<P::State>,
-    ) -> MultiWindow<impl Program<State = P::State, Message = P::Message, Theme = P::Theme>> {
-        MultiWindow {
-            raw: with_title(self.raw, move |state, window| title.title(state, window)),
-            settings: self.settings,
-            window: self.window,
-        }
-    }
-
-    /// Sets the subscription logic of the [`MultiWindow`].
-    pub fn subscription(
-        self,
-        f: impl Fn(&P::State) -> Subscription<P::Message>,
-    ) -> MultiWindow<impl Program<State = P::State, Message = P::Message, Theme = P::Theme>> {
-        MultiWindow {
-            raw: with_subscription(self.raw, f),
-            settings: self.settings,
-            window: self.window,
-        }
-    }
-
-    /// Sets the theme logic of the [`MultiWindow`].
-    pub fn theme(
-        self,
-        f: impl Fn(&P::State, window::Id) -> P::Theme,
-    ) -> MultiWindow<impl Program<State = P::State, Message = P::Message, Theme = P::Theme>> {
-        MultiWindow {
-            raw: with_theme(self.raw, f),
-            settings: self.settings,
-            window: self.window,
-        }
-    }
-
-    /// Sets the style logic of the [`MultiWindow`].
-    pub fn style(
-        self,
-        f: impl Fn(&P::State, &P::Theme) -> Appearance,
-    ) -> MultiWindow<impl Program<State = P::State, Message = P::Message, Theme = P::Theme>> {
-        MultiWindow {
-            raw: with_style(self.raw, f),
-            settings: self.settings,
-            window: self.window,
-        }
-    }
-
-    /// Sets the window settings of the [`MultiWindow`].
-    pub fn window(self, window: window::Settings) -> Self {
-        Self {
-            raw: self.raw,
-            settings: self.settings,
-            window: Some(window),
-        }
-    }
-}
-
-/// The title logic of some [`MultiWindow`].
-///
-/// This trait is implemented both for `&static str` and
-/// any closure `Fn(&State, window::Id) -> String`.
-///
-/// This trait allows the [`daemon`] builder to take any of them.
-pub trait Title<State> {
-    /// Produces the title of the [`MultiWindow`].
-    fn title(&self, state: &State, window: window::Id) -> String;
-}
-
-impl<State> Title<State> for &'static str {
-    fn title(&self, _state: &State, _window: window::Id) -> String {
-        (*self).to_string()
-    }
-}
-
-impl<T, State> Title<State> for T
-where
-    T: Fn(&State, window::Id) -> String,
-{
-    fn title(&self, state: &State, window: window::Id) -> String {
-        self(state, window)
-    }
-}
-
-/// The view logic of some [`MultiWindow`].
-///
-/// This trait allows the [`daemon`] builder to take any closure that
-/// returns any `Into<Element<'_, Message>>`.
-pub trait View<'a, State, Message, Theme, Renderer> {
-    /// Produces the widget of the [`MultiWindow`].
-    fn view(
-        &self,
-        state: &'a State,
-        window: window::Id,
-    ) -> impl Into<Element<'a, Message, Theme, Renderer>>;
-}
-
-impl<'a, T, State, Message, Theme, Renderer, Widget> View<'a, State, Message, Theme, Renderer> for T
-where
-    T: Fn(&'a State, window::Id) -> Widget,
-    State: 'static,
-    Widget: Into<Element<'a, Message, Theme, Renderer>>,
-{
-    fn view(
-        &self,
-        state: &'a State,
-        window: window::Id,
-    ) -> impl Into<Element<'a, Message, Theme, Renderer>> {
-        self(state, window)
-    }
-}

src/app/settings.rs

@@ -16,7 +16,7 @@ pub struct Settings {
     pub(crate) antialiasing: bool,
 
     /// Autosize the window to fit its contents
-    #[cfg(feature = "wayland")]
+    #[cfg(all(feature = "wayland", target_os = "linux"))]
     pub(crate) autosize: bool,
 
     /// Set the application to not create a main window
@@ -80,7 +80,7 @@ impl Default for Settings {
     fn default() -> Self {
         Self {
             antialiasing: true,
-            #[cfg(feature = "wayland")]
+            #[cfg(all(feature = "wayland", target_os = "linux"))]
             autosize: false,
             no_main_window: false,
             client_decorations: true,

src/applet/column.rs

@@ -217,7 +217,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -233,25 +233,26 @@ where
             self.padding,
             self.spacing,
             self.align,
-            &self.children,
+            &mut self.children,
             &mut tree.children,
         )
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
         operation: &mut dyn Operation,
     ) {
-        operation.container(None, layout.bounds(), &mut |operation| {
+        operation.container(None, layout.bounds());
+        operation.traverse(&mut |operation| {
             self.children
-                .iter()
+                .iter_mut()
                 .zip(&mut tree.children)
                 .zip(layout.children())
                 .for_each(|((child, state), c_layout)| {
-                    child.as_widget().operate(
+                    child.as_widget_mut().operate(
                         state,
                         c_layout.with_virtual_offset(layout.virtual_offset()),
                         renderer,
@@ -261,17 +262,17 @@ where
         });
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         viewport: &Rectangle,
-    ) -> event::Status {
+    ) {
         let my_state = tree.state.downcast_mut::<State>();
 
         if let Some(hovered) = my_state.hovered {
@@ -285,7 +286,7 @@ where
                         e,
                         mouse::Event::CursorLeft | mouse::Event::ButtonReleased { .. }
                     ) {
-                        return self.children[hovered].as_widget_mut().on_event(
+                        return self.children[hovered].as_widget_mut().update(
                             &mut tree.children[hovered],
                             event,
                             child_layout.with_virtual_offset(layout.virtual_offset()),
@@ -302,7 +303,7 @@ where
                         iced::core::touch::Event::FingerLifted { .. }
                             | iced::core::touch::Event::FingerLost { .. }
                     ) {
-                        return self.children[hovered].as_widget_mut().on_event(
+                        return self.children[hovered].as_widget_mut().update(
                             &mut tree.children[hovered],
                             event,
                             child_layout.with_virtual_offset(layout.virtual_offset()),
@@ -319,49 +320,49 @@ where
             }
         }
 
-        self.children
+        for (((i, child), state), c_layout) in self
+            .children
             .iter_mut()
             .enumerate()
             .zip(&mut tree.children)
             .zip(layout.children())
-            .map(|(((i, child), state), c_layout)| {
-                let mut cursor_virtual = cursor;
-                if matches!(
-                    event,
-                    Event::Mouse(mouse::Event::CursorMoved { .. } | mouse::Event::CursorEntered)
-                        | Event::Touch(
-                            iced_core::touch::Event::FingerMoved { .. }
-                                | iced_core::touch::Event::FingerPressed { .. }
-                        )
-                ) && cursor.is_over(c_layout.bounds())
-                {
-                    my_state.hovered = Some(i);
-                    return child.as_widget_mut().on_event(
-                        state,
-                        event.clone(),
-                        c_layout.with_virtual_offset(layout.virtual_offset()),
-                        cursor_virtual,
-                        renderer,
-                        clipboard,
-                        shell,
-                        viewport,
-                    );
-                } else if my_state.hovered.is_some_and(|h| i != h) {
-                    cursor_virtual = mouse::Cursor::Unavailable;
-                }
-
-                child.as_widget_mut().on_event(
+        {
+            let mut cursor_virtual = cursor;
+            if matches!(
+                event,
+                Event::Mouse(mouse::Event::CursorMoved { .. } | mouse::Event::CursorEntered)
+                    | Event::Touch(
+                        iced_core::touch::Event::FingerMoved { .. }
+                            | iced_core::touch::Event::FingerPressed { .. }
+                    )
+            ) && cursor.is_over(c_layout.bounds())
+            {
+                my_state.hovered = Some(i);
+                return child.as_widget_mut().update(
                     state,
-                    event.clone(),
+                    &event,
                     c_layout.with_virtual_offset(layout.virtual_offset()),
                     cursor_virtual,
                     renderer,
                     clipboard,
                     shell,
                     viewport,
-                )
-            })
-            .fold(event::Status::Ignored, event::Status::merge)
+                );
+            } else if my_state.hovered.is_some_and(|h| i != h) {
+                cursor_virtual = mouse::Cursor::Unavailable;
+            }
+
+            child.as_widget_mut().update(
+                state,
+                &event,
+                c_layout.with_virtual_offset(layout.virtual_offset()),
+                cursor_virtual,
+                renderer,
+                clipboard,
+                shell,
+                viewport,
+            );
+        }
     }
 
     fn mouse_interaction(
@@ -436,11 +437,19 @@ where
     fn overlay<'b>(
         &'b mut self,
         tree: &'b mut Tree,
-        layout: Layout<'_>,
+        layout: Layout<'b>,
         renderer: &Renderer,
+        viewport: &Rectangle,
         translation: Vector,
     ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
-        overlay::from_children(&mut self.children, tree, layout, renderer, translation)
+        overlay::from_children(
+            &mut self.children,
+            tree,
+            layout,
+            renderer,
+            viewport,
+            translation,
+        )
     }
 
     #[cfg(feature = "a11y")]

src/applet/mod.rs

@@ -1,34 +1,36 @@
 #[cfg(feature = "applet-token")]
 pub mod token;
 
-use crate::app::cosmic;
+use crate::app::{BootData, BootDataInner, cosmic};
 use crate::{
     Application, Element, Renderer,
     app::iced_settings,
     cctk::sctk,
-    iced::{
-        self, Color, Length, Limits, Rectangle,
-        alignment::{Alignment, Horizontal, Vertical},
-        widget::Container,
-        window,
-    },
-    iced_widget,
     theme::{self, Button, THEME, system_dark, system_light},
     widget::{
         self,
         autosize::{self, Autosize, autosize},
         column::Column,
-        horizontal_space, layer_container,
+        layer_container,
         row::Row,
-        vertical_space,
+        space::horizontal,
+        space::vertical,
     },
 };
+
 pub use cosmic_panel_config;
 use cosmic_panel_config::{CosmicPanelBackground, PanelAnchor, PanelSize};
+use iced::{
+    self, Color, Length, Limits, Rectangle,
+    alignment::{Alignment, Horizontal, Vertical},
+    widget::Container,
+    window,
+};
 use iced_core::{Padding, Shadow};
+use iced_runtime::platform_specific::wayland::popup::{SctkPopupSettings, SctkPositioner};
 use iced_widget::Text;
-use iced_widget::runtime::platform_specific::wayland::popup::{SctkPopupSettings, SctkPositioner};
 use sctk::reexports::protocols::xdg::shell::client::xdg_positioner::{Anchor, Gravity};
+use std::cell::RefCell;
 use std::{borrow::Cow, num::NonZeroU32, rc::Rc, sync::LazyLock, time::Duration};
 use tracing::info;
 
@@ -40,7 +42,7 @@ static AUTOSIZE_ID: LazyLock<iced::id::Id> =
 static AUTOSIZE_MAIN_ID: LazyLock<iced::id::Id> =
     LazyLock::new(|| iced::id::Id::new("cosmic-applet-autosize-main"));
 static TOOLTIP_ID: LazyLock<crate::widget::Id> = LazyLock::new(|| iced::id::Id::new("subsurface"));
-static TOOLTIP_WINDOW_ID: LazyLock<window::Id> = LazyLock::new(window::Id::unique);
+pub(crate) static TOOLTIP_WINDOW_ID: LazyLock<window::Id> = LazyLock::new(window::Id::unique);
 
 #[derive(Debug, Clone)]
 pub struct Context {
@@ -224,7 +226,7 @@ impl Context {
         let symbolic = icon.symbolic;
         let icon = widget::icon(icon)
             .class(if symbolic {
-                theme::Svg::Custom(Rc::new(|theme| crate::iced_widget::svg::Style {
+                theme::Svg::Custom(Rc::new(|theme| iced_widget::svg::Style {
                     color: Some(theme.cosmic().background.on.into()),
                 }))
             } else {
@@ -386,10 +388,10 @@ impl Context {
                         },
                         shadow: Shadow::default(),
                         icon_color: Some(cosmic.background.on.into()),
+                        snap: true,
                     }
                 }),
             )
-            .width(Length::Shrink)
             .height(Length::Shrink)
             .align_x(horizontal_align)
             .align_y(vertical_align),
@@ -571,26 +573,33 @@ pub fn run<App: Application>(flags: App::Flags) -> iced::Result {
 
     // TODO make multi-window not mandatory
 
-    let mut app = super::app::multi_window::multi_window::<_, _, _, _, App::Executor>(
-        cosmic::Cosmic::title,
+    let no_main_window = core.main_window.is_none();
+    if no_main_window {
+        // TODO still apply window settings?
+        // window_settings = window_settings.clone();
+        core.main_window = Some(iced_core::window::Id::RESERVED);
+    }
+    let mut app = iced::daemon(
+        BootData(Rc::new(RefCell::new(Some(BootDataInner::<App> {
+            flags,
+            core,
+            settings: window_settings,
+        })))),
         cosmic::Cosmic::update,
         cosmic::Cosmic::view,
     );
-    if core.main_window.is_none() {
-        app = app.window(window_settings.clone());
-        core.main_window = Some(iced_core::window::Id::RESERVED);
-    }
+
     app.subscription(cosmic::Cosmic::subscription)
         .style(cosmic::Cosmic::style)
         .theme(cosmic::Cosmic::theme)
         .settings(iced_settings)
-        .run_with(move || cosmic::Cosmic::<App>::init((core, flags)))
+        .run()
 }
 
 #[must_use]
-pub fn style() -> iced_runtime::Appearance {
+pub fn style() -> iced::theme::Style {
     let theme = crate::theme::THEME.lock().unwrap();
-    iced_runtime::Appearance {
+    iced::theme::Style {
         background_color: Color::from_rgba(0.0, 0.0, 0.0, 0.0),
         text_color: theme.cosmic().on_bg_color().into(),
         icon_color: theme.cosmic().on_bg_color().into(),

src/applet/row.rs

@@ -208,7 +208,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -222,25 +222,26 @@ where
             self.padding,
             self.spacing,
             self.align,
-            &self.children,
+            &mut self.children,
             &mut tree.children,
         )
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
         operation: &mut dyn Operation,
     ) {
-        operation.container(None, layout.bounds(), &mut |operation| {
+        operation.container(None, layout.bounds());
+        operation.traverse(&mut |operation| {
             self.children
-                .iter()
+                .iter_mut()
                 .zip(&mut tree.children)
                 .zip(layout.children())
                 .for_each(|((child, state), c_layout)| {
-                    child.as_widget().operate(
+                    child.as_widget_mut().operate(
                         state,
                         c_layout.with_virtual_offset(layout.virtual_offset()),
                         renderer,
@@ -250,17 +251,17 @@ where
         });
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         viewport: &Rectangle,
-    ) -> event::Status {
+    ) {
         let my_state = tree.state.downcast_mut::<State>();
 
         if let Some(hovered) = my_state.hovered {
@@ -274,7 +275,7 @@ where
                         e,
                         mouse::Event::CursorLeft | mouse::Event::ButtonReleased { .. }
                     ) {
-                        return self.children[hovered].as_widget_mut().on_event(
+                        return self.children[hovered].as_widget_mut().update(
                             &mut tree.children[hovered],
                             event,
                             child_layout.with_virtual_offset(layout.virtual_offset()),
@@ -291,7 +292,7 @@ where
                         iced::core::touch::Event::FingerLifted { .. }
                             | iced::core::touch::Event::FingerLost { .. }
                     ) {
-                        return self.children[hovered].as_widget_mut().on_event(
+                        return self.children[hovered].as_widget_mut().update(
                             &mut tree.children[hovered],
                             event,
                             child_layout.with_virtual_offset(layout.virtual_offset()),
@@ -308,50 +309,50 @@ where
             }
         }
 
-        self.children
+        for (((i, child), state), c_layout) in self
+            .children
             .iter_mut()
             .enumerate()
             .zip(&mut tree.children)
             .zip(layout.children())
-            .map(|(((i, child), state), c_layout)| {
-                let mut cursor_virtual = cursor;
+        {
+            let mut cursor_virtual = cursor;
 
-                if matches!(
-                    event,
-                    Event::Mouse(mouse::Event::CursorMoved { .. } | mouse::Event::CursorEntered)
-                        | Event::Touch(
-                            iced_core::touch::Event::FingerMoved { .. }
-                                | iced_core::touch::Event::FingerPressed { .. }
-                        )
-                ) && cursor.is_over(c_layout.bounds())
-                {
-                    my_state.hovered = Some(i);
-                    return child.as_widget_mut().on_event(
-                        state,
-                        event.clone(),
-                        c_layout.with_virtual_offset(layout.virtual_offset()),
-                        cursor_virtual,
-                        renderer,
-                        clipboard,
-                        shell,
-                        viewport,
-                    );
-                } else if my_state.hovered.is_some_and(|h| i != h) {
-                    cursor_virtual = mouse::Cursor::Unavailable;
-                }
-
-                child.as_widget_mut().on_event(
+            if matches!(
+                event,
+                Event::Mouse(mouse::Event::CursorMoved { .. } | mouse::Event::CursorEntered)
+                    | Event::Touch(
+                        iced_core::touch::Event::FingerMoved { .. }
+                            | iced_core::touch::Event::FingerPressed { .. }
+                    )
+            ) && cursor.is_over(c_layout.bounds())
+            {
+                my_state.hovered = Some(i);
+                return child.as_widget_mut().update(
                     state,
-                    event.clone(),
+                    &event,
                     c_layout.with_virtual_offset(layout.virtual_offset()),
                     cursor_virtual,
                     renderer,
                     clipboard,
                     shell,
                     viewport,
-                )
-            })
-            .fold(event::Status::Ignored, event::Status::merge)
+                );
+            } else if my_state.hovered.is_some_and(|h| i != h) {
+                cursor_virtual = mouse::Cursor::Unavailable;
+            }
+
+            child.as_widget_mut().update(
+                state,
+                &event,
+                c_layout.with_virtual_offset(layout.virtual_offset()),
+                cursor_virtual,
+                renderer,
+                clipboard,
+                shell,
+                viewport,
+            );
+        }
     }
 
     fn mouse_interaction(
@@ -426,11 +427,19 @@ where
     fn overlay<'b>(
         &'b mut self,
         tree: &'b mut Tree,
-        layout: Layout<'_>,
+        layout: Layout<'b>,
         renderer: &Renderer,
+        viewport: &Rectangle,
         translation: Vector,
     ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
-        overlay::from_children(&mut self.children, tree, layout, renderer, translation)
+        overlay::from_children(
+            &mut self.children,
+            tree,
+            layout,
+            renderer,
+            viewport,
+            translation,
+        )
     }
 
     #[cfg(feature = "a11y")]

src/applet/token/subscription.rs

@@ -1,11 +1,11 @@
 use crate::iced;
-use crate::iced_futures::futures;
 use cctk::sctk::reexports::calloop;
 use futures::{
     SinkExt, StreamExt,
     channel::mpsc::{UnboundedReceiver, unbounded},
 };
 use iced::Subscription;
+use iced_futures::futures;
 use iced_futures::stream;
 use std::{fmt::Debug, hash::Hash, thread::JoinHandle};
 
@@ -14,16 +14,15 @@ use super::wayland_handler::wayland_handler;
 pub fn activation_token_subscription<I: 'static + Hash + Copy + Send + Sync + Debug>(
     id: I,
 ) -> iced::Subscription<TokenUpdate> {
-    Subscription::run_with_id(
-        id,
+    Subscription::run_with(id, |_| {
         stream::channel(50, move |mut output| async move {
             let mut state = State::Ready;
 
             loop {
                 state = start_listening(state, &mut output).await;
             }
-        }),
-    )
+        })
+    })
 }
 
 pub enum State {

src/command.rs

@@ -39,7 +39,7 @@ pub fn set_theme<M: Send + 'static>(theme: crate::Theme) -> iced::Task<crate::Ac
 
 /// Sets the window mode to windowed.
 pub fn set_windowed<M>(id: window::Id) -> iced::Task<crate::Action<M>> {
-    iced_runtime::window::change_mode(id, window::Mode::Windowed)
+    iced_runtime::window::set_mode(id, window::Mode::Windowed)
 }
 
 /// Toggles the windows' maximize state.

src/core.rs

@@ -99,7 +99,7 @@ pub struct Core {
 
     pub(crate) menu_bars: HashMap<crate::widget::Id, (Limits, Size)>,
 
-    #[cfg(feature = "wayland")]
+    #[cfg(all(feature = "wayland", target_os = "linux"))]
     pub(crate) sync_window_border_radii_to_theme: bool,
 }
 
@@ -159,7 +159,7 @@ impl Default for Core {
             main_window: None,
             exit_on_main_window_closed: true,
             menu_bars: HashMap::new(),
-            #[cfg(feature = "wayland")]
+            #[cfg(all(feature = "wayland", target_os = "linux"))]
             sync_window_border_radii_to_theme: true,
         }
     }
@@ -493,12 +493,12 @@ impl Core {
     }
 
     // TODO should we emit tasks setting the corner radius or unsetting it if this is changed?
-    #[cfg(feature = "wayland")]
+    #[cfg(all(feature = "wayland", target_os = "linux"))]
     pub fn set_sync_window_border_radii_to_theme(&mut self, sync: bool) {
         self.sync_window_border_radii_to_theme = sync;
     }
 
-    #[cfg(feature = "wayland")]
+    #[cfg(all(feature = "wayland", target_os = "linux"))]
     pub fn sync_window_border_radii_to_theme(&self) -> bool {
         self.sync_window_border_radii_to_theme
     }

src/dbus_activation.rs

@@ -16,75 +16,80 @@ use {
 #[cold]
 pub fn subscription<App: ApplicationExt>() -> Subscription<crate::Action<App::Message>> {
     use iced_futures::futures::StreamExt;
-    iced_futures::Subscription::run_with_id(
-        TypeId::of::<DbusActivation>(),
-        iced::stream::channel(10, move |mut output| async move {
-            let mut single_instance: DbusActivation = DbusActivation::new();
-            let mut rx = single_instance.rx();
-            if let Ok(builder) = zbus::connection::Builder::session() {
-                let path: String = format!("/{}", App::APP_ID.replace('.', "/"));
-                if let Ok(conn) = builder.build().await {
-                    // XXX Setup done this way seems to be more reliable.
-                    //
-                    // the docs for serve_at seem to imply it will replace the
-                    // existing interface at the requested path, but it doesn't
-                    // seem to work that way all the time. The docs for
-                    // object_server().at() imply it won't replace the existing
-                    // interface.
-                    //
-                    // request_name is used either way, with the builder or
-                    // with the connection, but it must be done after the
-                    // object server is setup.
-                    if conn.object_server().at(path, single_instance).await != Ok(true) {
-                        tracing::error!("Failed to serve dbus");
-                        std::process::exit(1);
-                    }
-                    if conn.request_name(App::APP_ID).await.is_err() {
-                        tracing::error!("Failed to serve dbus");
-                        std::process::exit(1);
-                    }
+    iced_futures::Subscription::run_with(TypeId::of::<DbusActivation>(), |_| {
+        iced::stream::channel(
+            10,
+            move |mut output: Sender<crate::Action<App::Message>>| async move {
+                let mut single_instance: DbusActivation = DbusActivation::new();
+                let mut rx = single_instance.rx();
+                if let Ok(builder) = zbus::connection::Builder::session() {
+                    let path: String = format!("/{}", App::APP_ID.replace('.', "/"));
+                    if let Ok(conn) = builder.build().await {
+                        // XXX Setup done this way seems to be more reliable.
+                        //
+                        // the docs for serve_at seem to imply it will replace the
+                        // existing interface at the requested path, but it doesn't
+                        // seem to work that way all the time. The docs for
+                        // object_server().at() imply it won't replace the existing
+                        // interface.
+                        //
+                        // request_name is used either way, with the builder or
+                        // with the connection, but it must be done after the
+                        // object server is setup.
+                        if conn.object_server().at(path, single_instance).await != Ok(true) {
+                            tracing::error!("Failed to serve dbus");
+                            std::process::exit(1);
+                        }
+                        if conn.request_name(App::APP_ID).await.is_err() {
+                            tracing::error!("Failed to serve dbus");
+                            std::process::exit(1);
+                        }
 
-                    output
-                        .send(crate::Action::Cosmic(crate::app::Action::DbusConnection(
-                            conn.clone(),
-                        )))
-                        .await;
+                        output
+                            .send(crate::Action::Cosmic(crate::app::Action::DbusConnection(
+                                conn.clone(),
+                            )))
+                            .await;
 
-                    #[cfg(feature = "smol")]
-                    let handle = {
-                        std::thread::spawn(move || {
-                            let conn_clone = _conn.clone();
+                        #[cfg(feature = "smol")]
+                        let handle = {
+                            std::thread::spawn(move || {
+                                let conn_clone = _conn.clone();
 
-                            zbus::block_on(async move {
-                                loop {
-                                    conn_clone.executor().tick().await;
-                                }
+                                zbus::block_on(async move {
+                                    loop {
+                                        conn_clone.executor().tick().await;
+                                    }
+                                })
                             })
-                        })
-                    };
-                    while let Some(mut msg) = rx.next().await {
-                        if let Some(token) = msg.activation_token.take() {
-                            if let Err(err) = output
-                                .send(crate::Action::Cosmic(crate::app::Action::Activate(token)))
-                                .await
+                        };
+                        while let Some(mut msg) = rx.next().await {
+                            if let Some(token) = msg.activation_token.take() {
+                                if let Err(err) = output
+                                    .send(crate::Action::Cosmic(crate::app::Action::Activate(
+                                        token,
+                                    )))
+                                    .await
+                                {
+                                    tracing::error!(?err, "Failed to send message");
+                                }
+                            }
+                            if let Err(err) = output.send(crate::Action::DbusActivation(msg)).await
                             {
                                 tracing::error!(?err, "Failed to send message");
                             }
                         }
-                        if let Err(err) = output.send(crate::Action::DbusActivation(msg)).await {
-                            tracing::error!(?err, "Failed to send message");
-                        }
                     }
+                } else {
+                    tracing::warn!("Failed to connect to dbus for single instance");
                 }
-            } else {
-                tracing::warn!("Failed to connect to dbus for single instance");
-            }
 
-            loop {
-                iced::futures::pending!();
-            }
-        }),
-    )
+                loop {
+                    iced::futures::pending!();
+                }
+            },
+        )
+    })
 }
 
 #[derive(Debug, Clone)]

src/desktop.rs

@@ -416,7 +416,6 @@ fn match_exec_basename(
         };
 
         let basename_lower = basename.to_ascii_lowercase();
-
         if normalized
             .iter()
             .any(|candidate| candidate == &basename_lower)
@@ -440,8 +439,7 @@ fn fallback_entry(context: &DesktopLookupContext<'_>) -> fde::DesktopEntry {
     let name = context
         .title
         .as_ref()
-        .map(|title| title.to_string())
-        .unwrap_or_else(|| context.app_id.to_string());
+        .map_or_else(|| context.app_id.to_string(), |title| title.to_string());
     entry.add_desktop_entry("Name".to_string(), name);
     entry
 }
@@ -458,7 +456,9 @@ fn proton_or_wine_fallback(
 ) -> Option<fde::DesktopEntry> {
     let app_id = context.app_id.as_ref();
     let is_proton_game = app_id == "steam_app_default";
-    let is_wine_entry = app_id.ends_with(".exe");
+    let is_wine_entry = std::path::Path::new(app_id)
+        .extension()
+        .is_some_and(|ext| ext.eq_ignore_ascii_case("exe"));
 
     if !is_proton_game && !is_wine_entry {
         return None;
@@ -487,10 +487,6 @@ fn proton_or_wine_fallback(
 
 #[cfg(not(windows))]
 fn candidate_desktop_ids(context: &DesktopLookupContext<'_>) -> Vec<String> {
-    const SUFFIXES: &[&str] = &[".desktop", ".Desktop", ".DESKTOP"];
-    let mut ordered = Vec::new();
-    let mut seen = HashSet::new();
-
     fn push_candidate(seen: &mut HashSet<String>, ordered: &mut Vec<String>, candidate: &str) {
         let trimmed = candidate.trim();
         if trimmed.is_empty() {
@@ -531,11 +527,11 @@ fn candidate_desktop_ids(context: &DesktopLookupContext<'_>) -> Vec<String> {
             }
         }
 
-        if trimmed.contains('.') {
-            if let Some(last) = trimmed.rsplit('.').next() {
-                if last.len() >= 2 {
-                    push_candidate(seen, ordered, last);
-                }
+        if trimmed.contains('.')
+            && let Some(last) = trimmed.rsplit('.').next()
+        {
+            if last.len() >= 2 {
+                push_candidate(seen, ordered, last);
             }
         }
 
@@ -546,13 +542,20 @@ fn candidate_desktop_ids(context: &DesktopLookupContext<'_>) -> Vec<String> {
             push_candidate(seen, ordered, &trimmed.replace('_', "-"));
         }
 
-        for token in trimmed.split(|c: char| matches!(c, '.' | '-' | '_' | '@' | ' ')) {
+        for token in
+            trimmed.split(|c: char| matches!(c, '.' | '-' | '_' | '@') || c.is_whitespace())
+        {
             if token.len() >= 2 && token != trimmed {
                 push_candidate(seen, ordered, token);
             }
         }
     }
 
+    const SUFFIXES: &[&str] = &[".desktop", ".Desktop", ".DESKTOP"];
+
+    let mut ordered = Vec::new();
+    let mut seen = HashSet::new();
+
     add_variants(
         &mut seen,
         &mut ordered,
@@ -786,7 +789,7 @@ pub async fn spawn_desktop_exec<S, I, K, V>(
             })
             .unwrap_or_else(|| String::from("cosmic-term"));
 
-        term_exec = format!("{term} -- {}", exec.as_ref());
+        term_exec = format!("{term} -e {}", exec.as_ref());
         &term_exec
     } else {
         exec.as_ref()
@@ -915,12 +918,20 @@ mod tests {
         let candidates = candidate_desktop_ids(&ctx);
 
         assert_eq!(candidates.first().unwrap(), "com.example.App.desktop");
-        assert!(candidates.contains(&"com.example.App".to_string()));
-        assert!(candidates.contains(&"com-example-App".to_string()));
-        assert!(candidates.contains(&"com_example_App".to_string()));
-        assert!(candidates.contains(&"Example App".to_string()));
-        assert!(candidates.contains(&"Example".to_string()));
-        assert!(candidates.contains(&"App".to_string()));
+        for test in [
+            "com.example.App",
+            "com-example-App",
+            "com_example_App",
+            "Example App",
+            "Example",
+            "App",
+        ] {
+            assert!(
+                candidates
+                    .iter()
+                    .any(|c| c.to_ascii_lowercase() == test.to_ascii_lowercase()),
+            );
+        }
     }
 
     #[test]
@@ -985,7 +996,7 @@ Icon=vmware-workstation\n\
 
         let resolved = resolve_desktop_entry(&mut cache, &ctx, &DesktopResolveOptions::default());
 
-        assert_eq!(resolved.id(), "vmware-workstation.desktop");
+        assert_eq!(resolved.id(), "vmware-workstation");
     }
 
     #[test]

src/executor/multi.rs

@@ -26,4 +26,8 @@ impl iced::Executor for Executor {
         let _guard = self.0.enter();
         f()
     }
+
+    fn block_on<T>(&self, future: impl Future<Output = T>) -> T {
+        self.0.block_on(future)
+    }
 }

src/executor/single.rs

@@ -30,4 +30,8 @@ impl iced::Executor for Executor {
         let _guard = self.0.enter();
         f()
     }
+
+    fn block_on<T>(&self, future: impl Future<Output = T>) -> T {
+        self.0.block_on(future)
+    }
 }

src/ext.rs

@@ -19,72 +19,6 @@ impl<Message: 'static> ElementExt for crate::Element<'_, Message> {
     }
 }
 
-/// Additional methods for the [`Column`] and [`Row`] widgets.
-pub trait CollectionWidget<'a, Message: 'a>:
-    Widget<Message, crate::Theme, crate::Renderer>
-where
-    Self: Sized,
-{
-    /// Moves all the elements of `other` into `self`, leaving `other` empty.
-    #[must_use]
-    fn append<E>(self, other: &mut Vec<E>) -> Self
-    where
-        E: Into<crate::Element<'a, Message>>;
-
-    /// Appends all elements in an iterator to the widget.
-    #[must_use]
-    fn extend<E>(mut self, iterator: impl Iterator<Item = E>) -> Self
-    where
-        E: Into<crate::Element<'a, Message>>,
-    {
-        for item in iterator {
-            self = self.push(item.into());
-        }
-
-        self
-    }
-
-    /// Pushes an element into the widget.
-    #[must_use]
-    fn push(self, element: impl Into<crate::Element<'a, Message>>) -> Self;
-
-    /// Conditionally pushes an element to the widget.
-    #[must_use]
-    fn push_maybe(self, element: Option<impl Into<crate::Element<'a, Message>>>) -> Self {
-        if let Some(element) = element {
-            self.push(element.into())
-        } else {
-            self
-        }
-    }
-}
-
-impl<'a, Message: 'a> CollectionWidget<'a, Message> for crate::widget::Column<'a, Message> {
-    fn append<E>(self, other: &mut Vec<E>) -> Self
-    where
-        E: Into<crate::Element<'a, Message>>,
-    {
-        self.extend(other.drain(..).map(Into::into))
-    }
-
-    fn push(self, element: impl Into<crate::Element<'a, Message>>) -> Self {
-        self.push(element)
-    }
-}
-
-impl<'a, Message: 'a> CollectionWidget<'a, Message> for crate::widget::Row<'a, Message> {
-    fn append<E>(self, other: &mut Vec<E>) -> Self
-    where
-        E: Into<crate::Element<'a, Message>>,
-    {
-        self.extend(other.drain(..).map(Into::into))
-    }
-
-    fn push(self, element: impl Into<crate::Element<'a, Message>>) -> Self {
-        self.push(element)
-    }
-}
-
 pub trait ColorExt {
     /// Combines color with background to create appearance of transparency.
     #[must_use]

src/lib.rs

@@ -3,6 +3,7 @@
 
 #![allow(clippy::module_name_repetitions)]
 #![cfg_attr(target_os = "redox", feature(lazy_cell))]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 
 /// Recommended default imports.
 pub mod prelude {
@@ -18,6 +19,8 @@ pub use apply::{Also, Apply};
 pub mod action;
 pub use action::Action;
 
+pub mod anim;
+
 #[cfg(feature = "winit")]
 pub mod app;
 #[cfg(feature = "winit")]
@@ -64,29 +67,6 @@ pub mod font;
 #[doc(inline)]
 pub use iced;
 
-#[doc(inline)]
-pub use iced_core;
-
-#[doc(inline)]
-pub use iced_futures;
-
-#[doc(inline)]
-pub use iced_renderer;
-
-#[doc(inline)]
-pub use iced_runtime;
-
-#[doc(inline)]
-pub use iced_widget;
-
-#[doc(inline)]
-#[cfg(feature = "winit")]
-pub use iced_winit;
-
-#[doc(inline)]
-#[cfg(feature = "wgpu")]
-pub use iced_wgpu;
-
 pub mod icon_theme;
 pub mod keyboard_nav;
 
@@ -98,7 +78,8 @@ pub(crate) mod malloc;
 #[cfg(all(feature = "process", not(windows)))]
 pub mod process;
 
-#[cfg(feature = "wayland")]
+#[doc(inline)]
+#[cfg(all(feature = "wayland", target_os = "linux"))]
 pub use cctk;
 
 pub mod surface;

src/surface/action.rs

@@ -9,25 +9,25 @@ use iced::window;
 use std::{any::Any, sync::Arc};
 
 /// Used to produce a destroy popup message from within a widget.
-#[cfg(feature = "wayland")]
+#[cfg(all(feature = "wayland", target_os = "linux"))]
 #[must_use]
 pub fn destroy_popup(id: iced_core::window::Id) -> Action {
     Action::DestroyPopup(id)
 }
 
-#[cfg(feature = "wayland")]
+#[cfg(all(feature = "wayland", target_os = "linux"))]
 #[must_use]
 pub fn destroy_subsurface(id: iced_core::window::Id) -> Action {
     Action::DestroySubsurface(id)
 }
 
-#[cfg(feature = "wayland")]
+#[cfg(all(feature = "wayland", target_os = "linux"))]
 #[must_use]
 pub fn destroy_window(id: iced_core::window::Id) -> Action {
     Action::DestroyWindow(id)
 }
 
-#[cfg(all(feature = "wayland", feature = "winit"))]
+#[cfg(all(feature = "wayland", target_os = "linux", feature = "winit"))]
 #[must_use]
 pub fn app_window<App: Application>(
     settings: impl Fn(&mut App) -> window::Settings + Send + Sync + 'static,
@@ -60,7 +60,7 @@ pub fn app_window<App: Application>(
 }
 
 /// Used to create a window message from within a widget.
-#[cfg(all(feature = "wayland", feature = "winit"))]
+#[cfg(all(feature = "wayland", target_os = "linux", feature = "winit"))]
 #[must_use]
 pub fn simple_window<Message: 'static>(
     settings: impl Fn() -> window::Settings + Send + Sync + 'static,
@@ -92,7 +92,7 @@ pub fn simple_window<Message: 'static>(
     )
 }
 
-#[cfg(all(feature = "wayland", feature = "winit"))]
+#[cfg(all(feature = "wayland", target_os = "linux", feature = "winit"))]
 #[must_use]
 pub fn app_popup<App: Application>(
     settings: impl Fn(&mut App) -> iced_runtime::platform_specific::wayland::popup::SctkPopupSettings
@@ -126,7 +126,7 @@ pub fn app_popup<App: Application>(
 }
 
 /// Used to create a subsurface message from within a widget.
-#[cfg(all(feature = "wayland", feature = "winit"))]
+#[cfg(all(feature = "wayland", target_os = "linux", feature = "winit"))]
 #[must_use]
 pub fn simple_subsurface<Message: 'static, V>(
     settings: impl Fn() -> iced_runtime::platform_specific::wayland::subsurface::SctkSubsurfaceSettings
@@ -155,7 +155,7 @@ pub fn simple_subsurface<Message: 'static, V>(
 }
 
 /// Used to create a popup message from within a widget.
-#[cfg(all(feature = "wayland", feature = "winit"))]
+#[cfg(all(feature = "wayland", target_os = "linux", feature = "winit"))]
 #[must_use]
 pub fn simple_popup<Message: 'static>(
     settings: impl Fn() -> iced_runtime::platform_specific::wayland::popup::SctkPopupSettings
@@ -186,7 +186,7 @@ pub fn simple_popup<Message: 'static>(
     )
 }
 
-#[cfg(all(feature = "wayland", feature = "winit"))]
+#[cfg(all(feature = "wayland", target_os = "linux", feature = "winit"))]
 #[must_use]
 pub fn subsurface<App: Application>(
     settings: impl Fn(

src/surface/mod.rs

@@ -36,6 +36,8 @@ pub enum Action {
     ),
     /// Destroy a subsurface with a view function
     DestroyPopup(iced::window::Id),
+    /// Destroys the global tooltip popup subsurface
+    DestroyTooltipPopup,
 
     /// Create a window with a view function accepting the App as a parameter
     AppWindow(
@@ -85,6 +87,7 @@ impl std::fmt::Debug for Action {
             }
             Self::Popup(arg0, arg1) => f.debug_tuple("Popup").field(arg0).field(arg1).finish(),
             Self::DestroyPopup(arg0) => f.debug_tuple("DestroyPopup").field(arg0).finish(),
+            Self::DestroyTooltipPopup => f.debug_tuple("DestroyTooltipPopup").finish(),
             Self::ResponsiveMenuBar {
                 menu_bar,
                 limits,

src/theme/mod.rs

@@ -307,7 +307,7 @@ impl DefaultStyle for Theme {
     fn default_style(&self) -> Appearance {
         let cosmic = self.cosmic();
         Appearance {
-            icon_color: cosmic.bg_color().into(),
+            icon_color: cosmic.on_bg_color().into(),
             background_color: cosmic.bg_color().into(),
             text_color: cosmic.on_bg_color().into(),
         }

src/theme/portal.rs

@@ -13,9 +13,8 @@ pub enum Desktop {
 
 #[cold]
 pub fn desktop_settings() -> iced_futures::Subscription<Desktop> {
-    iced_futures::Subscription::run_with_id(
-        std::any::TypeId::of::<Desktop>(),
-        stream::channel(10, |mut tx| {
+    iced_futures::Subscription::run(|| {
+        stream::channel(10, |mut tx: futures::channel::mpsc::Sender<Desktop>| {
             async move {
                 let mut attempts = 0;
                 loop {
@@ -99,6 +98,6 @@ pub fn desktop_settings() -> iced_futures::Subscription<Desktop> {
                     }
                 }
             }
-        }),
-    )
+        })
+    })
 }

src/theme/style/button.rs

@@ -27,7 +27,7 @@ pub enum Button {
     IconVertical,
     Image,
     Link,
-    ListItem,
+    ListItem([f32; 4]),
     MenuFolder,
     MenuItem,
     MenuRoot,
@@ -148,8 +148,8 @@ pub fn appearance(
             appearance.text_color = Some(component.on.into());
             corner_radii = &cosmic.corner_radii.radius_s;
         }
-        Button::ListItem => {
-            corner_radii = &[0.0; 4];
+        Button::ListItem(radii) => {
+            corner_radii = radii;
             let (background, text, icon) = color(&cosmic.background.component);
 
             if selected {
@@ -197,7 +197,7 @@ impl Catalog for crate::Theme {
             return active(focused, self);
         }
 
-        appearance(self, focused, selected, false, style, move |component| {
+        let mut s = appearance(self, focused, selected, false, style, move |component| {
             let text_color = if matches!(
                 style,
                 Button::Icon | Button::IconVertical | Button::HeaderBar
@@ -209,7 +209,15 @@ impl Catalog for crate::Theme {
             };
 
             (component.base.into(), text_color, text_color)
-        })
+        });
+
+        if let Button::ListItem(_) = style {
+            if !selected {
+                s.background = None;
+            }
+        }
+
+        s
     }
 
     fn disabled(&self, style: &Self::Class) -> Style {
@@ -237,7 +245,7 @@ impl Catalog for crate::Theme {
             return hovered(focused, self);
         }
 
-        appearance(
+        let mut s = appearance(
             self,
             focused || matches!(style, Button::Image),
             selected,
@@ -256,7 +264,15 @@ impl Catalog for crate::Theme {
 
                 (component.hover.into(), text_color, text_color)
             },
-        )
+        );
+
+        if let Button::ListItem(_) = style {
+            if !selected {
+                s.background = None;
+            }
+        }
+
+        s
     }
 
     fn pressed(&self, focused: bool, selected: bool, style: &Self::Class) -> Style {

src/theme/style/iced.rs

@@ -7,6 +7,7 @@ use crate::theme::{CosmicComponent, TRANSPARENT_COMPONENT, Theme};
 use cosmic_theme::composite::over;
 use iced::{
     overlay::menu,
+    theme::Base,
     widget::{
         button as iced_button, checkbox as iced_checkbox, combo_box, container as iced_container,
         pane_grid, pick_list, progress_bar, radio, rule, scrollable,
@@ -15,7 +16,7 @@ use iced::{
     },
 };
 use iced_core::{Background, Border, Color, Shadow, Vector};
-use iced_widget::{pane_grid::Highlight, text_editor, text_input};
+use iced_widget::{pane_grid::Highlight, scrollable::AutoScroll, text_editor, text_input};
 use palette::WithAlpha;
 use std::rc::Rc;
 
@@ -36,13 +37,13 @@ pub mod application {
         }
     }
 
-    pub fn appearance(theme: &Theme) -> Appearance {
+    pub fn style(theme: &Theme) -> iced::theme::Style {
         let cosmic = theme.cosmic();
 
-        Appearance {
-            icon_color: cosmic.bg_color().into(),
+        iced::theme::Style {
             background_color: cosmic.bg_color().into(),
             text_color: cosmic.on_bg_color().into(),
+            icon_color: cosmic.on_bg_color().into(),
         }
     }
 }
@@ -422,6 +423,7 @@ impl<'a> Container<'a> {
                 ..Default::default()
             },
             shadow: Shadow::default(),
+            snap: true,
         }
     }
 
@@ -436,6 +438,7 @@ impl<'a> Container<'a> {
                 ..Default::default()
             },
             shadow: Shadow::default(),
+            snap: true,
         }
     }
 
@@ -450,6 +453,7 @@ impl<'a> Container<'a> {
                 ..Default::default()
             },
             shadow: Shadow::default(),
+            snap: true,
         }
     }
 }
@@ -493,6 +497,7 @@ impl iced_container::Catalog for Theme {
                     ..Default::default()
                 },
                 shadow: Shadow::default(),
+                snap: true,
             },
 
             Container::List => {
@@ -506,6 +511,7 @@ impl iced_container::Catalog for Theme {
                         ..Default::default()
                     },
                     shadow: Shadow::default(),
+                    snap: true,
                 }
             }
 
@@ -552,6 +558,7 @@ impl iced_container::Catalog for Theme {
                         .into(),
                         ..Default::default()
                     },
+                    snap: true,
                     shadow: Shadow::default(),
                 }
             }
@@ -582,6 +589,7 @@ impl iced_container::Catalog for Theme {
                     radius: cosmic.corner_radii.radius_s.into(),
                 },
                 shadow: Shadow::default(),
+                snap: true,
             },
 
             Container::Tooltip => iced_container::Style {
@@ -593,6 +601,7 @@ impl iced_container::Catalog for Theme {
                     ..Default::default()
                 },
                 shadow: Shadow::default(),
+                snap: true,
             },
 
             Container::Card => {
@@ -610,6 +619,7 @@ impl iced_container::Catalog for Theme {
                             ..Default::default()
                         },
                         shadow: Shadow::default(),
+                        snap: true,
                     },
                     cosmic_theme::Layer::Primary => iced_container::Style {
                         icon_color: Some(Color::from(cosmic.primary.component.on)),
@@ -622,6 +632,7 @@ impl iced_container::Catalog for Theme {
                             ..Default::default()
                         },
                         shadow: Shadow::default(),
+                        snap: true,
                     },
                     cosmic_theme::Layer::Secondary => iced_container::Style {
                         icon_color: Some(Color::from(cosmic.secondary.component.on)),
@@ -634,6 +645,7 @@ impl iced_container::Catalog for Theme {
                             ..Default::default()
                         },
                         shadow: Shadow::default(),
+                        snap: true,
                     },
                 }
             }
@@ -652,6 +664,7 @@ impl iced_container::Catalog for Theme {
                     offset: Vector::new(0.0, 4.0),
                     blur_radius: 16.0,
                 },
+                snap: true,
             },
         }
     }
@@ -791,6 +804,7 @@ impl menu::Catalog for Theme {
             },
             selected_text_color: cosmic.accent_text_color().into(),
             selected_background: Background::Color(cosmic.background.component.hover.into()),
+            shadow: Default::default(),
         }
     }
 }
@@ -830,7 +844,7 @@ impl pick_list::Catalog for Theme {
                 background: Background::Color(cosmic.background.base.into()),
                 ..appearance
             },
-            pick_list::Status::Opened => appearance,
+            pick_list::Status::Opened { is_hovered: _ } => appearance,
         }
     }
 }
@@ -920,6 +934,8 @@ impl toggler::Catalog for Theme {
             background_border_color: Color::TRANSPARENT,
             foreground_border_width: 0.0,
             foreground_border_color: Color::TRANSPARENT,
+            text_color: None,
+            padding_ratio: 0.0,
         };
         match status {
             toggler::Status::Active { is_toggled } => active,
@@ -942,9 +958,9 @@ impl toggler::Catalog for Theme {
                     ..active
                 }
             }
-            toggler::Status::Disabled => {
-                active.background.a /= 2.;
-                active.foreground.a /= 2.;
+            toggler::Status::Disabled { is_toggled } => {
+                active.background = active.background.scale_alpha(0.5);
+                active.foreground = active.foreground.scale_alpha(0.5);
                 active
             }
         }
@@ -1086,21 +1102,21 @@ impl rule::Catalog for Theme {
         match class {
             Rule::Default => rule::Style {
                 color: self.current_container().divider.into(),
-                width: 1,
                 radius: 0.0.into(),
                 fill_mode: rule::FillMode::Full,
+                snap: true,
             },
             Rule::LightDivider => rule::Style {
                 color: self.current_container().divider.into(),
-                width: 1,
                 radius: 0.0.into(),
                 fill_mode: rule::FillMode::Padded(8),
+                snap: true,
             },
             Rule::HeavyDivider => rule::Style {
                 color: self.current_container().divider.into(),
-                width: 4,
                 radius: 2.0.into(),
                 fill_mode: rule::FillMode::Full,
+                snap: true,
             },
             Rule::Custom(f) => f(self),
         }
@@ -1126,7 +1142,10 @@ impl scrollable::Catalog for Theme {
 
     fn style(&self, class: &Self::Class<'_>, status: scrollable::Status) -> scrollable::Style {
         match status {
-            scrollable::Status::Active => {
+            scrollable::Status::Active {
+                is_horizontal_scrollbar_disabled,
+                is_vertical_scrollbar_disabled,
+            } => {
                 let cosmic = self.cosmic();
                 let neutral_5 = cosmic.palette.neutral_5.with_alpha(0.7);
                 let neutral_6 = cosmic.palette.neutral_6.with_alpha(0.7);
@@ -1139,7 +1158,7 @@ impl scrollable::Catalog for Theme {
                         },
                         background: None,
                         scroller: scrollable::Scroller {
-                            color: if cosmic.is_dark {
+                            background: if cosmic.is_dark {
                                 neutral_6.into()
                             } else {
                                 neutral_5.into()
@@ -1157,7 +1176,7 @@ impl scrollable::Catalog for Theme {
                         },
                         background: None,
                         scroller: scrollable::Scroller {
-                            color: if cosmic.is_dark {
+                            background: if cosmic.is_dark {
                                 neutral_6.into()
                             } else {
                                 neutral_5.into()
@@ -1169,6 +1188,13 @@ impl scrollable::Catalog for Theme {
                         },
                     },
                     gap: None,
+                    // TODO: what is auto scroll?
+                    auto_scroll: AutoScroll {
+                        background: Color::TRANSPARENT.into(),
+                        border: Border::default(),
+                        shadow: Shadow::default(),
+                        icon: Color::TRANSPARENT.into(),
+                    },
                 };
                 let small_widget_container = self.current_container().small_widget.with_alpha(0.7);
 
@@ -1200,7 +1226,7 @@ impl scrollable::Catalog for Theme {
                         },
                         background: None,
                         scroller: scrollable::Scroller {
-                            color: if cosmic.is_dark {
+                            background: if cosmic.is_dark {
                                 neutral_6.into()
                             } else {
                                 neutral_5.into()
@@ -1218,7 +1244,7 @@ impl scrollable::Catalog for Theme {
                         },
                         background: None,
                         scroller: scrollable::Scroller {
-                            color: if cosmic.is_dark {
+                            background: if cosmic.is_dark {
                                 neutral_6.into()
                             } else {
                                 neutral_5.into()
@@ -1230,6 +1256,13 @@ impl scrollable::Catalog for Theme {
                         },
                     },
                     gap: None,
+                    // TODO: what is auto scroll?
+                    auto_scroll: AutoScroll {
+                        background: Color::TRANSPARENT.into(),
+                        border: Border::default(),
+                        shadow: Shadow::default(),
+                        icon: Color::TRANSPARENT.into(),
+                    },
                 };
 
                 if matches!(class, Scrollable::Permanent) {
@@ -1400,7 +1433,7 @@ impl text_input::Catalog for Theme {
                     },
                 }
             }
-            text_input::Status::Focused => {
+            text_input::Status::Focused { is_hovered } => {
                 let bg = self.current_container().small_widget.with_alpha(0.25);
 
                 match class {
@@ -1477,7 +1510,8 @@ impl iced_widget::text_editor::Catalog for Theme {
         let selection = cosmic.accent.base.into();
         let value = cosmic.palette.neutral_9.into();
         let placeholder = cosmic.palette.neutral_9.with_alpha(0.7).into();
-        let icon = cosmic.background.on.into();
+        let icon: Color = cosmic.background.on.into();
+        // TODO do we need to add icon color back?
 
         match status {
             iced_widget::text_editor::Status::Active
@@ -1489,23 +1523,23 @@ impl iced_widget::text_editor::Catalog for Theme {
                     width: f32::from(cosmic.space_xxxs()),
                     color: iced::Color::from(cosmic.bg_divider()),
                 },
-                icon,
-                placeholder,
-                value,
-                selection,
-            },
-            iced_widget::text_editor::Status::Focused => iced_widget::text_editor::Style {
-                background: iced::Color::from(cosmic.bg_color()).into(),
-                border: Border {
-                    radius: cosmic.corner_radii.radius_0.into(),
-                    width: f32::from(cosmic.space_xxxs()),
-                    color: iced::Color::from(cosmic.accent.base),
-                },
-                icon,
                 placeholder,
                 value,
                 selection,
             },
+            iced_widget::text_editor::Status::Focused { is_hovered } => {
+                iced_widget::text_editor::Style {
+                    background: iced::Color::from(cosmic.bg_color()).into(),
+                    border: Border {
+                        radius: cosmic.corner_radii.radius_0.into(),
+                        width: f32::from(cosmic.space_xxxs()),
+                        color: iced::Color::from(cosmic.accent.base),
+                    },
+                    placeholder,
+                    value,
+                    selection,
+                }
+            }
         }
     }
 }
@@ -1522,6 +1556,21 @@ impl iced_widget::markdown::Catalog for Theme {
     }
 }
 
+impl iced_widget::table::Catalog for Theme {
+    type Class<'a> = iced_widget::table::StyleFn<'a, Self>;
+
+    fn default<'a>() -> Self::Class<'a> {
+        Box::new(|theme| iced_widget::table::Style {
+            separator_x: theme.current_container().divider.into(),
+            separator_y: theme.current_container().divider.into(),
+        })
+    }
+
+    fn style(&self, class: &Self::Class<'_>) -> iced_widget::table::Style {
+        class(self)
+    }
+}
+
 #[cfg(feature = "qr_code")]
 impl iced_widget::qr_code::Catalog for Theme {
     type Class<'a> = iced_widget::qr_code::StyleFn<'a, Self>;
@@ -1539,3 +1588,50 @@ impl iced_widget::qr_code::Catalog for Theme {
 }
 
 impl combo_box::Catalog for Theme {}
+
+impl Base for Theme {
+    fn default(preference: iced::theme::Mode) -> Self {
+        match preference {
+            iced::theme::Mode::Light => Theme::light(),
+            iced::theme::Mode::Dark | iced::theme::Mode::None => Theme::dark(),
+        }
+    }
+
+    fn mode(&self) -> iced::theme::Mode {
+        if self.theme_type.is_dark() {
+            iced::theme::Mode::Dark
+        } else {
+            iced::theme::Mode::Light
+        }
+    }
+
+    fn base(&self) -> iced::theme::Style {
+        iced::theme::Style {
+            background_color: self.cosmic().bg_color().into(),
+            text_color: self.cosmic().on_bg_color().into(),
+            icon_color: self.cosmic().on_bg_color().into(),
+        }
+    }
+
+    fn palette(&self) -> Option<iced::theme::Palette> {
+        Some(iced::theme::Palette {
+            primary: self.cosmic().accent.base.into(),
+            success: self.cosmic().success.base.into(),
+            warning: self.cosmic().warning.base.into(),
+            danger: self.cosmic().destructive.base.into(),
+            background: iced::Color::from(self.cosmic().bg_color()),
+            text: iced::Color::from(self.cosmic().on_bg_color()),
+        })
+    }
+
+    fn name(&self) -> &str {
+        match &self.theme_type {
+            crate::theme::ThemeType::Dark => "Cosmic Dark Theme",
+            crate::theme::ThemeType::Light => "Cosmic Light Theme",
+            crate::theme::ThemeType::HighContrastDark => "Cosmic High Contrast Dark Theme",
+            crate::theme::ThemeType::HighContrastLight => "Cosmic High Contrast Light Theme",
+            crate::theme::ThemeType::Custom(theme) => "Custom Cosmic Theme",
+            crate::theme::ThemeType::System { prefer_dark, theme } => &theme.name,
+        }
+    }
+}

src/theme/style/mod.rs

@@ -32,7 +32,7 @@ mod text_input;
 #[doc(inline)]
 pub use self::text_input::TextInput;
 
-#[cfg(all(feature = "wayland", feature = "winit"))]
+#[cfg(all(feature = "wayland", target_os = "linux", feature = "winit"))]
 pub mod tooltip;
-#[cfg(all(feature = "wayland", feature = "winit"))]
+#[cfg(all(feature = "wayland", target_os = "linux", feature = "winit"))]
 pub use tooltip::Tooltip;

src/widget/about.rs

@@ -1,8 +1,9 @@
 use crate::{
     Apply, Element, fl,
     iced::{Alignment, Length},
-    widget::{self, horizontal_space},
+    widget::{self, list},
 };
+use std::rc::Rc;
 
 #[derive(Debug, Default, Clone, derive_setters::Setters)]
 #[setters(into, strip_option)]
@@ -47,32 +48,40 @@ pub struct About {
 fn add_contributors(contributors: Vec<(&str, &str)>) -> Vec<(String, String)> {
     contributors
         .into_iter()
-        .map(|(name, email)| (name.to_string(), format!("mailto:{email}")))
+        .map(|(name, email)| (name.into(), format!("mailto:{email}")))
         .collect()
 }
 
-macro_rules! set_contributors {
-    ($field:ident, $doc:expr) => {
-        #[doc = $doc]
-        pub fn $field(mut self, contributors: impl Into<Vec<(&'a str, &'a str)>>) -> Self {
-            self.$field = add_contributors(contributors.into());
-            self
-        }
-    };
-}
-
 impl<'a> About {
-    set_contributors!(artists, "Artists who contributed to the application.");
-    set_contributors!(designers, "Designers who contributed to the application.");
-    set_contributors!(developers, "Developers who contributed to the application.");
-    set_contributors!(
-        documenters,
-        "Documenters who contributed to the application."
-    );
-    set_contributors!(
-        translators,
-        "Translators who contributed to the application."
-    );
+    /// Artists who contributed to the application.
+    pub fn artists(mut self, contributors: impl Into<Vec<(&'a str, &'a str)>>) -> Self {
+        self.artists = add_contributors(contributors.into());
+        self
+    }
+
+    /// Designers who contributed to the application.
+    pub fn designers(mut self, contributors: impl Into<Vec<(&'a str, &'a str)>>) -> Self {
+        self.designers = add_contributors(contributors.into());
+        self
+    }
+
+    /// Developers who contributed to the application.
+    pub fn developers(mut self, contributors: impl Into<Vec<(&'a str, &'a str)>>) -> Self {
+        self.developers = add_contributors(contributors.into());
+        self
+    }
+
+    /// Documenters who contributed to the application.
+    pub fn documenters(mut self, contributors: impl Into<Vec<(&'a str, &'a str)>>) -> Self {
+        self.documenters = add_contributors(contributors.into());
+        self
+    }
+
+    /// Translators who contributed to the application.
+    pub fn translators(mut self, contributors: impl Into<Vec<(&'a str, &'a str)>>) -> Self {
+        self.translators = add_contributors(contributors.into());
+        self
+    }
 
     /// Links associated with the application.
     pub fn links<K: Into<String>, V: Into<String>>(
@@ -96,19 +105,23 @@ pub fn about<'a, Message: Clone + 'static>(
         space_xxs, space_m, ..
     } = crate::theme::spacing();
 
-    let section_button = |name: &'a str, url: &'a str| -> Element<'a, Message> {
-        widget::row()
-            .push(widget::text(name))
-            .push(horizontal_space())
+    let svg_accent = Rc::new(|theme: &crate::Theme| widget::svg::Style {
+        color: Some(theme.cosmic().accent_text_color().into()),
+    });
+
+    let section_button = |name: &'a str, url: &'a str| -> list::ListButton<'a, Message> {
+        widget::row::with_capacity(2)
+            .push(widget::text::body(name).width(Length::Fill))
             .push_maybe(
-                (!url.is_empty()).then_some(crate::widget::icon::from_name("link-symbolic").icon()),
+                (!url.is_empty()).then_some(
+                    widget::icon::from_name("link-symbolic")
+                        .icon()
+                        .class(crate::theme::Svg::Custom(svg_accent.clone())),
+                ),
             )
             .align_y(Alignment::Center)
-            .apply(widget::button::custom)
-            .class(crate::theme::Button::Link)
+            .apply(list::button)
             .on_press(on_url_press(url))
-            .width(Length::Fill)
-            .into()
     };
 
     let section = |list: &'a Vec<(String, String)>, title: String| {
@@ -158,7 +171,7 @@ pub fn about<'a, Message: Clone + 'static>(
     let copyright = about.copyright.as_ref().map(widget::text::body);
     let comments = about.comments.as_ref().map(widget::text::body);
 
-    widget::column()
+    widget::column::with_capacity(10)
         .push_maybe(header)
         .push_maybe(links_section)
         .push_maybe(developers_section)

src/widget/aspect_ratio.rs

@@ -2,7 +2,7 @@
 
 use iced::Size;
 use iced::widget::Container;
-use iced_core::event::{self, Event};
+use iced_core::event::Event;
 use iced_core::layout;
 use iced_core::mouse;
 use iced_core::overlay;
@@ -172,7 +172,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -186,7 +186,7 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -195,18 +195,18 @@ where
         self.container.operate(tree, layout, renderer, operation);
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor_position: mouse::Cursor,
         renderer: &Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         viewport: &Rectangle,
-    ) -> event::Status {
-        self.container.on_event(
+    ) {
+        self.container.update(
             tree,
             event,
             layout,
@@ -254,11 +254,13 @@ where
     fn overlay<'b>(
         &'b mut self,
         tree: &'b mut Tree,
-        layout: Layout<'_>,
+        layout: Layout<'b>,
         renderer: &Renderer,
+        viewport: &Rectangle,
         translation: Vector,
     ) -> Option<overlay::Element<'b, Message, crate::Theme, Renderer>> {
-        self.container.overlay(tree, layout, renderer, translation)
+        self.container
+            .overlay(tree, layout, renderer, viewport, translation)
     }
 
     #[cfg(feature = "a11y")]

src/widget/autosize.rs

@@ -5,7 +5,7 @@ use iced_core::layout;
 use iced_core::mouse;
 use iced_core::overlay;
 use iced_core::renderer;
-use iced_core::widget::{Id, Tree};
+use iced_core::widget::{Id, Operation, Tree};
 use iced_core::{Clipboard, Element, Layout, Length, Rectangle, Shell, Vector, Widget};
 pub use iced_widget::container::{Catalog, Style};
 
@@ -107,7 +107,7 @@ where
     }
 
     fn diff(&mut self, tree: &mut Tree) {
-        tree.children[0].diff(&mut self.content);
+        tree.diff_children(std::slice::from_mut(&mut self.content));
     }
 
     fn size(&self) -> iced_core::Size<Length> {
@@ -115,7 +115,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -131,21 +131,22 @@ where
         }
         let node = self
             .content
-            .as_widget()
+            .as_widget_mut()
             .layout(&mut tree.children[0], renderer, &my_limits);
         let size = node.size();
         layout::Node::with_children(size, vec![node])
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn iced_core::widget::Operation<()>,
+        operation: &mut dyn Operation,
     ) {
-        operation.container(Some(&self.id), layout.bounds(), &mut |operation| {
-            self.content.as_widget().operate(
+        operation.container(Some(&self.id), layout.bounds());
+        operation.traverse(&mut |operation| {
+            self.content.as_widget_mut().operate(
                 &mut tree.children[0],
                 layout
                     .children()
@@ -158,18 +159,18 @@ where
         });
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor_position: mouse::Cursor,
         renderer: &Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         viewport: &Rectangle,
-    ) -> event::Status {
-        #[cfg(feature = "wayland")]
+    ) {
+        #[cfg(all(feature = "wayland", target_os = "linux"))]
         if matches!(
             event,
             Event::PlatformSpecific(event::PlatformSpecific::Wayland(
@@ -179,9 +180,9 @@ where
             let bounds = layout.bounds().size();
             clipboard.request_logical_window_size(bounds.width.max(1.), bounds.height.max(1.));
         }
-        self.content.as_widget_mut().on_event(
+        self.content.as_widget_mut().update(
             &mut tree.children[0],
-            event.clone(),
+            event,
             layout
                 .children()
                 .next()
@@ -192,7 +193,7 @@ where
             clipboard,
             shell,
             viewport,
-        )
+        );
     }
 
     fn mouse_interaction(
@@ -238,8 +239,9 @@ where
     fn overlay<'b>(
         &'b mut self,
         tree: &'b mut Tree,
-        layout: Layout<'_>,
+        layout: Layout<'b>,
         renderer: &Renderer,
+        viewport: &Rectangle,
         translation: Vector,
     ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
         self.content.as_widget_mut().overlay(
@@ -250,6 +252,7 @@ where
                 .unwrap()
                 .with_virtual_offset(layout.virtual_offset()),
             renderer,
+            viewport,
             translation,
         )
     }

src/widget/button/icon.rs

@@ -3,10 +3,7 @@
 
 use super::{Builder, ButtonClass};
 use crate::Element;
-use crate::widget::{
-    icon::{self, Handle},
-    tooltip,
-};
+use crate::widget::{icon::Handle, tooltip};
 use apply::Apply;
 use iced_core::{Alignment, Length, Padding, font::Weight, text::LineHeight, widget::Id};
 use std::borrow::Cow;
@@ -133,7 +130,7 @@ impl<Message> Button<'_, Message> {
 }
 
 impl<'a, Message: Clone + 'static> From<Button<'a, Message>> for Element<'a, Message> {
-    fn from(mut builder: Button<'a, Message>) -> Element<'a, Message> {
+    fn from(builder: Button<'a, Message>) -> Element<'a, Message> {
         let mut content = Vec::with_capacity(2);
 
         content.push(

src/widget/button/widget.rs

@@ -318,7 +318,7 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &crate::Renderer,
         limits: &layout::Limits,
@@ -331,21 +331,22 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
             self.padding,
             |renderer, limits| {
                 self.content
-                    .as_widget()
+                    .as_widget_mut()
                     .layout(&mut tree.children[0], renderer, limits)
             },
         )
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &crate::Renderer,
         operation: &mut dyn Operation<()>,
     ) {
-        operation.container(None, layout.bounds(), &mut |operation| {
-            self.content.as_widget().operate(
+        operation.container(None, layout.bounds());
+        operation.traverse(&mut |operation| {
+            self.content.as_widget_mut().operate(
                 &mut tree.children[0],
                 layout
                     .children()
@@ -357,20 +358,20 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
             );
         });
         let state = tree.state.downcast_mut::<State>();
-        operation.focusable(state, Some(&self.id));
+        operation.focusable(Some(&self.id), layout.bounds(), state);
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &crate::Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         viewport: &Rectangle,
-    ) -> event::Status {
+    ) {
         if let Variant::Image {
             on_remove: Some(on_remove),
             ..
@@ -383,7 +384,8 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
                     if let Some(position) = cursor.position() {
                         if removal_bounds(layout.bounds(), 4.0).contains(position) {
                             shell.publish(on_remove.clone());
-                            return event::Status::Captured;
+                            shell.capture_event();
+                            return;
                         }
                     }
                 }
@@ -391,10 +393,9 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
                 _ => (),
             }
         }
-
-        if self.content.as_widget_mut().on_event(
+        self.content.as_widget_mut().update(
             &mut tree.children[0],
-            event.clone(),
+            event,
             layout
                 .children()
                 .next()
@@ -405,9 +406,9 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
             clipboard,
             shell,
             viewport,
-        ) == event::Status::Captured
-        {
-            return event::Status::Captured;
+        );
+        if shell.is_event_captured() {
+            return;
         }
 
         update(
@@ -541,6 +542,7 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
                                 ..Default::default()
                             },
                             shadow: Shadow::default(),
+                            snap: true,
                         },
                         selection_background,
                     );
@@ -554,7 +556,7 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
                         y: bounds.y + (bounds.height - 18.0 - styling.border_width),
                     };
                     if bounds.intersects(viewport) {
-                        iced_core::svg::Renderer::draw_svg(renderer, svg_handle, bounds);
+                        iced_core::svg::Renderer::draw_svg(renderer, svg_handle, bounds, bounds);
                     }
                 }
 
@@ -570,6 +572,7 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
                                         radius: c_rad.radius_m.into(),
                                         ..Default::default()
                                     },
+                                    snap: true,
                                 },
                                 selection_background,
                             );
@@ -583,6 +586,12 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
                                     x: bounds.x + 4.0,
                                     y: bounds.y + 4.0,
                                 },
+                                Rectangle {
+                                    width: 16.0,
+                                    height: 16.0,
+                                    x: bounds.x + 4.0,
+                                    y: bounds.y + 4.0,
+                                },
                             );
                         }
                     }
@@ -609,8 +618,9 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
     fn overlay<'b>(
         &'b mut self,
         tree: &'b mut Tree,
-        layout: Layout<'_>,
+        layout: Layout<'b>,
         renderer: &crate::Renderer,
+        viewport: &Rectangle,
         mut translation: Vector,
     ) -> Option<overlay::Element<'b, Message, crate::Theme, crate::Renderer>> {
         let position = layout.bounds().position();
@@ -624,6 +634,7 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
                 .unwrap()
                 .with_virtual_offset(layout.virtual_offset()),
             renderer,
+            viewport,
             translation,
         )
     }
@@ -638,7 +649,7 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
     ) -> iced_accessibility::A11yTree {
         use iced_accessibility::{
             A11yNode, A11yTree,
-            accesskit::{Action, DefaultActionVerb, NodeBuilder, NodeId, Rect, Role},
+            accesskit::{Action, Node, NodeId, Rect, Role},
         };
         // TODO why is state None sometimes?
         if matches!(state.state, iced_core::widget::tree::State::None) {
@@ -658,12 +669,12 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
         let bounds = Rect::new(x as f64, y as f64, (x + width) as f64, (y + height) as f64);
         let is_hovered = state.state.downcast_ref::<State>().is_hovered;
 
-        let mut node = NodeBuilder::new(Role::Button);
+        let mut node = Node::new(Role::Button);
         node.add_action(Action::Focus);
-        node.add_action(Action::Default);
+        node.add_action(Action::Click);
         node.set_bounds(bounds);
         if let Some(name) = self.name.as_ref() {
-            node.set_name(name.clone());
+            node.set_label(name.clone());
         }
         match self.description.as_ref() {
             Some(iced_accessibility::Description::Id(id)) => {
@@ -682,10 +693,10 @@ impl<'a, Message: 'a + Clone> Widget<Message, crate::Theme, crate::Renderer>
         if self.on_press.is_none() {
             node.set_disabled();
         }
-        if is_hovered {
-            node.set_hovered();
-        }
-        node.set_default_action_verb(DefaultActionVerb::Click);
+        // TODO hover
+        // if is_hovered {
+        //     node.set_hovered();
+        // }
 
         if let Some(child_tree) = child_tree.map(|child_tree| {
             self.content.as_widget().a11y_nodes(
@@ -761,14 +772,14 @@ impl State {
 #[allow(clippy::needless_pass_by_value, clippy::too_many_arguments)]
 pub fn update<'a, Message: Clone>(
     _id: Id,
-    event: Event,
+    event: &Event,
     layout: Layout<'_>,
     cursor: mouse::Cursor,
     shell: &mut Shell<'_, Message>,
     on_press: Option<&dyn Fn(Vector, Rectangle) -> Message>,
     on_press_down: Option<&dyn Fn(Vector, Rectangle) -> Message>,
     state: impl FnOnce() -> &'a mut State,
-) -> event::Status {
+) {
     match event {
         Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
         | Event::Touch(touch::Event::FingerPressed { .. }) => {
@@ -787,7 +798,8 @@ pub fn update<'a, Message: Clone>(
                         shell.publish(msg);
                     }
 
-                    return event::Status::Captured;
+                    shell.capture_event();
+                    return;
                 }
             }
         }
@@ -806,7 +818,8 @@ pub fn update<'a, Message: Clone>(
                         shell.publish(msg);
                     }
 
-                    return event::Status::Captured;
+                    shell.capture_event();
+                    return;
                 }
             } else if on_press_down.is_some() {
                 let state = state();
@@ -816,7 +829,7 @@ pub fn update<'a, Message: Clone>(
         #[cfg(feature = "a11y")]
         Event::A11y(event_id, iced_accessibility::accesskit::ActionRequest { action, .. }) => {
             let state = state();
-            if let Some(on_press) = matches!(action, iced_accessibility::accesskit::Action::Default)
+            if let Some(on_press) = matches!(action, iced_accessibility::accesskit::Action::Click)
                 .then_some(on_press)
                 .flatten()
             {
@@ -825,17 +838,19 @@ pub fn update<'a, Message: Clone>(
 
                 shell.publish(msg);
             }
-            return event::Status::Captured;
+            shell.capture_event();
+            return;
         }
         Event::Keyboard(keyboard::Event::KeyPressed { key, .. }) => {
             if let Some(on_press) = on_press {
                 let state = state();
-                if state.is_focused && key == keyboard::Key::Named(keyboard::key::Named::Enter) {
+                if state.is_focused && *key == keyboard::Key::Named(keyboard::key::Named::Enter) {
                     state.is_pressed = true;
                     let msg = (on_press)(layout.virtual_offset(), layout.bounds());
 
                     shell.publish(msg);
-                    return event::Status::Captured;
+                    shell.capture_event();
+                    return;
                 }
             }
         }
@@ -846,8 +861,6 @@ pub fn update<'a, Message: Clone>(
         }
         _ => {}
     }
-
-    event::Status::Ignored
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -879,6 +892,7 @@ pub fn draw<Renderer: iced_core::Renderer, Theme>(
                     radius: styling.border_radius,
                 },
                 shadow: Shadow::default(),
+                snap: true,
             },
             Color::TRANSPARENT,
         );
@@ -900,6 +914,7 @@ pub fn draw<Renderer: iced_core::Renderer, Theme>(
                         ..Default::default()
                     },
                     shadow: Shadow::default(),
+                    snap: true,
                 },
                 Background::Color([0.0, 0.0, 0.0, 0.5].into()),
             );
@@ -915,6 +930,7 @@ pub fn draw<Renderer: iced_core::Renderer, Theme>(
                         ..Default::default()
                     },
                     shadow: Shadow::default(),
+                    snap: true,
                 },
                 background,
             );
@@ -930,6 +946,7 @@ pub fn draw<Renderer: iced_core::Renderer, Theme>(
                         ..Default::default()
                     },
                     shadow: Shadow::default(),
+                    snap: true,
                 },
                 overlay,
             );
@@ -953,6 +970,7 @@ pub fn draw<Renderer: iced_core::Renderer, Theme>(
                         radius: styling.border_radius,
                     },
                     shadow: Shadow::default(),
+                    snap: true,
                 },
                 Color::TRANSPARENT,
             );

src/widget/calendar.rs

@@ -4,10 +4,10 @@
 //! A widget that displays an interactive calendar.
 
 use crate::fl;
-use crate::iced_core::{Alignment, Length};
 use crate::widget::{button, column, grid, icon, row, text};
 use apply::Apply;
 use iced::alignment::Vertical;
+use iced_core::{Alignment, Length};
 use jiff::{
     ToSpan,
     civil::{Date, Weekday},
@@ -212,8 +212,10 @@ where
 
         let content_list = column::with_children([
             row::with_children([
-                column().push(date).push(day).into(),
-                crate::widget::Space::with_width(Length::Fill).into(),
+                column([date.into(), day.into()]).into(),
+                crate::widget::space::horizontal()
+                    .width(Length::Fill)
+                    .into(),
                 month_controls.into(),
             ])
             .align_y(Vertical::Center)

src/widget/cards.rs

@@ -0,0 +1,586 @@
+//! An expandable stack of cards
+use std::time::Duration;
+
+use crate::{
+    anim,
+    widget::{
+        button,
+        card::style::Style,
+        column,
+        icon::{self, Handle},
+        row, text,
+    },
+};
+use float_cmp::approx_eq;
+use iced::widget;
+use iced_core::{
+    Border, Element, Event, Length, Shadow, Size, Vector, Widget, border::Radius, id::Id,
+    layout::Node, renderer::Quad, widget::Tree,
+};
+use iced_core::{widget::tree, window};
+
+const ICON_SIZE: u16 = 16;
+const TOP_SPACING: u16 = 4;
+const VERTICAL_SPACING: f32 = 8.0;
+const PADDING: u16 = 16;
+const BG_CARD_VISIBLE_HEIGHT: f32 = 4.0;
+const BG_CARD_BORDER_RADIUS: f32 = 8.0;
+const BG_CARD_MARGIN_STEP: f32 = 8.0;
+
+/// get an expandable stack of cards
+#[allow(clippy::too_many_arguments)]
+pub fn cards<'a, Message, F, G>(
+    id: widget::Id,
+    card_inner_elements: Vec<Element<'a, Message, crate::Theme, crate::Renderer>>,
+    on_clear_all: Message,
+    on_show_more: Option<F>,
+    on_activate: Option<G>,
+    show_more_label: &'a str,
+    show_less_label: &'a str,
+    clear_all_label: &'a str,
+    show_less_icon: Option<Handle>,
+    expanded: bool,
+) -> Cards<'a, Message, crate::Renderer>
+where
+    Message: 'static + Clone,
+    F: 'a + Fn(bool) -> Message,
+    G: 'a + Fn(usize) -> Message,
+{
+    Cards::new(
+        id,
+        card_inner_elements,
+        on_clear_all,
+        on_show_more,
+        on_activate,
+        show_more_label,
+        show_less_label,
+        clear_all_label,
+        show_less_icon,
+        expanded,
+    )
+}
+
+impl<'a, Message, Renderer> Cards<'a, Message, Renderer>
+where
+    Renderer: iced_core::text::Renderer,
+{
+    fn fully_expanded(&self, t: f32) -> bool {
+        self.expanded && self.elements.len() > 1 && self.can_show_more && approx_eq!(f32, t, 1.0)
+    }
+
+    fn fully_unexpanded(&self, t: f32) -> bool {
+        self.elements.len() == 1
+            || (!self.expanded && (!self.can_show_more || approx_eq!(f32, t, 0.0)))
+    }
+}
+
+/// An expandable stack of cards.
+#[allow(missing_debug_implementations)]
+pub struct Cards<'a, Message, Renderer = crate::Renderer>
+where
+    Renderer: iced_core::text::Renderer,
+{
+    id: Id,
+    show_less_button: Element<'a, Message, crate::Theme, Renderer>,
+    clear_all_button: Element<'a, Message, crate::Theme, Renderer>,
+    elements: Vec<Element<'a, Message, crate::Theme, Renderer>>,
+    expanded: bool,
+    can_show_more: bool,
+    width: Length,
+    anim_multiplier: f32,
+    duration: Duration,
+}
+
+impl<'a, Message> Cards<'a, Message, crate::Renderer>
+where
+    Message: Clone + 'static,
+{
+    /// Get an expandable stack of cards
+    #[allow(clippy::too_many_arguments)]
+    pub fn new<F, G>(
+        id: widget::Id,
+        card_inner_elements: Vec<Element<'a, Message, crate::Theme, crate::Renderer>>,
+        on_clear_all: Message,
+        on_show_more: Option<F>,
+        on_activate: Option<G>,
+        show_more_label: &'a str,
+        show_less_label: &'a str,
+        clear_all_label: &'a str,
+        show_less_icon: Option<Handle>,
+        expanded: bool,
+    ) -> Self
+    where
+        F: 'a + Fn(bool) -> Message,
+        G: 'a + Fn(usize) -> Message,
+    {
+        let can_show_more = card_inner_elements.len() > 1 && on_show_more.is_some();
+
+        Self {
+            can_show_more,
+            id: Id::unique(),
+            show_less_button: {
+                let mut show_less_children = Vec::with_capacity(3);
+                if let Some(source) = show_less_icon {
+                    show_less_children.push(icon::icon(source).size(ICON_SIZE).into());
+                }
+                show_less_children.push(text::body(show_less_label).width(Length::Shrink).into());
+                show_less_children.push(
+                    icon::from_name("pan-up-symbolic")
+                        .size(ICON_SIZE)
+                        .icon()
+                        .into(),
+                );
+
+                let button_content = row::with_children(show_less_children)
+                    .align_y(iced_core::Alignment::Center)
+                    .spacing(TOP_SPACING)
+                    .width(Length::Shrink);
+
+                Element::from(
+                    button::custom(button_content)
+                        .class(crate::theme::Button::Text)
+                        .width(Length::Shrink)
+                        .on_press_maybe(on_show_more.as_ref().map(|f| f(false)))
+                        .padding([PADDING / 2, PADDING]),
+                )
+            },
+            clear_all_button: Element::from(
+                button::custom(text(clear_all_label))
+                    .class(crate::theme::Button::Text)
+                    .width(Length::Shrink)
+                    .on_press(on_clear_all)
+                    .padding([PADDING / 2, PADDING]),
+            ),
+            elements: card_inner_elements
+                .into_iter()
+                .enumerate()
+                .map(|(i, w)| {
+                    let custom_content = if i == 0 && !expanded && can_show_more {
+                        column::with_capacity(2)
+                            .push(w)
+                            .push(text::caption(show_more_label))
+                            .spacing(VERTICAL_SPACING)
+                            .align_x(iced_core::Alignment::Center)
+                            .into()
+                    } else {
+                        w
+                    };
+
+                    let b = crate::iced::widget::button(custom_content)
+                        .class(crate::theme::iced::Button::Card)
+                        .padding(PADDING);
+                    if i == 0 && !expanded && can_show_more {
+                        b.on_press_maybe(on_show_more.as_ref().map(|f| f(true)))
+                    } else {
+                        b.on_press_maybe(on_activate.as_ref().map(|f| f(i)))
+                    }
+                    .into()
+                })
+                // we will set the width of the container to shrink, then when laying out the top bar
+                // we will set the fill limit to the max of the shrink top bar width and the max shrink width of the
+                // cards
+                .collect(),
+            width: Length::Shrink,
+            anim_multiplier: 1.0,
+            expanded,
+            duration: Duration::from_millis(200),
+        }
+    }
+
+    ///  Set the width of the cards stack
+    #[must_use]
+    pub fn width(mut self, width: Length) -> Self {
+        self.width = width;
+        self
+    }
+
+    #[must_use]
+    /// The default animation time is 100ms, to speed up the toggle
+    /// animation use a value less than 1.0, and to slow down the
+    /// animation use a value greater than 1.0.
+    pub fn anim_multiplier(mut self, multiplier: f32) -> Self {
+        self.anim_multiplier = multiplier;
+        self
+    }
+
+    pub fn duration(mut self, dur: Duration) -> Self {
+        self.duration = dur;
+        self
+    }
+
+    pub fn id(mut self, id: Id) -> Self {
+        self.id = id;
+        self
+    }
+}
+
+impl<'a, Message, Renderer> Widget<Message, crate::Theme, Renderer> for Cards<'a, Message, Renderer>
+where
+    Message: 'a + Clone,
+    Renderer: 'a + iced_core::Renderer + iced_core::text::Renderer,
+{
+    fn children(&self) -> Vec<Tree> {
+        [&self.show_less_button, &self.clear_all_button]
+            .iter()
+            .map(|w| Tree::new(w.as_widget()))
+            .chain(self.elements.iter().map(|w| Tree::new(w.as_widget())))
+            .collect()
+    }
+
+    fn diff(&mut self, tree: &mut Tree) {
+        let mut children: Vec<_> = vec![
+            self.show_less_button.as_widget_mut(),
+            self.clear_all_button.as_widget_mut(),
+        ]
+        .into_iter()
+        .chain(
+            self.elements
+                .iter_mut()
+                .map(iced_core::Element::as_widget_mut),
+        )
+        .collect();
+
+        tree.diff_children(children.as_mut_slice());
+    }
+
+    #[allow(clippy::too_many_lines)]
+    fn layout(
+        &mut self,
+        tree: &mut Tree,
+        renderer: &Renderer,
+        limits: &iced_core::layout::Limits,
+    ) -> iced_core::layout::Node {
+        let my_state = tree.state.downcast_ref::<State>();
+
+        let mut children = Vec::with_capacity(1 + self.elements.len());
+        let mut size = Size::new(0.0, 0.0);
+        let tree_children = &mut tree.children;
+        let count = self.elements.len();
+        if self.elements.is_empty() {
+            return Node::with_children(Size::new(1., 1.), children);
+        }
+        let s = anim::smootherstep(my_state.anim.t(self.duration, self.expanded));
+        let fully_expanded: bool = self.fully_expanded(s);
+        let fully_unexpanded: bool = self.fully_unexpanded(s);
+
+        let show_less = &mut self.show_less_button;
+        let clear_all = &mut self.clear_all_button;
+
+        let show_less_node = if self.can_show_more {
+            show_less
+                .as_widget_mut()
+                .layout(&mut tree_children[0], renderer, limits)
+        } else {
+            Node::new(Size::default())
+        };
+        let clear_all_node =
+            clear_all
+                .as_widget_mut()
+                .layout(&mut tree_children[1], renderer, limits);
+        size.width += show_less_node.size().width + clear_all_node.size().width;
+
+        let custom_limits = limits.min_width(size.width);
+        for (c, t) in self.elements.iter_mut().zip(tree_children[2..].iter_mut()) {
+            let card_node = c.as_widget_mut().layout(t, renderer, &custom_limits);
+            size.width = size.width.max(card_node.size().width);
+        }
+
+        if fully_expanded {
+            let show_less = &mut self.show_less_button;
+            let clear_all = &mut self.clear_all_button;
+
+            let show_less_node = if self.can_show_more {
+                show_less
+                    .as_widget_mut()
+                    .layout(&mut tree_children[0], renderer, limits)
+            } else {
+                Node::new(Size::default())
+            };
+            let clear_all_node = if self.can_show_more {
+                let mut n =
+                    clear_all
+                        .as_widget_mut()
+                        .layout(&mut tree_children[1], renderer, limits);
+                let clear_all_node_size = n.size();
+                n = clear_all_node
+                    .translate(Vector::new(size.width - clear_all_node_size.width, 0.0));
+                size.height += show_less_node.size().height.max(n.size().height) + VERTICAL_SPACING;
+                n
+            } else {
+                Node::new(Size::default())
+            };
+
+            children.push(show_less_node);
+            children.push(clear_all_node);
+        }
+
+        let custom_limits = limits
+            .min_width(size.width)
+            .max_width(size.width)
+            .width(Length::Fixed(size.width));
+
+        for (i, (c, t)) in self
+            .elements
+            .iter_mut()
+            .zip(tree_children[2..].iter_mut())
+            .enumerate()
+        {
+            let progress = s * size.height;
+            let card_node = c
+                .as_widget_mut()
+                .layout(t, renderer, &custom_limits)
+                .translate(Vector::new(0.0, progress));
+
+            size.height = size.height.max(progress + card_node.size().height);
+
+            children.push(card_node);
+
+            if fully_unexpanded {
+                let width = children.last().unwrap().bounds().width;
+
+                // push the background card nodes
+                for i in 1..self.elements.len().min(3) {
+                    // height must be 16px for 8px padding
+                    // but we only want 4px visible
+
+                    let margin = f32::from(u8::try_from(i).unwrap()) * BG_CARD_MARGIN_STEP;
+                    let node =
+                        Node::new(Size::new(width - 2.0 * margin, BG_CARD_BORDER_RADIUS * 2.0))
+                            .translate(Vector::new(
+                                margin,
+                                size.height - BG_CARD_BORDER_RADIUS * 2.0 + BG_CARD_VISIBLE_HEIGHT,
+                            ));
+                    size.height += BG_CARD_VISIBLE_HEIGHT;
+                    children.push(node);
+                }
+                break;
+            }
+
+            if i + 1 < count {
+                size.height += VERTICAL_SPACING;
+            }
+        }
+
+        Node::with_children(size, children)
+    }
+
+    fn draw(
+        &self,
+        state: &iced_core::widget::Tree,
+        renderer: &mut Renderer,
+        theme: &crate::Theme,
+        style: &iced_core::renderer::Style,
+        layout: iced_core::Layout<'_>,
+        cursor: iced_core::mouse::Cursor,
+        viewport: &iced_core::Rectangle,
+    ) {
+        let my_state = state.state.downcast_ref::<State>();
+
+        // there are 4 cases for drawing
+        // 1. empty entries list
+        //      Nothing to draw
+        // 2. un-expanded
+        //      go through the layout, draw the card, the inner card, and the bg cards
+        // 3. expanding / unexpanding
+        //      go through the layout. draw each card and its inner card
+        // 4. expanded =>
+        //      go through the layout. draw the top bar, and do all of 3
+        // cards may be hovered
+        // any buttons may have a hover state as well
+        if self.elements.is_empty() {
+            return;
+        }
+
+        let t = my_state.anim.t(self.duration, self.expanded);
+        let fully_unexpanded = self.fully_unexpanded(t);
+        let fully_expanded = self.fully_expanded(t);
+
+        let mut layout = layout.children();
+        let mut tree_children = state.children.iter();
+
+        if fully_expanded {
+            let show_less = &self.show_less_button;
+            let clear_all = &self.clear_all_button;
+
+            let show_less_layout = layout.next().unwrap();
+            let clear_all_layout = layout.next().unwrap();
+
+            show_less.as_widget().draw(
+                tree_children.next().unwrap(),
+                renderer,
+                theme,
+                style,
+                show_less_layout,
+                cursor,
+                viewport,
+            );
+
+            clear_all.as_widget().draw(
+                tree_children.next().unwrap(),
+                renderer,
+                theme,
+                style,
+                clear_all_layout,
+                cursor,
+                viewport,
+            );
+        } else {
+            _ = tree_children.next();
+            _ = tree_children.next();
+        }
+
+        // Draw first to appear behind
+        if fully_unexpanded {
+            let card_layout = layout.next().unwrap();
+            let appearance = Style::default();
+            let bg_layout = layout.collect::<Vec<_>>();
+            for (i, layout) in (0..2).zip(bg_layout.into_iter()).rev() {
+                renderer.fill_quad(
+                    Quad {
+                        bounds: layout.bounds(),
+                        border: Border {
+                            radius: Radius::from([
+                                0.0,
+                                0.0,
+                                BG_CARD_BORDER_RADIUS,
+                                BG_CARD_BORDER_RADIUS,
+                            ]),
+                            ..Default::default()
+                        },
+                        shadow: Shadow::default(),
+                        snap: true,
+                    },
+                    if i == 0 {
+                        appearance.card_1
+                    } else {
+                        appearance.card_2
+                    },
+                );
+            }
+            self.elements[0].as_widget().draw(
+                tree_children.next().unwrap(),
+                renderer,
+                theme,
+                style,
+                card_layout,
+                cursor,
+                viewport,
+            );
+        } else {
+            let layout = layout.collect::<Vec<_>>();
+            // draw in reverse order so later cards appear behind earlier cards
+            for ((inner, layout), c_state) in self
+                .elements
+                .iter()
+                .rev()
+                .zip(layout.into_iter().rev())
+                .zip(tree_children.rev())
+            {
+                inner
+                    .as_widget()
+                    .draw(c_state, renderer, theme, style, layout, cursor, viewport);
+            }
+        }
+    }
+
+    fn update(
+        &mut self,
+        state: &mut Tree,
+        event: &iced_core::Event,
+        layout: iced_core::Layout<'_>,
+        cursor: iced_core::mouse::Cursor,
+        renderer: &Renderer,
+        clipboard: &mut dyn iced_core::Clipboard,
+        shell: &mut iced_core::Shell<'_, Message>,
+        viewport: &iced_core::Rectangle,
+    ) {
+        if self.elements.is_empty() {
+            return;
+        }
+
+        if let Event::Window(window::Event::RedrawRequested(_)) = event {
+            let state = state.state.downcast_mut::<State>();
+
+            state.anim.anim_done(self.duration);
+            if state.anim.last_change.is_some() {
+                shell.request_redraw();
+                shell.invalidate_layout();
+            }
+        }
+
+        let my_state = state.state.downcast_ref::<State>();
+
+        let mut layout = layout.children();
+        let mut tree_children = state.children.iter_mut();
+        let t = my_state.anim.t(self.duration, self.expanded);
+        let fully_expanded = self.fully_expanded(t);
+        let fully_unexpanded = self.fully_unexpanded(t);
+        let show_less_state = tree_children.next();
+        let clear_all_state = tree_children.next();
+
+        if fully_expanded {
+            let c_layout = layout.next().unwrap();
+            let state = show_less_state.unwrap();
+            self.show_less_button.as_widget_mut().update(
+                state, event, c_layout, cursor, renderer, clipboard, shell, viewport,
+            );
+
+            if shell.is_event_captured() {
+                return;
+            }
+
+            let c_layout = layout.next().unwrap();
+            let state = clear_all_state.unwrap();
+            self.clear_all_button.as_widget_mut().update(
+                state, &event, c_layout, cursor, renderer, clipboard, shell, viewport,
+            );
+        }
+
+        if shell.is_event_captured() {
+            return;
+        }
+
+        for ((inner, layout), c_state) in self.elements.iter_mut().zip(layout).zip(tree_children) {
+            inner.as_widget_mut().update(
+                c_state, &event, layout, cursor, renderer, clipboard, shell, viewport,
+            );
+            if shell.is_event_captured() || fully_unexpanded {
+                break;
+            }
+        }
+    }
+
+    fn size(&self) -> Size<Length> {
+        Size::new(self.width, Length::Shrink)
+    }
+
+    fn tag(&self) -> tree::Tag {
+        tree::Tag::of::<State>()
+    }
+
+    fn state(&self) -> tree::State {
+        tree::State::new(State::default())
+    }
+
+    fn id(&self) -> Option<Id> {
+        Some(self.id.clone())
+    }
+
+    fn set_id(&mut self, id: Id) {
+        self.id = id;
+    }
+}
+
+impl<'a, Message> From<Cards<'a, Message>> for Element<'a, Message, crate::Theme, crate::Renderer>
+where
+    Message: Clone + 'a,
+{
+    fn from(cards: Cards<'a, Message>) -> Self {
+        Self::new(cards)
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct State {
+    anim: anim::State,
+}

src/widget/color_picker/mod.rs

@@ -4,7 +4,6 @@
 //! Widgets for selecting colors with a color picker.
 
 use std::borrow::Cow;
-use std::iter;
 use std::rc::Rc;
 use std::sync::LazyLock;
 use std::sync::atomic::{AtomicBool, Ordering};
@@ -26,7 +25,10 @@ use iced_core::{
 };
 
 use iced_widget::slider::HandleShape;
-use iced_widget::{Row, canvas, column, horizontal_space, row, scrollable, vertical_space};
+use iced_widget::{
+    Row, canvas, column, row, scrollable,
+    space::{horizontal, vertical},
+};
 use palette::{FromColor, RgbHue};
 
 use super::divider::horizontal;
@@ -90,8 +92,6 @@ pub struct ColorPickerModel {
     #[setters(skip)]
     active_color: palette::Hsv,
     #[setters(skip)]
-    save_next: Option<Color>,
-    #[setters(skip)]
     input_color: String,
     #[setters(skip)]
     applied_color: Option<Color>,
@@ -125,7 +125,6 @@ impl ColorPickerModel {
                 .insert(move |b| b.text(rgb.clone()))
                 .build(),
             active_color: hsv,
-            save_next: None,
             input_color: color_to_string(hsv, true),
             applied_color: initial,
             fallback_color,
@@ -156,22 +155,26 @@ impl ColorPickerModel {
         )
     }
 
+    fn update_recent_colors(&mut self, new_color: Color) {
+        if let Some(pos) = self.recent_colors.iter().position(|c| *c == new_color) {
+            self.recent_colors.remove(pos);
+        }
+        self.recent_colors.insert(0, new_color);
+        self.recent_colors.truncate(MAX_RECENT);
+    }
+
     pub fn update<Message>(&mut self, update: ColorPickerUpdate) -> Task<Message> {
         match update {
             ColorPickerUpdate::ActiveColor(c) => {
                 self.must_clear_cache.store(true, Ordering::SeqCst);
                 self.input_color = color_to_string(c, self.is_hex());
-                if let Some(to_save) = self.save_next.take() {
-                    self.recent_colors.insert(0, to_save);
-                    self.recent_colors.truncate(MAX_RECENT);
-                }
                 self.active_color = c;
                 self.copied_at = None;
             }
-            ColorPickerUpdate::AppliedColor => {
+            ColorPickerUpdate::AppliedColor | ColorPickerUpdate::ActionFinished => {
                 let srgb = palette::Srgb::from_color(self.active_color);
                 if let Some(applied_color) = self.applied_color.take() {
-                    self.recent_colors.push(applied_color);
+                    self.update_recent_colors(applied_color);
                 }
                 self.applied_color = Some(Color::from(srgb));
                 self.active = false;
@@ -212,21 +215,12 @@ impl ColorPickerModel {
                         palette::Hsv::from_color(palette::Srgb::new(c.red, c.green, c.blue));
                 }
             }
-            ColorPickerUpdate::ActionFinished => {
-                let srgb = palette::Srgb::from_color(self.active_color);
-                if let Some(applied_color) = self.applied_color.take() {
-                    self.recent_colors.push(applied_color);
-                }
-                self.applied_color = Some(Color::from(srgb));
-                self.active = false;
-                self.save_next = Some(Color::from(srgb));
-            }
             ColorPickerUpdate::ToggleColorPicker => {
                 self.must_clear_cache.store(true, Ordering::SeqCst);
                 self.active = !self.active;
                 self.copied_at = None;
             }
-        };
+        }
         Task::none()
     }
 
@@ -334,7 +328,7 @@ where
                 .width(self.width),
             // canvas with gradient for the current color
             // still needs the canvas and the handle to be drawn on it
-            container(vertical_space().height(self.height))
+            container(vertical().height(self.height))
                 .width(self.width)
                 .height(self.height),
             slider(
@@ -392,7 +386,8 @@ where
             text_input("", self.input_color)
                 .on_input(move |s| on_update(ColorPickerUpdate::Input(s)))
                 .on_paste(move |s| on_update(ColorPickerUpdate::Input(s)))
-                .on_submit(move |_| on_update(ColorPickerUpdate::AppliedColor))
+                .on_submit(move |_| on_update(ColorPickerUpdate::ActionFinished))
+                // .on_unfocus(on_update(ColorPickerUpdate::ActionFinished)) Somehow this is called even when the field wasn't previously focused
                 .leading_icon(
                     color_button(
                         None,
@@ -548,13 +543,13 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &crate::Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
         self.inner
-            .as_widget()
+            .as_widget_mut()
             .layout(&mut tree.children[0], renderer, limits)
     }
 
@@ -657,6 +652,7 @@ where
                             radius: (1.0 + handle_radius).into(),
                         },
                         shadow: Shadow::default(),
+                        snap: true,
                     },
                     Color::TRANSPARENT,
                 );
@@ -674,6 +670,7 @@ where
                             radius: handle_radius.into(),
                         },
                         shadow: Shadow::default(),
+                        snap: true,
                     },
                     Color::TRANSPARENT,
                 );
@@ -684,26 +681,31 @@ where
     fn overlay<'b>(
         &'b mut self,
         state: &'b mut Tree,
-        layout: Layout<'_>,
+        layout: Layout<'b>,
         renderer: &crate::Renderer,
+        viewport: &Rectangle,
         translation: Vector,
     ) -> Option<iced_core::overlay::Element<'b, Message, crate::Theme, crate::Renderer>> {
-        self.inner
-            .as_widget_mut()
-            .overlay(&mut state.children[0], layout, renderer, translation)
+        self.inner.as_widget_mut().overlay(
+            &mut state.children[0],
+            layout,
+            renderer,
+            viewport,
+            translation,
+        )
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &crate::Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         viewport: &Rectangle,
-    ) -> event::Status {
+    ) {
         // if the pointer is performing a drag, intercept pointer motion and button events
         // else check if event is handled by child elements
         // if the event is not handled by a child element, check if it is over the canvas when pressing a button
@@ -732,24 +734,26 @@ where
                     shell.publish((self.on_update)(ColorPickerUpdate::ActionFinished));
                     state.dragging = false;
                 }
-                _ => return event::Status::Ignored,
+                _ => return,
             };
-            return event::Status::Captured;
+            shell.capture_event();
+            return;
         }
 
         let column_tree = &mut tree.children[0];
-        if self.inner.as_widget_mut().on_event(
+        self.inner.as_widget_mut().update(
             column_tree,
-            event.clone(),
+            &event,
             column_layout,
             cursor,
             renderer,
             clipboard,
             shell,
             viewport,
-        ) == event::Status::Captured
-        {
-            return event::Status::Captured;
+        );
+        if shell.is_event_captured() {
+            shell.capture_event();
+            return;
         }
 
         match event {
@@ -764,12 +768,10 @@ where
                     state.dragging = true;
                     let hsv: palette::Hsv = palette::Hsv::new(self.active_color.hue, s, v);
                     shell.publish((self.on_update)(ColorPickerUpdate::ActiveColor(hsv)));
-                    event::Status::Captured
-                } else {
-                    event::Status::Ignored
+                    shell.capture_event();
                 }
             }
-            _ => event::Status::Ignored,
+            _ => {}
         }
     }
 
@@ -812,12 +814,12 @@ pub fn color_button<'a, Message: Clone + 'static>(
     let spacing = THEME.lock().unwrap().cosmic().spacing;
 
     button::custom(if color.is_some() {
-        Element::from(vertical_space().height(Length::Fixed(f32::from(spacing.space_s))))
+        Element::from(vertical().height(Length::Fixed(f32::from(spacing.space_s))))
     } else {
         Element::from(column![
-            vertical_space().height(Length::FillPortion(6)),
+            vertical().height(Length::FillPortion(6)),
             row![
-                horizontal_space().width(Length::FillPortion(6)),
+                horizontal().width(Length::FillPortion(6)),
                 Icon::from(
                     icon::from_name("list-add-symbolic")
                         .prefer_svg(true)
@@ -827,11 +829,11 @@ pub fn color_button<'a, Message: Clone + 'static>(
                 .width(icon_portion)
                 .height(Length::Fill)
                 .content_fit(iced_core::ContentFit::Contain),
-                horizontal_space().width(Length::FillPortion(6)),
+                horizontal().width(Length::FillPortion(6)),
             ]
             .height(icon_portion)
             .width(Length::Fill),
-            vertical_space().height(Length::FillPortion(6)),
+            vertical().height(Length::FillPortion(6)),
         ])
     })
     .width(Length::Fixed(f32::from(spacing.space_s)))

src/widget/context_drawer/overlay.rs

@@ -7,8 +7,8 @@ use iced::advanced::layout::{self, Layout};
 use iced::advanced::widget::{self, Operation};
 use iced::advanced::{Clipboard, Shell};
 use iced::advanced::{overlay, renderer};
-use iced::{Event, Point, Rectangle, Size, event, mouse};
-use iced_core::Renderer;
+use iced::{Event, Point, Size, mouse};
+use iced_core::{Renderer, touch};
 
 pub(super) struct Overlay<'a, 'b, Message> {
     pub(crate) position: Point,
@@ -29,7 +29,7 @@ where
 
         let node = self
             .content
-            .as_widget()
+            .as_widget_mut()
             .layout(self.tree, renderer, &limits);
         let node_size = node.size();
 
@@ -47,16 +47,16 @@ where
         })
     }
 
-    fn on_event(
+    fn update(
         &mut self,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &crate::Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
-    ) -> event::Status {
-        self.content.as_widget_mut().on_event(
+    ) {
+        self.content.as_widget_mut().update(
             self.tree,
             event,
             layout,
@@ -65,7 +65,20 @@ where
             clipboard,
             shell,
             &layout.bounds(),
-        )
+        );
+        match event {
+            Event::Mouse(e) if !matches!(e, mouse::Event::CursorLeft) => {
+                if cursor.is_over(layout.bounds()) {
+                    shell.capture_event();
+                }
+            }
+            Event::Touch(e) if !matches!(e, touch::Event::FingerLost { .. }) => {
+                if cursor.is_over(layout.bounds()) {
+                    shell.capture_event();
+                }
+            }
+            _ => {}
+        }
     }
 
     fn draw(
@@ -86,7 +99,7 @@ where
                 cursor,
                 &layout.bounds(),
             );
-        })
+        });
     }
 
     fn operate(
@@ -104,21 +117,35 @@ where
         &self,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
-        viewport: &Rectangle,
         renderer: &crate::Renderer,
     ) -> mouse::Interaction {
-        self.content
+        // TODO how to handle viewport here?
+        let viewport = &layout.bounds();
+        let interaction = self
+            .content
             .as_widget()
-            .mouse_interaction(self.tree, layout, cursor, viewport, renderer)
+            .mouse_interaction(self.tree, layout, cursor, viewport, renderer);
+        if let mouse::Interaction::None = interaction
+            && cursor.is_over(layout.bounds())
+        {
+            return mouse::Interaction::Idle;
+        }
+        interaction
     }
 
     fn overlay<'c>(
         &'c mut self,
-        layout: Layout<'_>,
+        layout: Layout<'c>,
         renderer: &crate::Renderer,
     ) -> Option<overlay::Element<'c, Message, crate::Theme, crate::Renderer>> {
-        self.content
-            .as_widget_mut()
-            .overlay(self.tree, layout, renderer, iced::Vector::default())
+        let viewport = &layout.bounds();
+
+        self.content.as_widget_mut().overlay(
+            self.tree,
+            layout,
+            renderer,
+            viewport,
+            iced::Vector::default(),
+        )
     }
 }

src/widget/context_drawer/widget.rs

@@ -7,7 +7,7 @@ use crate::{Apply, Element, Renderer, Theme, fl};
 use std::borrow::Cow;
 
 use iced_core::Alignment;
-use iced_core::event::{self, Event};
+use iced_core::event::Event;
 use iced_core::widget::{Operation, Tree};
 use iced_core::{
     Clipboard, Layout, Length, Rectangle, Shell, Vector, Widget, layout, mouse,
@@ -65,7 +65,7 @@ impl<'a, Message: Clone + 'static> ContextDrawer<'a, Message> {
             } else {
                 let title = title
                     .map(|title| text::title4(title).width(Length::Fill).apply(Element::from))
-                    .unwrap_or_else(|| widget::horizontal_space().apply(Element::from));
+                    .unwrap_or_else(|| widget::space::horizontal().apply(Element::from));
                 (title, None)
             };
 
@@ -196,40 +196,40 @@ impl<Message: Clone> Widget<Message, crate::Theme, Renderer> for ContextDrawer<'
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
         self.content
-            .as_widget()
+            .as_widget_mut()
             .layout(&mut tree.children[0], renderer, limits)
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
         operation: &mut dyn Operation<()>,
     ) {
         self.content
-            .as_widget()
+            .as_widget_mut()
             .operate(&mut tree.children[0], layout, renderer, operation);
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         viewport: &Rectangle,
-    ) -> event::Status {
-        self.content.as_widget_mut().on_event(
+    ) {
+        self.content.as_widget_mut().update(
             &mut tree.children[0],
             event,
             layout,
@@ -238,7 +238,7 @@ impl<Message: Clone> Widget<Message, crate::Theme, Renderer> for ContextDrawer<'
             clipboard,
             shell,
             viewport,
-        )
+        );
     }
 
     fn mouse_interaction(
@@ -282,8 +282,9 @@ impl<Message: Clone> Widget<Message, crate::Theme, Renderer> for ContextDrawer<'
     fn overlay<'b>(
         &'b mut self,
         tree: &'b mut Tree,
-        layout: Layout<'_>,
+        layout: Layout<'b>,
         _renderer: &Renderer,
+        _viewport: &Rectangle,
         translation: Vector,
     ) -> Option<iced_overlay::Element<'b, Message, crate::Theme, Renderer>> {
         let bounds = layout.bounds();

src/widget/context_menu.rs

@@ -3,7 +3,12 @@
 
 //! A context menu is a menu in a graphical user interface that appears upon user interaction, such as a right-click mouse operation.
 
-#[cfg(all(feature = "wayland", feature = "winit", feature = "surface-message"))]
+#[cfg(all(
+    feature = "wayland",
+    target_os = "linux",
+    feature = "winit",
+    feature = "surface-message"
+))]
 use crate::app::cosmic::{WINDOWING_SYSTEM, WindowingSystem};
 use crate::widget::menu::{
     self, CloseCondition, Direction, ItemHeight, ItemWidth, MenuBarState, PathHighlight,
@@ -13,7 +18,7 @@ use derive_setters::Setters;
 use iced::touch::Finger;
 use iced::{Event, Vector, keyboard, window};
 use iced_core::widget::{Tree, Widget, tree};
-use iced_core::{Length, Point, Size, event, mouse, touch};
+use iced_core::{Length, Point, Size, mouse, touch};
 use std::collections::HashSet;
 use std::sync::Arc;
 
@@ -27,7 +32,7 @@ pub fn context_menu<'a, Message: 'static + Clone>(
         content: content.into(),
         context_menu: context_menu.map(|menus| {
             vec![menu::Tree::with_children(
-                crate::Element::from(crate::widget::row::<'static, Message>()),
+                crate::Element::from(crate::widget::Row::new()),
                 menus,
             )]
         }),
@@ -59,7 +64,12 @@ pub struct ContextMenu<'a, Message> {
 }
 
 impl<Message: Clone + 'static> ContextMenu<'_, Message> {
-    #[cfg(all(feature = "wayland", feature = "winit", feature = "surface-message"))]
+    #[cfg(all(
+        feature = "wayland",
+        target_os = "linux",
+        feature = "winit",
+        feature = "surface-message"
+    ))]
     #[allow(clippy::too_many_lines)]
     fn create_popup(
         &mut self,
@@ -85,6 +95,7 @@ impl<Message: Clone + 'static> ContextMenu<'_, Message> {
                     // close existing popups
                     state.menu_states.clear();
                     state.active_root.clear();
+
                     shell.publish(self.on_surface_action.as_ref().unwrap()(destroy_popup(id)));
                     state.view_cursor = view_cursor;
                     (
@@ -249,7 +260,7 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, crate::Renderer>
     }
 
     fn diff(&mut self, tree: &mut Tree) {
-        tree.children[0].diff(self.content.as_widget_mut());
+        tree.diff_children(std::slice::from_mut(&mut self.content));
         let state = tree.state.downcast_mut::<LocalState>();
         state.menu_bar_state.inner.with_data_mut(|inner| {
             menu_roots_diff(self.context_menu.as_mut().unwrap(), &mut inner.tree);
@@ -270,13 +281,13 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, crate::Renderer>
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &crate::Renderer,
         limits: &iced_core::layout::Limits,
     ) -> iced_core::layout::Node {
         self.content
-            .as_widget()
+            .as_widget_mut()
             .layout(&mut tree.children[0], renderer, limits)
     }
 
@@ -302,29 +313,29 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, crate::Renderer>
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: iced_core::Layout<'_>,
         renderer: &crate::Renderer,
         operation: &mut dyn iced_core::widget::Operation<()>,
     ) {
         self.content
-            .as_widget()
+            .as_widget_mut()
             .operate(&mut tree.children[0], layout, renderer, operation);
     }
 
     #[allow(clippy::too_many_lines)]
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: iced::Event,
+        event: &iced::Event,
         layout: iced_core::Layout<'_>,
         cursor: iced_core::mouse::Cursor,
         renderer: &crate::Renderer,
         clipboard: &mut dyn iced_core::Clipboard,
         shell: &mut iced_core::Shell<'_, Message>,
         viewport: &iced::Rectangle,
-    ) -> iced_core::event::Status {
+    ) {
         let state = tree.state.downcast_mut::<LocalState>();
         let bounds = layout.bounds();
 
@@ -336,13 +347,12 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, crate::Renderer>
                 .with_data(|d| !d.open && !d.active_root.is_empty());
 
         let open = state.menu_bar_state.inner.with_data_mut(|state| {
-            if reset {
-                if let Some(popup_id) = state.popup_id.get(&self.window_id).copied() {
-                    if let Some(handler) = self.on_surface_action.as_ref() {
-                        shell.publish((handler)(crate::surface::Action::DestroyPopup(popup_id)));
-                        state.reset();
-                    }
-                }
+            if reset
+                && let Some(popup_id) = state.popup_id.get(&self.window_id).copied()
+                && let Some(handler) = self.on_surface_action.as_ref()
+            {
+                shell.publish((handler)(crate::surface::Action::DestroyPopup(popup_id)));
+                state.reset();
             }
             state.open
         });
@@ -356,7 +366,6 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, crate::Renderer>
                 mouse::Button::Right | mouse::Button::Left,
             ))
             | Event::Touch(touch::Event::FingerPressed { .. })
-            | Event::Window(window::Event::Focused)
                 if open )
         {
             state.menu_bar_state.inner.with_data_mut(|state| {
@@ -365,16 +374,20 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, crate::Renderer>
                 state.active_root.clear();
                 state.open = false;
 
-                #[cfg(all(feature = "wayland", feature = "winit", feature = "surface-message"))]
-                if matches!(WINDOWING_SYSTEM.get(), Some(WindowingSystem::Wayland)) {
-                    if let Some(id) = state.popup_id.remove(&self.window_id) {
-                        {
-                            let surface_action = self.on_surface_action.as_ref().unwrap();
-                            shell
-                                .publish(surface_action(crate::surface::action::destroy_popup(id)));
-                        }
-                        state.view_cursor = cursor;
+                #[cfg(all(
+                    feature = "wayland",
+                    target_os = "linux",
+                    feature = "winit",
+                    feature = "surface-message"
+                ))]
+                if matches!(WINDOWING_SYSTEM.get(), Some(WindowingSystem::Wayland))
+                    && let Some(id) = state.popup_id.remove(&self.window_id)
+                {
+                    {
+                        let surface_action = self.on_surface_action.as_ref().unwrap();
+                        shell.publish(surface_action(crate::surface::action::destroy_popup(id)));
                     }
+                    state.view_cursor = cursor;
                 }
             });
         }
@@ -384,11 +397,11 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, crate::Renderer>
 
             match event {
                 Event::Touch(touch::Event::FingerPressed { id, .. }) => {
-                    state.fingers_pressed.insert(id);
+                    state.fingers_pressed.insert(*id);
                 }
 
                 Event::Touch(touch::Event::FingerLifted { id, .. }) => {
-                    state.fingers_pressed.remove(&id);
+                    state.fingers_pressed.remove(id);
                 }
 
                 _ => (),
@@ -397,7 +410,7 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, crate::Renderer>
             // Present a context menu on a right click event.
             if !was_open
                 && self.context_menu.is_some()
-                && (right_button_released(&event) || (touch_lifted(&event) && fingers_pressed == 2))
+                && (right_button_released(event) || (touch_lifted(event) && fingers_pressed == 2))
             {
                 state.context_cursor = cursor.position().unwrap_or_default();
                 let state = tree.state.downcast_mut::<LocalState>();
@@ -405,15 +418,21 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, crate::Renderer>
                     state.open = true;
                     state.view_cursor = cursor;
                 });
-                #[cfg(all(feature = "wayland", feature = "winit", feature = "surface-message"))]
+                #[cfg(all(
+                    feature = "wayland",
+                    target_os = "linux",
+                    feature = "winit",
+                    feature = "surface-message"
+                ))]
                 if matches!(WINDOWING_SYSTEM.get(), Some(WindowingSystem::Wayland)) {
                     self.create_popup(layout, cursor, renderer, shell, viewport, state);
                 }
 
-                return event::Status::Captured;
-            } else if !was_open && right_button_released(&event)
-                || (touch_lifted(&event))
-                || left_button_released(&event)
+                shell.capture_event();
+                return;
+            } else if !was_open && right_button_released(event)
+                || (touch_lifted(event))
+                || left_button_released(event)
             {
                 state.menu_bar_state.inner.with_data_mut(|state| {
                     was_open = true;
@@ -423,24 +442,24 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, crate::Renderer>
 
                     #[cfg(all(
                         feature = "wayland",
+                        target_os = "linux",
                         feature = "winit",
                         feature = "surface-message"
                     ))]
-                    if matches!(WINDOWING_SYSTEM.get(), Some(WindowingSystem::Wayland)) {
-                        if let Some(id) = state.popup_id.remove(&self.window_id) {
-                            {
-                                let surface_action = self.on_surface_action.as_ref().unwrap();
-                                shell.publish(surface_action(
-                                    crate::surface::action::destroy_popup(id),
-                                ));
-                            }
-                            state.view_cursor = cursor;
+                    if matches!(WINDOWING_SYSTEM.get(), Some(WindowingSystem::Wayland))
+                        && let Some(id) = state.popup_id.remove(&self.window_id)
+                    {
+                        {
+                            let surface_action = self.on_surface_action.as_ref().unwrap();
+                            shell
+                                .publish(surface_action(crate::surface::action::destroy_popup(id)));
                         }
+                        state.view_cursor = cursor;
                     }
                 });
             }
         }
-        self.content.as_widget_mut().on_event(
+        self.content.as_widget_mut().update(
             &mut tree.children[0],
             event,
             layout,
@@ -449,7 +468,7 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, crate::Renderer>
             clipboard,
             shell,
             viewport,
-        )
+        );
     }
 
     fn overlay<'b>(
@@ -457,9 +476,15 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, crate::Renderer>
         tree: &'b mut Tree,
         layout: iced_core::Layout<'_>,
         _renderer: &crate::Renderer,
+        _viewport: &iced::Rectangle,
         translation: Vector,
     ) -> Option<iced_core::overlay::Element<'b, Message, crate::Theme, crate::Renderer>> {
-        #[cfg(all(feature = "wayland", feature = "winit", feature = "surface-message"))]
+        #[cfg(all(
+            feature = "wayland",
+            target_os = "linux",
+            feature = "winit",
+            feature = "surface-message"
+        ))]
         if matches!(WINDOWING_SYSTEM.get(), Some(WindowingSystem::Wayland))
             && self.window_id != window::Id::NONE
             && self.on_surface_action.is_some()

src/widget/dialog.rs

@@ -123,7 +123,7 @@ impl<'a, Message: Clone + 'static> From<Dialog<'a, Message>> for Element<'a, Mes
         if let Some(body) = dialog.body {
             if should_space {
                 content_col = content_col
-                    .push(widget::vertical_space().height(Length::Fixed(space_xxs.into())));
+                    .push(widget::space::vertical().height(Length::Fixed(space_xxs.into())));
             }
             content_col = content_col.push(
                 widget::container(widget::scrollable(widget::text::body(body))).max_height(300.),
@@ -133,7 +133,7 @@ impl<'a, Message: Clone + 'static> From<Dialog<'a, Message>> for Element<'a, Mes
         for control in dialog.controls {
             if should_space {
                 content_col = content_col
-                    .push(widget::vertical_space().height(Length::Fixed(space_s.into())));
+                    .push(widget::space::vertical().height(Length::Fixed(space_s.into())));
             }
             content_col = content_col.push(control);
             should_space = true;
@@ -149,7 +149,7 @@ impl<'a, Message: Clone + 'static> From<Dialog<'a, Message>> for Element<'a, Mes
         if let Some(button) = dialog.tertiary_action {
             button_row = button_row.push(button);
         }
-        button_row = button_row.push(widget::horizontal_space());
+        button_row = button_row.push(widget::space::horizontal());
         if let Some(button) = dialog.secondary_action {
             button_row = button_row.push(button);
         }

src/widget/dnd_destination.rs

@@ -7,23 +7,24 @@ use iced::Vector;
 
 use crate::{
     Element,
-    iced::{
-        Event, Length, Rectangle,
-        clipboard::{
-            dnd::{self, DndAction, DndDestinationRectangle, DndEvent, OfferEvent},
-            mime::AllowedMimeTypes,
-        },
-        event,
-        id::Internal,
-        mouse, overlay,
-    },
-    iced_core::{
-        self, Clipboard, Shell, layout,
-        widget::{Tree, tree},
-    },
     widget::{Id, Widget},
 };
 
+use iced::{
+    Event, Length, Rectangle,
+    clipboard::{
+        dnd::{self, DndAction, DndDestinationRectangle, DndEvent, OfferEvent},
+        mime::AllowedMimeTypes,
+    },
+    event,
+    id::Internal,
+    mouse, overlay,
+};
+use iced_core::{
+    self, Clipboard, Shell, layout,
+    widget::{Tree, tree},
+};
+
 pub fn dnd_destination<'a, Message: 'static>(
     child: impl Into<Element<'a, Message>>,
     mimes: Vec<Cow<'static, str>>,
@@ -291,7 +292,7 @@ impl<Message: 'static> Widget<Message, crate::Theme, crate::Renderer>
     }
 
     fn diff(&mut self, tree: &mut Tree) {
-        tree.children[0].diff(self.container.as_widget_mut());
+        tree.diff_children(std::slice::from_mut(&mut self.container));
     }
 
     fn state(&self) -> iced_core::widget::tree::State {
@@ -303,43 +304,43 @@ impl<Message: 'static> Widget<Message, crate::Theme, crate::Renderer>
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &crate::Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
         self.container
-            .as_widget()
+            .as_widget_mut()
             .layout(&mut tree.children[0], renderer, limits)
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: layout::Layout<'_>,
         renderer: &crate::Renderer,
         operation: &mut dyn iced_core::widget::Operation<()>,
     ) {
         self.container
-            .as_widget()
+            .as_widget_mut()
             .operate(&mut tree.children[0], layout, renderer, operation);
     }
 
     #[allow(clippy::too_many_lines)]
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: layout::Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &crate::Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         viewport: &Rectangle,
-    ) -> event::Status {
-        let s = self.container.as_widget_mut().on_event(
+    ) {
+        self.container.as_widget_mut().update(
             &mut tree.children[0],
-            event.clone(),
+            event,
             layout,
             cursor,
             renderer,
@@ -347,8 +348,8 @@ impl<Message: 'static> Widget<Message, crate::Theme, crate::Renderer>
             shell,
             viewport,
         );
-        if matches!(s, event::Status::Captured) {
-            return event::Status::Captured;
+        if shell.is_event_captured() {
+            return;
         }
 
         let state = tree.state.downcast_mut::<State<()>>();
@@ -367,23 +368,23 @@ impl<Message: 'static> Widget<Message, crate::Theme, crate::Renderer>
                 OfferEvent::Enter {
                     x, y, mime_types, ..
                 },
-            )) if id == Some(my_id) => {
+            )) if *id == Some(my_id) => {
                 if !self.mime_matches(&mime_types) {
                     log::trace!(
                         target: DND_DEST_LOG_TARGET,
                         "offer enter id={my_id:?} ignored (mimes={mime_types:?} not in {:?})",
                         self.mime_types
                     );
-                    return event::Status::Ignored;
+                    return;
                 }
                 log::trace!(
                     target: DND_DEST_LOG_TARGET,
                     "offer enter id={my_id:?} coords=({x},{y}) mimes={mime_types:?}"
                 );
                 if let Some(msg) = state.on_enter(
-                    x,
-                    y,
-                    mime_types,
+                    *x,
+                    *y,
+                    mime_types.clone(),
                     self.on_enter.as_ref().map(std::convert::AsRef::as_ref),
                     (),
                 ) {
@@ -391,13 +392,13 @@ impl<Message: 'static> Widget<Message, crate::Theme, crate::Renderer>
                 }
                 if self.forward_drag_as_cursor {
                     #[allow(clippy::cast_possible_truncation)]
-                    let drag_cursor = mouse::Cursor::Available((x as f32, y as f32).into());
+                    let drag_cursor = mouse::Cursor::Available((*x as f32, *y as f32).into());
                     let event = Event::Mouse(mouse::Event::CursorMoved {
                         position: drag_cursor.position().unwrap(),
                     });
-                    self.container.as_widget_mut().on_event(
+                    self.container.as_widget_mut().update(
                         &mut tree.children[0],
-                        event,
+                        &event,
                         layout,
                         drag_cursor,
                         renderer,
@@ -406,7 +407,8 @@ impl<Message: 'static> Widget<Message, crate::Theme, crate::Renderer>
                         viewport,
                     );
                 }
-                return event::Status::Captured;
+                shell.capture_event();
+                return;
             }
             Event::Dnd(DndEvent::Offer(_, OfferEvent::Leave)) => {
                 log::trace!(
@@ -423,9 +425,9 @@ impl<Message: 'static> Widget<Message, crate::Theme, crate::Renderer>
                 if self.forward_drag_as_cursor {
                     let drag_cursor = mouse::Cursor::Unavailable;
                     let event = Event::Mouse(mouse::Event::CursorLeft);
-                    self.container.as_widget_mut().on_event(
+                    self.container.as_widget_mut().update(
                         &mut tree.children[0],
-                        event,
+                        &event,
                         layout,
                         drag_cursor,
                         renderer,
@@ -434,16 +436,16 @@ impl<Message: 'static> Widget<Message, crate::Theme, crate::Renderer>
                         viewport,
                     );
                 }
-                return event::Status::Ignored;
+                return;
             }
-            Event::Dnd(DndEvent::Offer(id, OfferEvent::Motion { x, y })) if id == Some(my_id) => {
+            Event::Dnd(DndEvent::Offer(id, OfferEvent::Motion { x, y })) if *id == Some(my_id) => {
                 log::trace!(
                     target: DND_DEST_LOG_TARGET,
                     "offer motion id={my_id:?} coords=({x},{y})"
                 );
                 if let Some(msg) = state.on_motion(
-                    x,
-                    y,
+                    *x,
+                    *y,
                     self.on_motion.as_ref().map(std::convert::AsRef::as_ref),
                     self.on_enter.as_ref().map(std::convert::AsRef::as_ref),
                     (),
@@ -453,13 +455,13 @@ impl<Message: 'static> Widget<Message, crate::Theme, crate::Renderer>
 
                 if self.forward_drag_as_cursor {
                     #[allow(clippy::cast_possible_truncation)]
-                    let drag_cursor = mouse::Cursor::Available((x as f32, y as f32).into());
+                    let drag_cursor = mouse::Cursor::Available((*x as f32, *y as f32).into());
                     let event = Event::Mouse(mouse::Event::CursorMoved {
                         position: drag_cursor.position().unwrap(),
                     });
-                    self.container.as_widget_mut().on_event(
+                    self.container.as_widget_mut().update(
                         &mut tree.children[0],
-                        event,
+                        &event,
                         layout,
                         drag_cursor,
                         renderer,
@@ -468,7 +470,8 @@ impl<Message: 'static> Widget<Message, crate::Theme, crate::Renderer>
                         viewport,
                     );
                 }
-                return event::Status::Captured;
+                shell.capture_event();
+                return;
             }
             Event::Dnd(DndEvent::Offer(_, OfferEvent::LeaveDestination)) => {
                 log::trace!(
@@ -481,9 +484,9 @@ impl<Message: 'static> Widget<Message, crate::Theme, crate::Renderer>
                 {
                     shell.publish(msg);
                 }
-                return event::Status::Ignored;
+                return;
             }
-            Event::Dnd(DndEvent::Offer(id, OfferEvent::Drop)) if id == Some(my_id) => {
+            Event::Dnd(DndEvent::Offer(id, OfferEvent::Drop)) if *id == Some(my_id) => {
                 log::trace!(
                     target: DND_DEST_LOG_TARGET,
                     "offer drop id={my_id:?}"
@@ -493,27 +496,29 @@ impl<Message: 'static> Widget<Message, crate::Theme, crate::Renderer>
                 {
                     shell.publish(msg);
                 }
-                return event::Status::Captured;
+                shell.capture_event();
+                return;
             }
             Event::Dnd(DndEvent::Offer(id, OfferEvent::SelectedAction(action)))
-                if id == Some(my_id) =>
+                if *id == Some(my_id) =>
             {
                 log::trace!(
                     target: DND_DEST_LOG_TARGET,
                     "offer selected-action id={my_id:?} action={action:?}"
                 );
                 if let Some(msg) = state.on_action_selected(
-                    action,
+                    *action,
                     self.on_action_selected
                         .as_ref()
                         .map(std::convert::AsRef::as_ref),
                 ) {
                     shell.publish(msg);
                 }
-                return event::Status::Captured;
+                shell.capture_event();
+                return;
             }
             Event::Dnd(DndEvent::Offer(id, OfferEvent::Data { data, mime_type }))
-                if id == Some(my_id) =>
+                if *id == Some(my_id) =>
             {
                 log::trace!(
                     target: DND_DEST_LOG_TARGET,
@@ -527,25 +532,33 @@ impl<Message: 'static> Widget<Message, crate::Theme, crate::Renderer>
                     && let Ok(s) = String::from_utf8(data[..data.len() - 1].to_vec())
                 {
                     shell.publish(f(s));
-                    return event::Status::Captured;
+                    shell.capture_event();
+                    return;
                 }
 
                 if let (Some(msg), ret) = state.on_data_received(
-                    mime_type,
-                    data,
+                    mime_type.clone(),
+                    data.clone(),
                     self.on_data_received
                         .as_ref()
                         .map(std::convert::AsRef::as_ref),
                     self.on_finish.as_ref().map(std::convert::AsRef::as_ref),
                 ) {
                     shell.publish(msg);
-                    return ret;
+                    if ret == event::Status::Captured {
+                        log::trace!(
+                            target: DND_DEST_LOG_TARGET,
+                            "offer data id={my_id:?} captured"
+                        );
+                        shell.capture_event();
+                    }
+                    return;
                 }
-                return event::Status::Captured;
+                shell.capture_event();
+                return;
             }
             _ => {}
         }
-        event::Status::Ignored
     }
 
     fn mouse_interaction(
@@ -589,13 +602,18 @@ impl<Message: 'static> Widget<Message, crate::Theme, crate::Renderer>
     fn overlay<'b>(
         &'b mut self,
         tree: &'b mut Tree,
-        layout: layout::Layout<'_>,
+        layout: layout::Layout<'b>,
         renderer: &crate::Renderer,
+        viewport: &Rectangle,
         translation: Vector,
     ) -> Option<overlay::Element<'b, Message, crate::Theme, crate::Renderer>> {
-        self.container
-            .as_widget_mut()
-            .overlay(&mut tree.children[0], layout, renderer, translation)
+        self.container.as_widget_mut().overlay(
+            &mut tree.children[0],
+            layout,
+            renderer,
+            viewport,
+            translation,
+        )
     }
 
     fn drag_destinations(

src/widget/dnd_source.rs

@@ -1,20 +1,20 @@
 use std::any::Any;
 
-use iced_core::window;
+use iced_core::{widget::Operation, window};
 
 use crate::{
     Element,
-    iced::{
-        Event, Length, Point, Rectangle, Vector,
-        clipboard::dnd::{DndAction, DndEvent, SourceEvent},
-        event, mouse, overlay,
-    },
-    iced_core::{
-        self, Clipboard, Shell, layout, renderer,
-        widget::{Tree, tree},
-    },
     widget::{Id, Widget, container},
 };
+use iced::{
+    Event, Length, Point, Rectangle, Vector,
+    clipboard::dnd::{DndAction, DndEvent, SourceEvent},
+    event, mouse, overlay,
+};
+use iced_core::{
+    self, Clipboard, Shell, layout, renderer,
+    widget::{Tree, tree},
+};
 
 pub fn dnd_source<
     'a,
@@ -131,21 +131,25 @@ impl<
         );
     }
 
+    #[must_use]
     pub fn on_start(mut self, on_start: Option<Message>) -> Self {
         self.on_start = on_start;
         self
     }
 
+    #[must_use]
     pub fn on_cancel(mut self, on_cancelled: Option<Message>) -> Self {
         self.on_cancelled = on_cancelled;
         self
     }
 
+    #[must_use]
     pub fn on_finish(mut self, on_finish: Option<Message>) -> Self {
         self.on_finish = on_finish;
         self
     }
 
+    #[must_use]
     pub fn window(mut self, window: window::Id) -> Self {
         self.window = Some(window);
         self
@@ -164,7 +168,7 @@ impl<Message: Clone + 'static, D: iced::clipboard::mime::AsMimeTypes + std::mark
     }
 
     fn diff(&mut self, tree: &mut Tree) {
-        tree.children[0].diff(self.container.as_widget_mut());
+        tree.diff_children(std::slice::from_mut(&mut self.container));
     }
 
     fn state(&self) -> iced_core::widget::tree::State {
@@ -176,7 +180,7 @@ impl<Message: Clone + 'static, D: iced::clipboard::mime::AsMimeTypes + std::mark
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &crate::Renderer,
         limits: &layout::Limits,
@@ -184,41 +188,44 @@ impl<Message: Clone + 'static, D: iced::clipboard::mime::AsMimeTypes + std::mark
         let state = tree.state.downcast_mut::<State>();
         let node = self
             .container
-            .as_widget()
+            .as_widget_mut()
             .layout(&mut tree.children[0], renderer, limits);
         state.cached_bounds = node.bounds();
         node
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: layout::Layout<'_>,
         renderer: &crate::Renderer,
-        operation: &mut dyn iced_core::widget::Operation<()>,
+        operation: &mut dyn Operation,
     ) {
-        operation.custom((&mut tree.state) as &mut dyn Any, Some(&self.id));
-        operation.container(Some(&self.id), layout.bounds(), &mut |operation| {
-            self.container
-                .as_widget()
-                .operate(&mut tree.children[0], layout, renderer, operation)
-        });
+        operation.custom(
+            Some(&self.id),
+            layout.bounds(),
+            (&mut tree.state) as &mut dyn Any,
+        );
+
+        self.container
+            .as_widget_mut()
+            .operate(&mut tree.children[0], layout, renderer, operation);
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: layout::Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &crate::Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         viewport: &Rectangle,
-    ) -> event::Status {
-        let ret = self.container.as_widget_mut().on_event(
+    ) {
+        self.container.as_widget_mut().update(
             &mut tree.children[0],
-            event.clone(),
+            event,
             layout,
             cursor,
             renderer,
@@ -233,54 +240,48 @@ impl<Message: Clone + 'static, D: iced::clipboard::mime::AsMimeTypes + std::mark
             Event::Mouse(mouse_event) => match mouse_event {
                 mouse::Event::ButtonPressed(mouse::Button::Left) => {
                     if let Some(position) = cursor.position() {
-                        if !state.hovered {
-                            return ret;
+                        if !cursor.is_over(layout.bounds()) {
+                            return;
                         }
 
                         state.left_pressed_position = Some(position);
-                        return event::Status::Captured;
+                        shell.capture_event();
                     }
                 }
                 mouse::Event::ButtonReleased(mouse::Button::Left)
                     if state.left_pressed_position.is_some() =>
                 {
                     state.left_pressed_position = None;
-                    return event::Status::Captured;
+                    shell.capture_event();
                 }
                 mouse::Event::CursorMoved { .. } => {
                     if let Some(position) = cursor.position() {
-                        if state.hovered {
-                            // We ignore motion if we do not possess drag content by now.
-                            if self.drag_content.is_none() {
-                                state.left_pressed_position = None;
-                                return ret;
-                            }
-                            if let Some(left_pressed_position) = state.left_pressed_position {
-                                if position.distance(left_pressed_position) > self.drag_threshold {
-                                    if let Some(on_start) = self.on_start.as_ref() {
-                                        shell.publish(on_start.clone())
-                                    }
-                                    let offset = Vector::new(
-                                        left_pressed_position.x - layout.bounds().x,
-                                        left_pressed_position.y - layout.bounds().y,
-                                    );
-                                    self.start_dnd(clipboard, state.cached_bounds, offset);
-                                    state.is_dragging = true;
-                                    state.left_pressed_position = None;
-                                }
-                            }
-                            if !cursor.is_over(layout.bounds()) {
-                                state.hovered = false;
-
-                                return ret;
-                            }
-                        } else if cursor.is_over(layout.bounds()) {
-                            state.hovered = true;
+                        // We ignore motion if we do not possess drag content by now.
+                        if self.drag_content.is_none() {
+                            state.left_pressed_position = None;
+                            return;
                         }
-                        return event::Status::Captured;
+                        if let Some(left_pressed_position) = state.left_pressed_position
+                            && position.distance(left_pressed_position) > self.drag_threshold
+                        {
+                            if let Some(on_start) = self.on_start.as_ref() {
+                                shell.publish(on_start.clone());
+                            }
+                            let offset = Vector::new(
+                                left_pressed_position.x - layout.bounds().x,
+                                left_pressed_position.y - layout.bounds().y,
+                            );
+                            self.start_dnd(clipboard, state.cached_bounds, offset);
+                            state.is_dragging = true;
+                            state.left_pressed_position = None;
+                        }
+                        if !cursor.is_over(layout.bounds()) {
+                            return;
+                        }
+                        shell.capture_event();
                     }
                 }
-                _ => return ret,
+                _ => (),
             },
             Event::Dnd(DndEvent::Source(SourceEvent::Cancelled)) => {
                 if state.is_dragging {
@@ -288,9 +289,8 @@ impl<Message: Clone + 'static, D: iced::clipboard::mime::AsMimeTypes + std::mark
                         shell.publish(m.clone());
                     }
                     state.is_dragging = false;
-                    return event::Status::Captured;
+                    shell.capture_event();
                 }
-                return ret;
             }
             Event::Dnd(DndEvent::Source(SourceEvent::Finished)) => {
                 if state.is_dragging {
@@ -298,13 +298,11 @@ impl<Message: Clone + 'static, D: iced::clipboard::mime::AsMimeTypes + std::mark
                         shell.publish(m.clone());
                     }
                     state.is_dragging = false;
-                    return event::Status::Captured;
+                    shell.capture_event();
                 }
-                return ret;
             }
-            _ => return ret,
+            _ => (),
         }
-        ret
     }
 
     fn mouse_interaction(
@@ -352,13 +350,18 @@ impl<Message: Clone + 'static, D: iced::clipboard::mime::AsMimeTypes + std::mark
     fn overlay<'b>(
         &'b mut self,
         tree: &'b mut Tree,
-        layout: layout::Layout<'_>,
+        layout: layout::Layout<'b>,
         renderer: &crate::Renderer,
+        viewport: &Rectangle,
         translation: Vector,
     ) -> Option<overlay::Element<'b, Message, crate::Theme, crate::Renderer>> {
-        self.container
-            .as_widget_mut()
-            .overlay(&mut tree.children[0], layout, renderer, translation)
+        self.container.as_widget_mut().overlay(
+            &mut tree.children[0],
+            layout,
+            renderer,
+            viewport,
+            translation,
+        )
     }
 
     fn drag_destinations(
@@ -411,7 +414,6 @@ impl<
 /// Local state of the [`MouseListener`].
 #[derive(Debug, Default)]
 struct State {
-    hovered: bool,
     left_pressed_position: Option<Point>,
     is_dragging: bool,
     cached_bounds: Rectangle,

src/widget/dropdown/menu/mod.rs

@@ -213,7 +213,7 @@ impl<'a, Message: Clone + 'a> Overlay<'a, Message> {
         }
     }
 
-    fn _layout(&self, renderer: &crate::Renderer, bounds: Size) -> layout::Node {
+    fn _layout(&mut self, renderer: &crate::Renderer, bounds: Size) -> layout::Node {
         let space_below = bounds.height - (self.position.y + self.target_height);
         let space_above = self.position.y;
 
@@ -242,19 +242,19 @@ impl<'a, Message: Clone + 'a> Overlay<'a, Message> {
         })
     }
 
-    fn _on_event(
+    fn _update(
         &mut self,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &crate::Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
-    ) -> event::Status {
+    ) {
         let bounds = layout.bounds();
 
         self.state.with_data_mut(|tree| {
-            self.container.on_event(
+            self.container.update(
                 tree, event, layout, cursor, renderer, clipboard, shell, &bounds,
             )
         })
@@ -293,6 +293,7 @@ impl<'a, Message: Clone + 'a> Overlay<'a, Message> {
                     radius: appearance.border_radius,
                 },
                 shadow: Shadow::default(),
+                snap: true,
             },
             appearance.background,
         );
@@ -311,26 +312,25 @@ impl<'a, Message: Clone + 'a> iced_core::Overlay<Message, crate::Theme, crate::R
         self._layout(renderer, bounds)
     }
 
-    fn on_event(
+    fn update(
         &mut self,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &crate::Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
-    ) -> event::Status {
-        self._on_event(event, layout, cursor, renderer, clipboard, shell)
+    ) {
+        self._update(event, layout, cursor, renderer, clipboard, shell)
     }
 
     fn mouse_interaction(
         &self,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
-        viewport: &Rectangle,
         renderer: &crate::Renderer,
     ) -> mouse::Interaction {
-        self._mouse_interaction(layout, cursor, viewport, renderer)
+        self._mouse_interaction(layout, cursor, &layout.bounds(), renderer)
     }
 
     fn draw(
@@ -353,7 +353,7 @@ impl<'a, Message: Clone + 'a> crate::widget::Widget<Message, crate::Theme, crate
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut iced_core::widget::Tree,
         renderer: &crate::Renderer,
         limits: &iced::Limits,
@@ -375,18 +375,18 @@ impl<'a, Message: Clone + 'a> crate::widget::Widget<Message, crate::Theme, crate
         self._mouse_interaction(layout, cursor, viewport, renderer)
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         _tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &crate::Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         _viewport: &Rectangle,
-    ) -> event::Status {
-        self._on_event(event, layout, cursor, renderer, clipboard, shell)
+    ) {
+        self._update(event, layout, cursor, renderer, clipboard, shell)
     }
 
     fn draw(
@@ -435,7 +435,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         renderer: &crate::Renderer,
         limits: &layout::Limits,
@@ -452,7 +452,7 @@ where
         let size = {
             let intrinsic = Size::new(
                 0.0,
-                (f32::from(text_line_height) + self.padding.vertical()) * self.options.len() as f32,
+                (f32::from(text_line_height) + self.padding.y()) * self.options.len() as f32,
             );
 
             limits.resolve(Length::Fill, Length::Shrink, intrinsic)
@@ -461,17 +461,17 @@ where
         layout::Node::new(size)
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         _state: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &crate::Renderer,
         _clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         _viewport: &Rectangle,
-    ) -> event::Status {
+    ) {
         match event {
             Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => {
                 let hovered_guard = self.hovered_option.lock().unwrap();
@@ -481,7 +481,8 @@ where
                         if let Some(close_on_selected) = self.close_on_selected.as_ref() {
                             shell.publish(close_on_selected.clone());
                         }
-                        return event::Status::Captured;
+                        shell.capture_event();
+                        return;
                     }
                 }
             }
@@ -493,7 +494,7 @@ where
 
                     let option_height =
                         f32::from(self.text_line_height.to_absolute(Pixels(text_size)))
-                            + self.padding.vertical();
+                            + self.padding.y();
 
                     let new_hovered_option = (cursor_position.y / option_height) as usize;
                     let mut hovered_guard = self.hovered_option.lock().unwrap();
@@ -515,7 +516,7 @@ where
 
                     let option_height =
                         f32::from(self.text_line_height.to_absolute(Pixels(text_size)))
-                            + self.padding.vertical();
+                            + self.padding.y();
                     let mut hovered_guard = self.hovered_option.lock().unwrap();
 
                     *hovered_guard = Some((cursor_position.y / option_height) as usize);
@@ -525,14 +526,13 @@ where
                         if let Some(close_on_selected) = self.close_on_selected.as_ref() {
                             shell.publish(close_on_selected.clone());
                         }
-                        return event::Status::Captured;
+                        shell.capture_event();
+                        return;
                     }
                 }
             }
             _ => {}
         }
-
-        event::Status::Ignored
     }
 
     fn mouse_interaction(
@@ -568,8 +568,8 @@ where
         let text_size = self
             .text_size
             .unwrap_or_else(|| text::Renderer::default_size(renderer).0);
-        let option_height = f32::from(self.text_line_height.to_absolute(Pixels(text_size)))
-            + self.padding.vertical();
+        let option_height =
+            f32::from(self.text_line_height.to_absolute(Pixels(text_size))) + self.padding.y();
 
         let offset = viewport.y - bounds.y;
         let start = (offset / option_height) as usize;
@@ -605,6 +605,7 @@ where
                             ..Default::default()
                         },
                         shadow: Shadow::default(),
+                        snap: true,
                     },
                     appearance.selected_background,
                 );
@@ -614,16 +615,13 @@ where
                         .color(appearance.selected_text_color)
                         .border_radius(appearance.border_radius);
 
-                svg::Renderer::draw_svg(
-                    renderer,
-                    svg_handle,
-                    Rectangle {
-                        x: item_x + item_width - 16.0 - 8.0,
-                        y: bounds.y + (bounds.height / 2.0 - 8.0),
-                        width: 16.0,
-                        height: 16.0,
-                    },
-                );
+                let bounds = Rectangle {
+                    x: item_x + item_width - 16.0 - 8.0,
+                    y: bounds.y + (bounds.height / 2.0 - 8.0),
+                    width: 16.0,
+                    height: 16.0,
+                };
+                svg::Renderer::draw_svg(renderer, svg_handle, bounds, bounds);
 
                 (appearance.selected_text_color, crate::font::semibold())
             } else if *hovered_guard == Some(i) {
@@ -642,6 +640,7 @@ where
                             ..Default::default()
                         },
                         shadow: Shadow::default(),
+                        snap: true,
                     },
                     appearance.hovered_background,
                 );
@@ -678,8 +677,8 @@ where
                     size: Pixels(text_size),
                     line_height: self.text_line_height,
                     font,
-                    horizontal_alignment: alignment::Horizontal::Left,
-                    vertical_alignment: alignment::Vertical::Center,
+                    align_x: text::Alignment::Left,
+                    align_y: alignment::Vertical::Center,
                     shaping: text::Shaping::Advanced,
                     wrapping: text::Wrapping::default(),
                     ellipsize: text::Ellipsize::default(),

src/widget/dropdown/mod.rs

@@ -50,18 +50,18 @@ pub fn popup_dropdown<
     let dropdown: Dropdown<'_, S, Message, AppMessage> =
         Dropdown::new(selections.into(), selected, on_selected);
 
-    #[cfg(all(feature = "winit", feature = "wayland"))]
+    #[cfg(all(feature = "winit", feature = "wayland", target_os = "linux"))]
     let dropdown = dropdown.with_popup(_parent_id, _on_surface_action, _map_action);
 
     dropdown
 }
 
-/// Produces a [`Task`] that closes the [`Dropdown`].
-pub fn close<Message: 'static>(id: Id) -> iced_runtime::Task<Message> {
-    iced_runtime::task::effect(iced_runtime::Action::Widget(Box::new(operation::close(id))))
-}
+// /// Produces a [`Task`] that closes the [`Dropdown`].
+// pub fn close<Message: 'static>(id: Id) -> iced_runtime::Task<Message> {
+//     iced_runtime::task::effect(iced_runtime::Action::Widget(Box::new(operation::close(id))))
+// }
 
-/// Produces a [`Task`] that opens the [`Dropdown`].
-pub fn open<Message: 'static>(id: Id) -> iced_runtime::Task<Message> {
-    iced_runtime::task::effect(iced_runtime::Action::Widget(Box::new(operation::open(id))))
-}
+// /// Produces a [`Task`] that opens the [`Dropdown`].
+// pub fn open<Message: 'static>(id: Id) -> iced_runtime::Task<Message> {
+//     iced_runtime::task::effect(iced_runtime::Action::Widget(Box::new(operation::open(id))))
+// }

src/widget/dropdown/multi/menu.rs

@@ -209,18 +209,18 @@ impl<Message> iced_core::Overlay<Message, crate::Theme, crate::Renderer> for Ove
         })
     }
 
-    fn on_event(
+    fn update(
         &mut self,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &crate::Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
-    ) -> event::Status {
+    ) {
         let bounds = layout.bounds();
 
-        self.container.on_event(
+        self.container.update(
             self.state, event, layout, cursor, renderer, clipboard, shell, &bounds,
         )
     }
@@ -229,11 +229,10 @@ impl<Message> iced_core::Overlay<Message, crate::Theme, crate::Renderer> for Ove
         &self,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
-        viewport: &Rectangle,
         renderer: &crate::Renderer,
     ) -> mouse::Interaction {
         self.container
-            .mouse_interaction(self.state, layout, cursor, viewport, renderer)
+            .mouse_interaction(self.state, layout, cursor, &layout.bounds(), renderer)
     }
 
     fn draw(
@@ -256,6 +255,7 @@ impl<Message> iced_core::Overlay<Message, crate::Theme, crate::Renderer> for Ove
                     radius: appearance.border_radius,
                 },
                 shadow: Shadow::default(),
+                snap: true,
             },
             appearance.background,
         );
@@ -287,7 +287,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         _tree: &mut Tree,
         renderer: &crate::Renderer,
         limits: &layout::Limits,
@@ -309,7 +309,7 @@ where
             )
         });
 
-        let vertical_padding = self.padding.vertical();
+        let vertical_padding = self.padding.y();
         let text_line_height = f32::from(text_line_height);
 
         let size = {
@@ -328,17 +328,17 @@ where
         layout::Node::new(size)
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         _state: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &crate::Renderer,
         _clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         _viewport: &Rectangle,
-    ) -> event::Status {
+    ) {
         let bounds = layout.bounds();
 
         match event {
@@ -346,7 +346,8 @@ where
                 if cursor.is_over(bounds) {
                     if let Some(item) = self.hovered_option.as_ref() {
                         shell.publish((self.on_selected)(item.clone()));
-                        return event::Status::Captured;
+                        shell.capture_event();
+                        return;
                     }
                 }
             }
@@ -361,7 +362,7 @@ where
 
                     let heights = self
                         .options
-                        .element_heights(self.padding.vertical(), text_line_height);
+                        .element_heights(self.padding.y(), text_line_height);
 
                     let mut current_offset = 0.0;
 
@@ -408,7 +409,7 @@ where
 
                     let heights = self
                         .options
-                        .element_heights(self.padding.vertical(), text_line_height);
+                        .element_heights(self.padding.y(), text_line_height);
 
                     let mut current_offset = 0.0;
 
@@ -446,8 +447,6 @@ where
             }
             _ => {}
         }
-
-        event::Status::Ignored
     }
 
     fn mouse_interaction(
@@ -490,7 +489,7 @@ where
         let text_line_height = f32::from(self.text_line_height.to_absolute(Pixels(text_size)));
 
         let visible_options = self.options.visible_options(
-            self.padding.vertical(),
+            self.padding.y(),
             text_line_height,
             offset,
             viewport.height,
@@ -528,24 +527,23 @@ where
                                     ..Default::default()
                                 },
                                 shadow: Shadow::default(),
+                                snap: true,
                             },
                             appearance.selected_background,
                         );
 
+                        let svg_bounds = Rectangle {
+                            x: item_x + item_width - 16.0 - 8.0,
+                            y: bounds.y + (bounds.height / 2.0 - 8.0),
+                            width: 16.0,
+                            height: 16.0,
+                        };
+
                         let svg_handle =
                             svg::Svg::new(crate::widget::common::object_select().clone())
                                 .color(appearance.selected_text_color)
                                 .border_radius(appearance.border_radius);
-                        svg::Renderer::draw_svg(
-                            renderer,
-                            svg_handle,
-                            Rectangle {
-                                x: item_x + item_width - 16.0 - 8.0,
-                                y: bounds.y + (bounds.height / 2.0 - 8.0),
-                                width: 16.0,
-                                height: 16.0,
-                            },
-                        );
+                        svg::Renderer::draw_svg(renderer, svg_handle, svg_bounds, svg_bounds);
 
                         (appearance.selected_text_color, crate::font::semibold())
                     } else if self.hovered_option.as_ref() == Some(item) {
@@ -566,6 +564,7 @@ where
                                     ..Default::default()
                                 },
                                 shadow: Shadow::default(),
+                                snap: true,
                             },
                             appearance.hovered_background,
                         );
@@ -590,8 +589,8 @@ where
                             size: iced::Pixels(text_size),
                             line_height: self.text_line_height,
                             font,
-                            horizontal_alignment: alignment::Horizontal::Left,
-                            vertical_alignment: alignment::Vertical::Center,
+                            align_x: text::Alignment::Left,
+                            align_y: alignment::Vertical::Center,
                             shaping: text::Shaping::Advanced,
                             wrapping: text::Wrapping::default(),
                             ellipsize: text::Ellipsize::default(),
@@ -611,7 +610,7 @@ where
                     })
                     .move_to(Point {
                         x: bounds.x,
-                        y: bounds.y + (self.padding.vertical() / 2.0) - 4.0,
+                        y: bounds.y + (self.padding.y() / 2.0) - 4.0,
                     });
 
                     Widget::<Message, crate::Theme, crate::Renderer>::draw(
@@ -640,8 +639,8 @@ where
                             size: iced::Pixels(text_size),
                             line_height: text::LineHeight::Absolute(Pixels(text_line_height + 4.0)),
                             font: crate::font::default(),
-                            horizontal_alignment: alignment::Horizontal::Center,
-                            vertical_alignment: alignment::Vertical::Center,
+                            align_x: text::Alignment::Center,
+                            align_y: alignment::Vertical::Center,
                             shaping: text::Shaping::Advanced,
                             wrapping: text::Wrapping::default(),
                             ellipsize: text::Ellipsize::default(),

src/widget/dropdown/multi/widget.rs

@@ -78,7 +78,7 @@ impl<'a, S: AsRef<str>, Message: 'a, Item: Clone + PartialEq + 'static>
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &crate::Renderer,
         limits: &layout::Limits,
@@ -116,17 +116,17 @@ impl<'a, S: AsRef<str>, Message: 'a, Item: Clone + PartialEq + 'static>
         )
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         _renderer: &crate::Renderer,
         _clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         _viewport: &Rectangle,
-    ) -> event::Status {
+    ) {
         update(
             &event,
             layout,
@@ -135,7 +135,7 @@ impl<'a, S: AsRef<str>, Message: 'a, Item: Clone + PartialEq + 'static>
             self.on_selected.as_ref(),
             self.selections,
             || tree.state.downcast_mut::<State<Item>>(),
-        )
+        );
     }
 
     fn mouse_interaction(
@@ -183,8 +183,9 @@ impl<'a, S: AsRef<str>, Message: 'a, Item: Clone + PartialEq + 'static>
     fn overlay<'b>(
         &'b mut self,
         tree: &'b mut Tree,
-        layout: Layout<'_>,
+        layout: Layout<'b>,
         renderer: &crate::Renderer,
+        _viewport: &Rectangle,
         translation: Vector,
     ) -> Option<overlay::Element<'b, Message, crate::Theme, crate::Renderer>> {
         let state = tree.state.downcast_mut::<State<Item>>();
@@ -275,8 +276,8 @@ pub fn layout(
                     size: iced::Pixels(text_size),
                     line_height: text_line_height,
                     font: font.unwrap_or_else(crate::font::default),
-                    horizontal_alignment: alignment::Horizontal::Left,
-                    vertical_alignment: alignment::Vertical::Top,
+                    align_x: text::Alignment::Left,
+                    align_y: alignment::Vertical::Top,
                     shaping: text::Shaping::Advanced,
                     wrapping: text::Wrapping::default(),
                     ellipsize: text::Ellipsize::default(),
@@ -314,7 +315,7 @@ pub fn update<'a, S: AsRef<str>, Message, Item: Clone + PartialEq + 'static + 'a
     on_selected: &dyn Fn(Item) -> Message,
     selections: &super::Model<S, Item>,
     state: impl FnOnce() -> &'a mut State<Item>,
-) -> event::Status {
+) {
     match event {
         Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
         | Event::Touch(touch::Event::FingerPressed { .. }) => {
@@ -325,14 +326,12 @@ pub fn update<'a, S: AsRef<str>, Message, Item: Clone + PartialEq + 'static + 'a
                 // bounds or on the drop-down, either way we close the overlay.
                 state.is_open = false;
 
-                event::Status::Captured
+                shell.capture_event();
             } else if cursor.is_over(layout.bounds()) {
                 state.is_open = true;
                 state.hovered_option = selections.selected.clone();
 
-                event::Status::Captured
-            } else {
-                event::Status::Ignored
+                shell.capture_event();
             }
         }
         Event::Mouse(mouse::Event::WheelScrolled {
@@ -348,19 +347,15 @@ pub fn update<'a, S: AsRef<str>, Message, Item: Clone + PartialEq + 'static + 'a
                     shell.publish((on_selected)(option.1.clone()));
                 }
 
-                event::Status::Captured
-            } else {
-                event::Status::Ignored
+                shell.capture_event();
             }
         }
         Event::Keyboard(keyboard::Event::ModifiersChanged(modifiers)) => {
             let state = state();
 
             state.keyboard_modifiers = *modifiers;
-
-            event::Status::Ignored
         }
-        _ => event::Status::Ignored,
+        _ => {}
     }
 }
 
@@ -420,8 +415,8 @@ pub fn overlay<'a, S: AsRef<str>, Message: 'a, Item: Clone + PartialEq + 'static
                         size: iced::Pixels(text_size),
                         line_height,
                         font: font.unwrap_or_else(crate::font::default),
-                        horizontal_alignment: alignment::Horizontal::Left,
-                        vertical_alignment: alignment::Vertical::Top,
+                        align_x: text::Alignment::Left,
+                        align_y: alignment::Vertical::Top,
                         shaping: text::Shaping::Advanced,
                         wrapping: text::Wrapping::default(),
                         ellipsize: text::Ellipsize::default(),
@@ -430,7 +425,7 @@ pub fn overlay<'a, S: AsRef<str>, Message: 'a, Item: Clone + PartialEq + 'static
                 };
 
             let mut desc_count = 0;
-            padding.horizontal().mul_add(
+            padding.x().mul_add(
                 2.0,
                 selections
                     .elements()
@@ -517,22 +512,20 @@ pub fn draw<'a, S, Item: Clone + PartialEq + 'static>(
             bounds,
             border: style.border,
             shadow: Shadow::default(),
+            snap: true,
         },
         style.background,
     );
 
     if let Some(handle) = state.icon.as_ref() {
         let svg_handle = iced_core::Svg::new(handle.clone()).color(style.text_color);
-        svg::Renderer::draw_svg(
-            renderer,
-            svg_handle,
-            Rectangle {
-                x: bounds.x + bounds.width - gap - 16.0,
-                y: bounds.center_y() - 8.0,
-                width: 16.0,
-                height: 16.0,
-            },
-        );
+        let svg_bounds = Rectangle {
+            x: bounds.x + bounds.width - gap - 16.0,
+            y: bounds.center_y() - 8.0,
+            width: 16.0,
+            height: 16.0,
+        };
+        svg::Renderer::draw_svg(renderer, svg_handle, svg_bounds, svg_bounds);
     }
 
     if let Some(content) = selected.map(AsRef::as_ref) {
@@ -541,7 +534,7 @@ pub fn draw<'a, S, Item: Clone + PartialEq + 'static>(
         let bounds = Rectangle {
             x: bounds.x + padding.left,
             y: bounds.center_y(),
-            width: bounds.width - padding.horizontal(),
+            width: bounds.width - padding.x(),
             height: f32::from(text_line_height.to_absolute(Pixels(text_size))),
         };
 
@@ -553,8 +546,8 @@ pub fn draw<'a, S, Item: Clone + PartialEq + 'static>(
                 line_height: text_line_height,
                 font,
                 bounds: bounds.size(),
-                horizontal_alignment: alignment::Horizontal::Left,
-                vertical_alignment: alignment::Vertical::Center,
+                align_x: text::Alignment::Left,
+                align_y: alignment::Vertical::Center,
                 shaping: text::Shaping::Advanced,
                 wrapping: text::Wrapping::default(),
                 ellipsize: text::Ellipsize::default(),

src/widget/dropdown/operation.rs

@@ -11,62 +11,62 @@ pub trait Dropdown {
     fn open(&mut self);
 }
 
-/// Produces a [`Task`] that closes a [`Dropdown`] popup.
-pub fn close<T>(id: Id) -> impl Operation<T> {
-    struct Close(Id);
+// /// Produces a [`Task`] that closes a [`Dropdown`] popup.
+// pub fn close<T>(id: Id) -> impl Operation<T> {
+//     struct Close(Id);
 
-    impl<T> Operation<T> for Close {
-        fn custom(&mut self, state: &mut dyn std::any::Any, id: Option<&Id>) {
-            if id.map_or(true, |id| id != &self.0) {
-                return;
-            }
+//     impl<T> Operation<T> for Close {
+//         fn custom(&mut self, state: &mut dyn std::any::Any, id: Option<&Id>) {
+//             if id.map_or(true, |id| id != &self.0) {
+//                 return;
+//             }
 
-            let Some(state) = state.downcast_mut::<State>() else {
-                return;
-            };
+//             let Some(state) = state.downcast_mut::<State>() else {
+//                 return;
+//             };
 
-            state.close();
-        }
+//             state.close();
+//         }
 
-        fn container(
-            &mut self,
-            _id: Option<&Id>,
-            _bounds: Rectangle,
-            operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
-        ) {
-            operate_on_children(self)
-        }
-    }
+//         fn container(
+//             &mut self,
+//             _id: Option<&Id>,
+//             _bounds: Rectangle,
+//             operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
+//         ) {
+//             operate_on_children(self)
+//         }
+//     }
 
-    Close(id)
-}
+//     Close(id)
+// }
 
-/// Produces a [`Task`] that opens a [`Dropdown`] popup.
-pub fn open<T>(id: Id) -> impl Operation<T> {
-    struct Open(Id);
+// /// Produces a [`Task`] that opens a [`Dropdown`] popup.
+// pub fn open<T>(id: Id) -> impl Operation<T> {
+//     struct Open(Id);
 
-    impl<T> Operation<T> for Open {
-        fn custom(&mut self, state: &mut dyn std::any::Any, id: Option<&Id>) {
-            if id.map_or(true, |id| id != &self.0) {
-                return;
-            }
+//     impl<T> Operation<T> for Open {
+//         fn custom(&mut self, state: &mut dyn std::any::Any, id: Option<&Id>) {
+//             if id.map_or(true, |id| id != &self.0) {
+//                 return;
+//             }
 
-            let Some(state) = state.downcast_mut::<State>() else {
-                return;
-            };
+//             let Some(state) = state.downcast_mut::<State>() else {
+//                 return;
+//             };
 
-            state.open();
-        }
+//             state.open();
+//         }
 
-        fn container(
-            &mut self,
-            _id: Option<&Id>,
-            _bounds: Rectangle,
-            operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
-        ) {
-            operate_on_children(self)
-        }
-    }
+//         fn container(
+//             &mut self,
+//             _id: Option<&Id>,
+//             _bounds: Rectangle,
+//             operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
+//         ) {
+//             operate_on_children(self)
+//         }
+//     }
 
-    Open(id)
-}
+//     Open(id)
+// }

src/widget/dropdown/widget.rs

@@ -60,7 +60,7 @@ where
     action_map: Option<Arc<dyn Fn(Message) -> AppMessage + 'static + Send + Sync>>,
     #[setters(strip_option)]
     window_id: Option<window::Id>,
-    #[cfg(all(feature = "winit", feature = "wayland"))]
+    #[cfg(all(feature = "winit", feature = "wayland", target_os = "linux"))]
     positioner: iced_runtime::platform_specific::wayland::popup::SctkPositioner,
 }
 
@@ -96,14 +96,14 @@ where
             text_line_height: text::LineHeight::Relative(1.2),
             font: None,
             window_id: None,
-            #[cfg(all(feature = "winit", feature = "wayland"))]
+            #[cfg(all(feature = "winit", feature = "wayland", target_os = "linux"))]
             positioner: iced_runtime::platform_specific::wayland::popup::SctkPositioner::default(),
             on_surface_action: None,
             action_map: None,
         }
     }
 
-    #[cfg(all(feature = "winit", feature = "wayland"))]
+    #[cfg(all(feature = "winit", feature = "wayland", target_os = "linux"))]
     /// Handle dropdown requests for popup creation.
     /// Intended to be used with [`crate::app::message::get_popup`]
     pub fn with_popup<NewAppMessage>(
@@ -154,7 +154,7 @@ where
         self
     }
 
-    #[cfg(all(feature = "winit", feature = "wayland"))]
+    #[cfg(all(feature = "winit", feature = "wayland", target_os = "linux"))]
     pub fn with_positioner(
         mut self,
         positioner: iced_runtime::platform_specific::wayland::popup::SctkPositioner,
@@ -203,13 +203,13 @@ where
             state.hashes[i] = text_hash;
             state.selections[i].update(Text {
                 content: selection.as_ref(),
-                bounds: Size::INFINITY,
+                bounds: Size::INFINITE,
                 // TODO use the renderer default size
                 size: iced::Pixels(self.text_size.unwrap_or(14.0)),
                 line_height: self.text_line_height,
                 font: self.font.unwrap_or_else(crate::font::default),
-                horizontal_alignment: alignment::Horizontal::Left,
-                vertical_alignment: alignment::Vertical::Top,
+                align_x: text::Alignment::Left,
+                align_y: alignment::Vertical::Top,
                 shaping: text::Shaping::Advanced,
                 wrapping: text::Wrapping::default(),
                 ellipsize: text::Ellipsize::default(),
@@ -227,7 +227,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &crate::Renderer,
         limits: &layout::Limits,
@@ -252,23 +252,23 @@ where
         )
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         _renderer: &crate::Renderer,
         _clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         _viewport: &Rectangle,
-    ) -> event::Status {
+    ) {
         update::<S, Message, AppMessage>(
             &event,
             layout,
             cursor,
             shell,
-            #[cfg(all(feature = "winit", feature = "wayland"))]
+            #[cfg(all(feature = "winit", feature = "wayland", target_os = "linux"))]
             self.positioner.clone(),
             self.on_selected.clone(),
             self.selected,
@@ -327,24 +327,26 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         _layout: Layout<'_>,
         _renderer: &crate::Renderer,
         operation: &mut dyn iced_core::widget::Operation,
     ) {
-        let state = tree.state.downcast_mut::<State>();
-        operation.custom(state, self.id.as_ref());
+        // TODO: double check operation handling
+        // let state = tree.state.downcast_mut::<State>();
+        // operation.custom(state, self.id.as_ref());
     }
 
     fn overlay<'b>(
         &'b mut self,
         tree: &'b mut Tree,
-        layout: Layout<'_>,
+        layout: Layout<'b>,
         renderer: &crate::Renderer,
+        viewport: &Rectangle,
         translation: Vector,
     ) -> Option<overlay::Element<'b, Message, crate::Theme, crate::Renderer>> {
-        #[cfg(all(feature = "winit", feature = "wayland"))]
+        #[cfg(all(feature = "winit", feature = "wayland", target_os = "linux"))]
         if self.window_id.is_some() || self.on_surface_action.is_some() {
             return None;
         }
@@ -469,24 +471,38 @@ pub fn layout(
     let max_width = match width {
         Length::Shrink => {
             let measure = move |(label, paragraph): (_, Option<&mut crate::Plain>)| -> f32 {
-                let text = Text {
-                    content: label,
-                    bounds: Size::new(f32::MAX, f32::MAX),
-                    size: iced::Pixels(text_size),
-                    line_height: text_line_height,
-                    font: font.unwrap_or_else(crate::font::default),
-                    horizontal_alignment: alignment::Horizontal::Left,
-                    vertical_alignment: alignment::Vertical::Top,
-                    shaping: text::Shaping::Advanced,
-                    wrapping: text::Wrapping::default(),
-                    ellipsize: text::Ellipsize::default(),
-                };
                 let paragraph = match paragraph {
                     Some(p) => {
+                        let text = Text {
+                            content: label,
+                            bounds: Size::new(f32::MAX, f32::MAX),
+                            size: iced::Pixels(text_size),
+                            line_height: text_line_height,
+                            font: font.unwrap_or_else(crate::font::default),
+                            align_x: text::Alignment::Left,
+                            align_y: alignment::Vertical::Top,
+                            shaping: text::Shaping::Advanced,
+                            wrapping: text::Wrapping::default(),
+                            ellipsize: text::Ellipsize::default(),
+                        };
                         p.update(text);
                         p
                     }
-                    None => &mut crate::Plain::new(text),
+                    None => {
+                        let text = Text {
+                            content: label.to_string(),
+                            bounds: Size::new(f32::MAX, f32::MAX),
+                            size: iced::Pixels(text_size),
+                            line_height: text_line_height,
+                            font: font.unwrap_or_else(crate::font::default),
+                            align_x: text::Alignment::Left,
+                            align_y: alignment::Vertical::Top,
+                            shaping: text::Shaping::Advanced,
+                            wrapping: text::Wrapping::default(),
+                            ellipsize: text::Ellipsize::default(),
+                        };
+                        &mut crate::Plain::new(text)
+                    }
                 };
                 paragraph.min_width().round()
             };
@@ -529,7 +545,7 @@ pub fn update<
     layout: Layout<'_>,
     cursor: mouse::Cursor,
     shell: &mut Shell<'_, Message>,
-    #[cfg(all(feature = "winit", feature = "wayland"))]
+    #[cfg(all(feature = "winit", feature = "wayland", target_os = "linux"))]
     positioner: iced_runtime::platform_specific::wayland::popup::SctkPositioner,
     on_selected: Arc<dyn Fn(usize) -> Message + Send + Sync + 'static>,
     selected: Option<usize>,
@@ -544,7 +560,7 @@ pub fn update<
     text_size: Option<f32>,
     font: Option<crate::font::Font>,
     selected_option: Option<usize>,
-) -> event::Status {
+) {
     let state = state();
 
     let open = |shell: &mut Shell<'_, Message>,
@@ -555,7 +571,7 @@ pub fn update<
         *hovered_guard = selected;
         let id = window::Id::unique();
         state.popup_id = id;
-        #[cfg(all(feature = "winit", feature = "wayland"))]
+        #[cfg(all(feature = "winit", feature = "wayland", target_os = "linux"))]
         if let Some(((on_surface_action, parent), action_map)) = on_surface_action
             .as_ref()
             .zip(_window_id)
@@ -575,7 +591,7 @@ pub fn update<
             let measure = |_label: &str, selection_paragraph: &crate::Paragraph| -> f32 {
                 selection_paragraph.min_width().round()
             };
-            let pad_width = padding.horizontal().mul_add(2.0, 16.0);
+            let pad_width = padding.x().mul_add(2.0, 16.0);
 
             let selections_width = selections
                 .iter()
@@ -642,7 +658,7 @@ pub fn update<
         state.close_operation = false;
         state.is_open.store(false, Ordering::SeqCst);
         if is_open {
-            #[cfg(all(feature = "winit", feature = "wayland"))]
+            #[cfg(all(feature = "winit", feature = "wayland", target_os = "linux"))]
             if let Some(ref on_close) = on_surface_action {
                 shell.publish(on_close(surface::action::destroy_popup(state.popup_id)));
             }
@@ -665,16 +681,14 @@ pub fn update<
                 // Event wasn't processed by overlay, so cursor was clicked either outside it's
                 // bounds or on the drop-down, either way we close the overlay.
                 state.is_open.store(false, Ordering::Relaxed);
-                #[cfg(all(feature = "winit", feature = "wayland"))]
+                #[cfg(all(feature = "winit", feature = "wayland", target_os = "linux"))]
                 if let Some(on_close) = on_surface_action {
                     shell.publish(on_close(surface::action::destroy_popup(state.popup_id)));
                 }
-                event::Status::Captured
+                shell.capture_event();
             } else if cursor.is_over(layout.bounds()) {
                 open(shell, state, on_selected);
-                event::Status::Captured
-            } else {
-                event::Status::Ignored
+                shell.capture_event();
             }
         }
         Event::Mouse(mouse::Event::WheelScrolled {
@@ -689,17 +703,13 @@ pub fn update<
                     shell.publish((on_selected)(next_index));
                 }
 
-                event::Status::Captured
-            } else {
-                event::Status::Ignored
+                shell.capture_event();
             }
         }
         Event::Keyboard(keyboard::Event::ModifiersChanged(modifiers)) => {
             state.keyboard_modifiers = *modifiers;
-
-            event::Status::Ignored
         }
-        _ => event::Status::Ignored,
+        _ => {}
     }
 }
 
@@ -716,7 +726,7 @@ pub fn mouse_interaction(layout: Layout<'_>, cursor: mouse::Cursor) -> mouse::In
     }
 }
 
-#[cfg(all(feature = "winit", feature = "wayland"))]
+#[cfg(all(feature = "winit", feature = "wayland", target_os = "linux"))]
 /// Returns the current menu widget of a [`Dropdown`].
 #[allow(clippy::too_many_arguments)]
 pub fn menu_widget<
@@ -746,7 +756,7 @@ where
         .zip(state.selections.iter())
         .map(|(label, selection)| measure(label.as_ref(), selection.raw()))
         .fold(0.0, |next, current| current.max(next));
-    let pad_width = padding.horizontal().mul_add(2.0, 16.0);
+    let pad_width = padding.x().mul_add(2.0, 16.0);
 
     let width = selections_width + gap + pad_width + icon_width;
     let is_open = state.is_open.clone();
@@ -822,7 +832,7 @@ where
                 selection_paragraph.min_width().round()
             };
 
-            let pad_width = padding.horizontal().mul_add(2.0, 16.0);
+            let pad_width = padding.x().mul_add(2.0, 16.0);
 
             let icon_width = if icons.is_empty() { 0.0 } else { 24.0 };
 
@@ -883,23 +893,20 @@ pub fn draw<'a, S>(
             bounds,
             border: style.border,
             shadow: Shadow::default(),
+            snap: true,
         },
         style.background,
     );
 
     if let Some(handle) = state.icon.clone() {
         let svg_handle = svg::Svg::new(handle).color(style.text_color);
-
-        svg::Renderer::draw_svg(
-            renderer,
-            svg_handle,
-            Rectangle {
-                x: bounds.x + bounds.width - gap - 16.0,
-                y: bounds.center_y() - 8.0,
-                width: 16.0,
-                height: 16.0,
-            },
-        );
+        let bounds = Rectangle {
+            x: bounds.x + bounds.width - gap - 16.0,
+            y: bounds.center_y() - 8.0,
+            width: 16.0,
+            height: 16.0,
+        };
+        svg::Renderer::draw_svg(renderer, svg_handle, bounds, bounds);
     }
 
     if let Some(content) = selected.map(AsRef::as_ref).or(placeholder) {
@@ -908,7 +915,7 @@ pub fn draw<'a, S>(
         let mut bounds = Rectangle {
             x: bounds.x + padding.left,
             y: bounds.center_y(),
-            width: bounds.width - padding.horizontal(),
+            width: bounds.width - padding.x(),
             height: f32::from(text_line_height.to_absolute(Pixels(text_size))),
         };
 
@@ -932,8 +939,8 @@ pub fn draw<'a, S>(
                 line_height: text_line_height,
                 font,
                 bounds: bounds.size(),
-                horizontal_alignment: alignment::Horizontal::Left,
-                vertical_alignment: alignment::Vertical::Center,
+                align_x: text::Alignment::Left,
+                align_y: alignment::Vertical::Center,
                 shaping: text::Shaping::Advanced,
                 wrapping: text::Wrapping::default(),
                 ellipsize: text::Ellipsize::default(),

src/widget/flex_row/layout.rs

@@ -15,7 +15,7 @@ use taffy::{AlignContent, TaffyTree};
 pub fn resolve<Message>(
     renderer: &Renderer,
     limits: &Limits,
-    items: &[Element<'_, Message>],
+    items: &mut [Element<'_, Message>],
     padding: Padding,
     column_spacing: f32,
     row_spacing: f32,
@@ -61,8 +61,8 @@ pub fn resolve<Message>(
         ..taffy::Style::default()
     };
 
-    for (child, tree) in items.iter().zip(tree.iter_mut()) {
-        let child_widget = child.as_widget();
+    for (child, tree) in items.iter_mut().zip(tree.iter_mut()) {
+        let child_widget = child.as_widget_mut();
         let child_node = child_widget.layout(tree, renderer, limits);
         let size = child_node.size();
 
@@ -138,7 +138,7 @@ pub fn resolve<Message>(
 
     leafs
         .into_iter()
-        .zip(items.iter())
+        .zip(items.iter_mut())
         .zip(nodes.iter_mut())
         .zip(tree)
         .for_each(|(((leaf, child), node), tree)| {
@@ -146,7 +146,7 @@ pub fn resolve<Message>(
                 return;
             };
 
-            let child_widget = child.as_widget();
+            let child_widget = child.as_widget_mut();
             let c_size = child_widget.size();
             match c_size.width {
                 Length::Fill | Length::FillPortion(_) => {
@@ -162,9 +162,14 @@ pub fn resolve<Message>(
             });
         });
 
+    let actual_height = nodes
+        .iter()
+        .map(|node| node.bounds().y + node.bounds().height)
+        .fold(0.0f32, f32::max);
+
     let size = Size {
         width: flex_layout.content_size.width,
-        height: flex_layout.content_size.height,
+        height: actual_height.max(flex_layout.content_size.height),
     };
 
     Node::with_children(size, nodes)

src/widget/flex_row/widget.rs

@@ -100,7 +100,7 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, Renderer> for FlexR
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -114,32 +114,32 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, Renderer> for FlexR
         super::layout::resolve(
             renderer,
             &limits,
-            &self.children,
+            &mut self.children,
             self.padding,
             f32::from(self.column_spacing),
             f32::from(self.row_spacing),
             self.min_item_width,
-            self.align_items,
             self.justify_items,
+            self.align_items,
             self.justify_content,
             &mut tree.children,
         )
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
         operation: &mut dyn Operation<()>,
     ) {
-        operation.container(None, layout.bounds(), &mut |operation| {
+        operation.traverse(&mut |operation| {
             self.children
-                .iter()
+                .iter_mut()
                 .zip(&mut tree.children)
                 .zip(layout.children())
                 .for_each(|((child, state), c_layout)| {
-                    child.as_widget().operate(
+                    child.as_widget_mut().operate(
                         state,
                         c_layout.with_virtual_offset(layout.virtual_offset()),
                         renderer,
@@ -149,34 +149,34 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, Renderer> for FlexR
         });
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         viewport: &Rectangle,
-    ) -> event::Status {
-        self.children
+    ) {
+        for ((child, state), c_layout) in self
+            .children
             .iter_mut()
             .zip(&mut tree.children)
             .zip(layout.children())
-            .map(|((child, state), c_layout)| {
-                child.as_widget_mut().on_event(
-                    state,
-                    event.clone(),
-                    c_layout.with_virtual_offset(layout.virtual_offset()),
-                    cursor,
-                    renderer,
-                    clipboard,
-                    shell,
-                    viewport,
-                )
-            })
-            .fold(event::Status::Ignored, event::Status::merge)
+        {
+            child.as_widget_mut().update(
+                state,
+                event,
+                c_layout.with_virtual_offset(layout.virtual_offset()),
+                cursor,
+                renderer,
+                clipboard,
+                shell,
+                viewport,
+            );
+        }
     }
 
     fn mouse_interaction(
@@ -235,11 +235,19 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, Renderer> for FlexR
     fn overlay<'b>(
         &'b mut self,
         tree: &'b mut Tree,
-        layout: Layout<'_>,
+        layout: Layout<'b>,
         renderer: &Renderer,
+        viewport: &Rectangle,
         translation: Vector,
     ) -> Option<overlay::Element<'b, Message, crate::Theme, Renderer>> {
-        overlay::from_children(&mut self.children, tree, layout, renderer, translation)
+        overlay::from_children(
+            &mut self.children,
+            tree,
+            layout,
+            renderer,
+            viewport,
+            translation,
+        )
     }
 
     #[cfg(feature = "a11y")]

src/widget/frames.rs

@@ -8,15 +8,16 @@ use std::path::Path;
 use std::time::{Duration, Instant};
 
 use ::image as image_rs;
+use iced::Task;
+use iced::mouse;
 use iced_core::image::Renderer as ImageRenderer;
 use iced_core::mouse::Cursor;
 use iced_core::widget::{Tree, tree};
 use iced_core::{
-    Clipboard, ContentFit, Element, Event, Layout, Length, Rectangle, Shell, Size, Vector, Widget,
-    event, layout, renderer, window,
+    Clipboard, ContentFit, Element, Event, Layout, Length, Rectangle, Rotation, Shell, Size,
+    Widget, event, layout, renderer, window,
 };
-use iced_runtime::Command;
-use iced_widget::image::{self, Handle};
+use iced_widget::image::{self, FilterMethod, Handle};
 use image_rs::AnimationDecoder;
 use image_rs::codecs::gif::GifDecoder;
 use image_rs::codecs::png::PngDecoder;
@@ -27,7 +28,7 @@ use iced_futures::futures::{AsyncRead, AsyncReadExt};
 #[cfg(feature = "tokio")]
 use tokio::io::{AsyncRead, AsyncReadExt};
 
-use super::icon::load_icon;
+use crate::widget::icon;
 
 #[must_use]
 /// Creates a new [`AnimatedImage`] with the given [`animated_image::Frames`]
@@ -74,13 +75,13 @@ impl Frames {
         size: u16,
         theme: Option<&str>,
         default_fallbacks: bool,
-    ) -> Command<Result<Frames, Error>> {
+    ) -> Task<Result<Frames, Error>> {
         let mut name_path_buffer = None;
-        if let Some(path) = load_icon(name, size, theme) {
+        if let Some(path) = icon::Named::new(name).size(size).path() {
             name_path_buffer = Some(path);
         } else if default_fallbacks {
             for name in name.rmatch_indices('-').map(|(pos, _)| &name[..pos]) {
-                if let Some(path) = load_icon(name, size, theme) {
+                if let Some(path) = icon::Named::new(name).size(size).path() {
                     name_path_buffer = Some(path);
                     break;
                 }
@@ -90,14 +91,14 @@ impl Frames {
         if let Some(name_path_buffer) = name_path_buffer {
             Self::load_from_path(name_path_buffer)
         } else {
-            Command::perform(async { Err(Error::Missing) }, std::convert::identity)
+            Task::perform(async { Err(Error::Missing) }, std::convert::identity)
         }
     }
 
     /// Load [`Frames`] from the supplied path
-    pub fn load_from_path(path: impl AsRef<Path>) -> Command<Result<Frames, Error>> {
+    pub fn load_from_path(path: impl AsRef<Path>) -> Task<Result<Frames, Error>> {
         #[inline(never)]
-        fn inner(path: &Path) -> Command<Result<Frames, Error>> {
+        fn inner(path: &Path) -> Task<Result<Frames, Error>> {
             #[cfg(feature = "tokio")]
             use tokio::fs::File;
             #[cfg(feature = "tokio")]
@@ -108,7 +109,7 @@ impl Frames {
             #[cfg(not(feature = "tokio"))]
             use iced_futures::futures::io::BufReader;
 
-            let path = path.as_ref().to_path_buf();
+            let path = path.to_path_buf();
 
             let f = async move {
                 let image_type = match &path.extension() {
@@ -119,10 +120,10 @@ impl Frames {
                 };
                 let reader = BufReader::new(File::open(path).await?);
 
-                Self::from_reader(reader, image_type).await
+                Frames::from_reader(reader, image_type).await
             };
 
-            Command::perform(f, std::convert::identity)
+            Task::perform(f, std::convert::identity)
         }
 
         inner(path.as_ref())
@@ -145,7 +146,7 @@ impl Frames {
 
         match image_type {
             ImageType::Gif => Self::from_decoder(GifDecoder::new(io::Cursor::new(bytes))?),
-            ImageType::Apng => Self::from_decoder(PngDecoder::new(io::Cursor::new(bytes))?.apng()),
+            ImageType::Apng => Self::from_decoder(PngDecoder::new(io::Cursor::new(bytes))?.apng()?),
             ImageType::WebP => Self::from_decoder(WebPDecoder::new(io::Cursor::new(bytes))?),
         }
     }
@@ -167,10 +168,10 @@ impl Frames {
         let first = frames.first().cloned().unwrap();
         let total_bytes = frames
             .iter()
-            .map(|f| match f.handle.data() {
-                iced_core::image::Data::Path(_) => 0,
-                iced_core::image::Data::Bytes(b) => b.len(),
-                iced_core::image::Data::Rgba { pixels, .. } => pixels.len(),
+            .map(|f| match &f.handle {
+                Handle::Path(..) => 0,
+                Handle::Bytes(_, b) => b.len(),
+                Handle::Rgba { pixels, .. } => pixels.len(),
             })
             .sum::<usize>()
             .try_into()
@@ -195,7 +196,7 @@ impl From<image_rs::Frame> for Frame {
 
         let delay = frame.delay().into();
 
-        let handle = image::Handle::from_pixels(width, height, frame.into_buffer().into_vec());
+        let handle = image::Handle::from_rgba(width, height, frame.into_buffer().into_vec());
 
         Self { delay, handle }
     }
@@ -278,12 +279,8 @@ impl<'a, Message, Renderer> Widget<Message, crate::Theme, Renderer> for Animated
 where
     Renderer: ImageRenderer<Handle = Handle>,
 {
-    fn width(&self) -> Length {
-        self.width
-    }
-
-    fn height(&self) -> Length {
-        self.height
+    fn size(&self) -> Size<Length> {
+        Size::new(self.width.into(), self.height.into())
     }
 
     fn tag(&self) -> tree::Tag {
@@ -315,30 +312,40 @@ where
         }
     }
 
-    fn layout(&self, renderer: &Renderer, limits: &layout::Limits) -> layout::Node {
+    fn layout(
+        &mut self,
+        tree: &mut Tree,
+        renderer: &Renderer,
+        limits: &layout::Limits,
+    ) -> layout::Node {
         iced_widget::image::layout(
             renderer,
             limits,
             &self.frames.first.handle,
             self.width,
             self.height,
+            None,
             self.content_fit,
+            Rotation::default(),
+            false,
+            [0.0; 4],
         )
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
-        _layout: Layout<'_>,
-        _cursor_position: Cursor,
-        _renderer: &Renderer,
-        _clipboard: &mut dyn Clipboard,
+        event: &Event,
+        layout: Layout<'_>,
+        cursor_position: mouse::Cursor,
+        renderer: &Renderer,
+        clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
-    ) -> event::Status {
+        viewport: &Rectangle,
+    ) {
         let state = tree.state.downcast_mut::<State>();
 
-        if let Event::Window(_, window::Event::RedrawRequested(now)) = event {
+        if let Event::Window(window::Event::RedrawRequested(now)) = event {
             let elapsed = now.duration_since(state.current.started);
 
             if elapsed > state.current.frame.delay {
@@ -346,15 +353,14 @@ where
 
                 state.current = self.frames.frames[state.index].clone().into();
 
-                shell.request_redraw(window::RedrawRequest::At(now + state.current.frame.delay));
+                shell
+                    .request_redraw_at(window::RedrawRequest::At(*now + state.current.frame.delay));
             } else {
                 let remaining = state.current.frame.delay - elapsed;
 
-                shell.request_redraw(window::RedrawRequest::At(now + remaining));
+                shell.request_redraw_at(window::RedrawRequest::At(*now + remaining));
             }
         }
-
-        event::Status::Ignored
     }
 
     fn draw(
@@ -369,37 +375,18 @@ where
     ) {
         let state = tree.state.downcast_ref::<State>();
 
-        // Pulled from iced_native::widget::<Image as Widget>::draw
-        //
-        // TODO: export iced_native::widget::image::draw as standalone function
-        {
-            let Size { width, height } = renderer.dimensions(&state.current.frame.handle);
-            let image_size = Size::new(width as f32, height as f32);
-
-            let bounds = layout.bounds();
-            let adjusted_fit = self.content_fit.fit(image_size, bounds.size());
-
-            let render = |renderer: &mut Renderer| {
-                let offset = Vector::new(
-                    (bounds.width - adjusted_fit.width).max(0.0) / 2.0,
-                    (bounds.height - adjusted_fit.height).max(0.0) / 2.0,
-                );
-
-                let drawing_bounds = Rectangle {
-                    width: adjusted_fit.width,
-                    height: adjusted_fit.height,
-                    ..bounds
-                };
-
-                renderer.draw(state.current.frame.handle.clone(), drawing_bounds + offset);
-            };
-
-            if adjusted_fit.width > bounds.width || adjusted_fit.height > bounds.height {
-                renderer.with_layer(bounds, render);
-            } else {
-                render(renderer);
-            }
-        }
+        iced_widget::image::draw(
+            renderer,
+            layout,
+            &state.current.frame.handle,
+            None,
+            iced_core::border::Radius::default(),
+            self.content_fit,
+            FilterMethod::default(),
+            Rotation::default(),
+            1.0,
+            1.0,
+        );
     }
 }
 

src/widget/grid/layout.rs

@@ -17,7 +17,7 @@ use taffy::{AlignContent, TaffyTree};
 pub fn resolve<Message>(
     renderer: &Renderer,
     limits: &Limits,
-    items: &[Element<'_, Message>],
+    items: &mut [Element<'_, Message>],
     assignments: &[Assignment],
     width: Length,
     height: Length,
@@ -37,9 +37,13 @@ pub fn resolve<Message>(
     let mut taffy = TaffyTree::<()>::with_capacity(items.len() + 1);
 
     // Attach widgets as child nodes.
-    for ((child, assignment), tree) in items.iter().zip(assignments.iter()).zip(tree.iter_mut()) {
+    for ((child, assignment), tree) in items
+        .iter_mut()
+        .zip(assignments.iter())
+        .zip(tree.iter_mut())
+    {
         // Calculate the dimensions of the item.
-        let child_widget = child.as_widget();
+        let child_widget = child.as_widget_mut();
         let child_node = child_widget.layout(tree, renderer, limits);
         let size = child_node.size();
 
@@ -172,12 +176,12 @@ pub fn resolve<Message>(
 
     for (((leaf, child), node), tree) in leafs
         .into_iter()
-        .zip(items.iter())
+        .zip(items.iter_mut())
         .zip(nodes.iter_mut())
         .zip(tree)
     {
         if let Ok(leaf_layout) = taffy.layout(leaf) {
-            let child_widget = child.as_widget();
+            let child_widget = child.as_widget_mut();
             let c_size = child_widget.size();
             match c_size.width {
                 Length::Fill | Length::FillPortion(_) => {

src/widget/grid/widget.rs

@@ -127,7 +127,7 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, Renderer> for Grid<
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -141,7 +141,7 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, Renderer> for Grid<
         super::layout::resolve(
             renderer,
             &limits,
-            &self.children,
+            &mut self.children,
             &self.assignments,
             self.width,
             self.height,
@@ -156,19 +156,19 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, Renderer> for Grid<
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
         operation: &mut dyn Operation<()>,
     ) {
-        operation.container(None, layout.bounds(), &mut |operation| {
+        operation.traverse(&mut |operation| {
             self.children
-                .iter()
+                .iter_mut()
                 .zip(&mut tree.children)
                 .zip(layout.children())
                 .for_each(|((child, state), c_layout)| {
-                    child.as_widget().operate(
+                    child.as_widget_mut().operate(
                         state,
                         c_layout.with_virtual_offset(layout.virtual_offset()),
                         renderer,
@@ -178,34 +178,34 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, Renderer> for Grid<
         });
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         renderer: &Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         viewport: &Rectangle,
-    ) -> event::Status {
-        self.children
+    ) {
+        for ((child, state), c_layout) in self
+            .children
             .iter_mut()
             .zip(&mut tree.children)
             .zip(layout.children())
-            .map(|((child, state), c_layout)| {
-                child.as_widget_mut().on_event(
-                    state,
-                    event.clone(),
-                    c_layout.with_virtual_offset(layout.virtual_offset()),
-                    cursor,
-                    renderer,
-                    clipboard,
-                    shell,
-                    viewport,
-                )
-            })
-            .fold(event::Status::Ignored, event::Status::merge)
+        {
+            child.as_widget_mut().update(
+                state,
+                event,
+                c_layout.with_virtual_offset(layout.virtual_offset()),
+                cursor,
+                renderer,
+                clipboard,
+                shell,
+                viewport,
+            );
+        }
     }
 
     fn mouse_interaction(
@@ -264,11 +264,19 @@ impl<Message: 'static + Clone> Widget<Message, crate::Theme, Renderer> for Grid<
     fn overlay<'b>(
         &'b mut self,
         tree: &'b mut Tree,
-        layout: Layout<'_>,
+        layout: Layout<'b>,
         renderer: &Renderer,
+        viewport: &Rectangle,
         translation: Vector,
     ) -> Option<overlay::Element<'b, Message, crate::Theme, Renderer>> {
-        overlay::from_children(&mut self.children, tree, layout, renderer, translation)
+        overlay::from_children(
+            &mut self.children,
+            tree,
+            layout,
+            renderer,
+            viewport,
+            translation,
+        )
     }
 
     #[cfg(feature = "a11y")]

src/widget/header_bar.rs

@@ -5,9 +5,8 @@ use crate::cosmic_theme::{Density, Spacing};
 use crate::{Element, theme, widget};
 use apply::Apply;
 use derive_setters::Setters;
-use iced::Length;
-use iced_core::{Vector, Widget, widget::tree};
-use std::{borrow::Cow, cmp};
+use iced_core::{Length, Size, Vector, Widget, layout, text, widget::tree};
+use std::borrow::Cow;
 
 #[must_use]
 pub fn header_bar<'a, Message>() -> HeaderBar<'a, Message> {
@@ -27,7 +26,6 @@ pub fn header_bar<'a, Message>() -> HeaderBar<'a, Message> {
         sharp_corners: false,
         is_ssd: false,
         on_double_click: None,
-        is_condensed: false,
         transparent: false,
     }
 }
@@ -91,9 +89,6 @@ pub struct HeaderBar<'a, Message> {
     /// HeaderBar used for server-side decorations
     is_ssd: bool,
 
-    /// Whether the headerbar should be compact
-    is_condensed: bool,
-
     /// Whether the headerbar should be transparent
     transparent: bool,
 }
@@ -126,48 +121,116 @@ impl<'a, Message: Clone + 'static> HeaderBar<'a, Message> {
         self.end.push(widget.into());
         self
     }
-
-    /// Build the widget
-    #[must_use]
-    #[inline]
-    pub fn build(self) -> HeaderBarWidget<'a, Message> {
-        HeaderBarWidget {
-            header_bar_inner: self.view(),
-        }
-    }
 }
 
 pub struct HeaderBarWidget<'a, Message> {
-    header_bar_inner: Element<'a, Message>,
+    start: Element<'a, Message>,
+    center: Option<Element<'a, Message>>,
+    end: Element<'a, Message>,
 }
 
-impl<Message: Clone + 'static> Widget<Message, crate::Theme, crate::Renderer>
-    for HeaderBarWidget<'_, Message>
+impl<'a, Message> HeaderBarWidget<'a, Message> {
+    pub fn new(
+        start: Element<'a, Message>,
+        center: Option<Element<'a, Message>>,
+        end: Element<'a, Message>,
+    ) -> Self {
+        Self { start, center, end }
+    }
+
+    fn elems(&self) -> impl Iterator<Item = &Element<'a, Message>> {
+        std::iter::once(&self.start)
+            .chain(std::iter::once(&self.end))
+            .chain(self.center.as_ref())
+    }
+
+    fn elems_mut(&mut self) -> impl Iterator<Item = &mut Element<'a, Message>> {
+        std::iter::once(&mut self.start)
+            .chain(std::iter::once(&mut self.end))
+            .chain(self.center.as_mut())
+    }
+}
+
+impl<'a, Message: Clone + 'static> Widget<Message, crate::Theme, crate::Renderer>
+    for HeaderBarWidget<'a, Message>
 {
     fn diff(&mut self, tree: &mut tree::Tree) {
-        tree.diff_children(&mut [&mut self.header_bar_inner]);
+        if let Some(center) = &mut self.center {
+            tree.diff_children(&mut [&mut self.start, &mut self.end, center]);
+        } else {
+            tree.diff_children(&mut [&mut self.start, &mut self.end]);
+        }
     }
 
     fn children(&self) -> Vec<tree::Tree> {
-        vec![tree::Tree::new(&self.header_bar_inner)]
+        self.elems().map(tree::Tree::new).collect()
     }
 
-    fn size(&self) -> iced_core::Size<Length> {
-        self.header_bar_inner.as_widget().size()
+    fn size(&self) -> Size<Length> {
+        Size {
+            width: Length::Fill,
+            height: Length::Shrink,
+        }
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut tree::Tree,
         renderer: &crate::Renderer,
-        limits: &iced_core::layout::Limits,
-    ) -> iced_core::layout::Node {
-        let child_tree = &mut tree.children[0];
-        let child = self
-            .header_bar_inner
-            .as_widget()
-            .layout(child_tree, renderer, limits);
-        iced_core::layout::Node::with_children(child.size(), vec![child])
+        limits: &layout::Limits,
+    ) -> layout::Node {
+        let width = limits.max().width;
+        let height = limits.max().height;
+        let gap = 8.0;
+
+        let end_node =
+            self.end
+                .as_widget_mut()
+                .layout(&mut tree.children[1], renderer, &limits.loose());
+        let end_width = end_node.size().width;
+
+        let start_available = (width - end_width - gap).max(0.0);
+        let start_node = self.start.as_widget_mut().layout(
+            &mut tree.children[0],
+            renderer,
+            &layout::Limits::new(Size::ZERO, Size::new(start_available, height)),
+        );
+        let start_width = start_node.size().width;
+
+        let vcenter = |node: layout::Node, x: f32| -> layout::Node {
+            let dy = ((height - node.size().height) / 2.0).max(0.0);
+            node.translate(Vector::new(x, dy))
+        };
+
+        let mut child_nodes = Vec::with_capacity(3);
+        child_nodes.push(vcenter(start_node, 0.0));
+        child_nodes.push(vcenter(end_node, width - end_width));
+
+        if let Some(center) = &mut self.center {
+            let slot_start = start_width + gap;
+            let slot_end = (width - end_width - gap).max(slot_start);
+            let slot_width = slot_end - slot_start;
+            // this instead of `node.size().width` prevents center jitter as text ellipsizes
+            let natural_width = center
+                .as_widget_mut()
+                .layout(&mut tree.children[2], renderer, &limits.loose())
+                .size()
+                .width;
+
+            let node = center.as_widget_mut().layout(
+                &mut tree.children[2],
+                renderer,
+                &layout::Limits::new(Size::ZERO, Size::new(slot_width, height)),
+            );
+
+            let ideal_x = (width - natural_width) / 2.0;
+            let max_x = (width - end_width - gap - natural_width).max(slot_start);
+            let center_x = ideal_x.clamp(slot_start, max_x);
+
+            child_nodes.push(vcenter(node, center_x))
+        }
+
+        layout::Node::with_children(Size::new(width, height), child_nodes)
     }
 
     fn draw(
@@ -180,42 +243,33 @@ impl<Message: Clone + 'static> Widget<Message, crate::Theme, crate::Renderer>
         cursor: iced_core::mouse::Cursor,
         viewport: &iced_core::Rectangle,
     ) {
-        let layout_children = layout.children().next().unwrap();
-        let state_children = &tree.children[0];
-        self.header_bar_inner.as_widget().draw(
-            state_children,
-            renderer,
-            theme,
-            style,
-            layout_children,
-            cursor,
-            viewport,
-        );
+        self.elems()
+            .zip(&tree.children)
+            .zip(layout.children())
+            .for_each(|((e, s), l)| {
+                e.as_widget()
+                    .draw(s, renderer, theme, style, l, cursor, viewport);
+            });
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         state: &mut tree::Tree,
-        event: iced_core::Event,
+        event: &iced_core::Event,
         layout: iced_core::Layout<'_>,
         cursor: iced_core::mouse::Cursor,
         renderer: &crate::Renderer,
         clipboard: &mut dyn iced_core::Clipboard,
         shell: &mut iced_core::Shell<'_, Message>,
         viewport: &iced_core::Rectangle,
-    ) -> iced_core::event::Status {
-        let child_state = &mut state.children[0];
-        let child_layout = layout.children().next().unwrap();
-        self.header_bar_inner.as_widget_mut().on_event(
-            child_state,
-            event,
-            child_layout,
-            cursor,
-            renderer,
-            clipboard,
-            shell,
-            viewport,
-        )
+    ) {
+        self.elems_mut()
+            .zip(&mut state.children)
+            .zip(layout.children())
+            .for_each(|((e, s), l)| {
+                e.as_widget_mut()
+                    .update(s, event, l, cursor, renderer, clipboard, shell, viewport);
+            });
     }
 
     fn mouse_interaction(
@@ -226,46 +280,47 @@ impl<Message: Clone + 'static> Widget<Message, crate::Theme, crate::Renderer>
         viewport: &iced_core::Rectangle,
         renderer: &crate::Renderer,
     ) -> iced_core::mouse::Interaction {
-        let child_tree = &state.children[0];
-        let child_layout = layout.children().next().unwrap();
-        self.header_bar_inner.as_widget().mouse_interaction(
-            child_tree,
-            child_layout,
-            cursor,
-            viewport,
-            renderer,
-        )
+        self.elems()
+            .zip(&state.children)
+            .zip(layout.children())
+            .map(|((e, s), l)| {
+                e.as_widget()
+                    .mouse_interaction(s, l, cursor, viewport, renderer)
+            })
+            .max()
+            .unwrap_or(iced_core::mouse::Interaction::None)
     }
 
     fn operate(
-        &self,
+        &mut self,
         state: &mut tree::Tree,
         layout: iced_core::Layout<'_>,
         renderer: &crate::Renderer,
         operation: &mut dyn iced_core::widget::Operation<()>,
     ) {
-        let child_tree = &mut state.children[0];
-        let child_layout = layout.children().next().unwrap();
-        self.header_bar_inner
-            .as_widget()
-            .operate(child_tree, child_layout, renderer, operation);
+        self.elems_mut()
+            .zip(&mut state.children)
+            .zip(layout.children())
+            .for_each(|((e, s), l)| {
+                e.as_widget_mut().operate(s, l, renderer, operation);
+            });
     }
 
     fn overlay<'b>(
         &'b mut self,
         state: &'b mut tree::Tree,
-        layout: iced_core::Layout<'_>,
+        layout: iced_core::Layout<'b>,
         renderer: &crate::Renderer,
+        viewport: &iced_core::Rectangle,
         translation: Vector,
     ) -> Option<iced_core::overlay::Element<'b, Message, crate::Theme, crate::Renderer>> {
-        let child_tree = &mut state.children[0];
-        let child_layout = layout.children().next().unwrap();
-        self.header_bar_inner.as_widget_mut().overlay(
-            child_tree,
-            child_layout,
-            renderer,
-            translation,
-        )
+        self.elems_mut()
+            .zip(&mut state.children)
+            .zip(layout.children())
+            .find_map(|((e, s), l)| {
+                e.as_widget_mut()
+                    .overlay(s, l, renderer, viewport, translation)
+            })
     }
 
     fn drag_destinations(
@@ -275,16 +330,13 @@ impl<Message: Clone + 'static> Widget<Message, crate::Theme, crate::Renderer>
         renderer: &crate::Renderer,
         dnd_rectangles: &mut iced_core::clipboard::DndDestinationRectangles,
     ) {
-        if let Some((child_tree, child_layout)) =
-            state.children.iter().zip(layout.children()).next()
-        {
-            self.header_bar_inner.as_widget().drag_destinations(
-                child_tree,
-                child_layout,
-                renderer,
-                dnd_rectangles,
-            );
-        }
+        self.elems()
+            .zip(&state.children)
+            .zip(layout.children())
+            .for_each(|((e, s), l)| {
+                e.as_widget()
+                    .drag_destinations(s, l, renderer, dnd_rectangles);
+            });
     }
 
     #[cfg(feature = "a11y")]
@@ -295,16 +347,22 @@ impl<Message: Clone + 'static> Widget<Message, crate::Theme, crate::Renderer>
         state: &tree::Tree,
         p: iced::mouse::Cursor,
     ) -> iced_accessibility::A11yTree {
-        let c_layout = layout.children().next().unwrap();
-        let c_state = &state.children[0];
-        self.header_bar_inner
-            .as_widget()
-            .a11y_nodes(c_layout, c_state, p)
+        iced_accessibility::A11yTree::join(
+            self.elems()
+                .zip(&state.children)
+                .zip(layout.children())
+                .map(|((e, s), l)| e.as_widget().a11y_nodes(l, s, p)),
+        )
+    }
+}
+
+impl<'a, Message: Clone + 'static> From<HeaderBarWidget<'a, Message>> for Element<'a, Message> {
+    fn from(w: HeaderBarWidget<'a, Message>) -> Self {
+        Element::new(w)
     }
 }
 
 impl<'a, Message: Clone + 'static> HeaderBar<'a, Message> {
-    #[allow(clippy::too_many_lines)]
     /// Converts the headerbar builder into an Iced element.
     pub fn view(mut self) -> Element<'a, Message> {
         let Spacing {
@@ -318,153 +376,84 @@ impl<'a, Message: Clone + 'static> HeaderBar<'a, Message> {
         let center = std::mem::take(&mut self.center);
         let mut end = std::mem::take(&mut self.end);
 
-        let window_control_cnt = self.on_close.is_some() as usize
-            + self.on_maximize.is_some() as usize
-            + self.on_minimize.is_some() as usize;
         // Also packs the window controls at the very end.
-        end.push(self.window_controls());
+        end.push(self.window_controls(space_xxs));
 
-        // Center content depending on window border
-        let padding = match self.density.unwrap_or_else(crate::config::header_size) {
-            Density::Compact => {
-                if self.maximized {
-                    [4, 8, 4, 8]
-                } else {
-                    [3, 7, 4, 7]
-                }
-            }
-            _ => {
-                if self.maximized {
-                    [8, 8, 8, 8]
-                } else {
-                    [7, 7, 8, 7]
-                }
+        let padding = if self.is_ssd {
+            [2, 8, 2, 8]
+        } else {
+            match (
+                self.density.unwrap_or_else(crate::config::header_size),
+                self.maximized, // window border handling
+            ) {
+                (Density::Compact, true) => [4, 8, 4, 8],
+                (Density::Compact, false) => [3, 7, 4, 7],
+                (_, true) => [8, 8, 8, 8],
+                (_, false) => [7, 7, 8, 7],
             }
         };
 
-        let acc_count = |v: &[Element<'a, Message>]| {
-            v.iter().fold(0, |acc, e| {
-                acc + match e.as_widget().size().width {
-                    Length::Fixed(w) if w > 30. => (w / 30.0).ceil() as usize,
-                    _ => 1,
-                }
-            })
-        };
-
-        let left_len = acc_count(&start);
-        let right_len = acc_count(&end);
-
-        let portion = ((left_len.max(right_len + window_control_cnt) as f32
-            / center.len().max(1) as f32)
-            .round() as u16)
-            .max(1);
-        let (left_portion, right_portion) =
-            if center.is_empty() && (self.title.is_empty() || self.is_condensed) {
-                let left_to_right_ratio = left_len as f32 / right_len.max(1) as f32;
-                let right_to_left_ratio = right_len as f32 / left_len.max(1) as f32;
-                if right_to_left_ratio > 2. || left_len < 1 {
-                    (1, 2)
-                } else if left_to_right_ratio > 2. || right_len < 1 {
-                    (2, 1)
-                } else {
-                    (left_len as u16, (right_len + window_control_cnt) as u16)
-                }
-            } else {
-                (portion, portion)
-            };
-        let title_portion = cmp::max(left_portion, right_portion) * 2;
-        // Creates the headerbar widget.
-        let mut widget = widget::row::with_capacity(3)
-            // If elements exist in the start region, append them here.
-            .push(
-                widget::row::with_children(start)
+        let start = widget::row::with_children(start)
+            .spacing(space_xxxs)
+            .align_y(iced::Alignment::Center)
+            .into();
+        let center = if !center.is_empty() {
+            Some(
+                widget::row::with_children(center)
                     .spacing(space_xxxs)
                     .align_y(iced::Alignment::Center)
-                    .apply(widget::container)
-                    .align_x(iced::Alignment::Start)
-                    .width(Length::FillPortion(left_portion)),
+                    .into(),
             )
-            // If elements exist in the center region, use them here.
-            // This will otherwise use the title as a widget if a title was defined.
-            .push_maybe(if !center.is_empty() {
-                Some(
-                    widget::row::with_children(center)
-                        .spacing(space_xxxs)
-                        .align_y(iced::Alignment::Center)
-                        .apply(widget::container)
-                        .center_x(Length::Fill)
-                        .into(),
-                )
-            } else if !self.title.is_empty() && !self.is_condensed {
-                Some(self.title_widget(title_portion))
-            } else {
-                None
-            })
-            .push(
-                widget::row::with_children(end)
-                    .spacing(space_xxs)
-                    .align_y(iced::Alignment::Center)
-                    .apply(widget::container)
-                    .align_x(iced::Alignment::End)
-                    .width(Length::FillPortion(right_portion)),
+        } else if !self.title.is_empty() {
+            Some(
+                widget::text::heading(self.title)
+                    .wrapping(text::Wrapping::None)
+                    .ellipsize(text::Ellipsize::End(text::EllipsizeHeightLimit::Lines(1)))
+                    .into(),
             )
+        } else {
+            None
+        };
+        let end = widget::row::with_children(end)
+            .spacing(space_xxs)
             .align_y(iced::Alignment::Center)
-            .height(Length::Fixed(32.0 + padding[0] as f32 + padding[2] as f32))
-            .padding(if self.is_ssd { [0, 8, 0, 8] } else { padding })
-            .spacing(8)
+            .into();
+
+        let mut widget = HeaderBarWidget::new(start, center, end)
             .apply(widget::container)
-            .class(crate::theme::Container::HeaderBar {
+            .class(theme::Container::HeaderBar {
                 focused: self.focused,
                 sharp_corners: self.sharp_corners,
                 transparent: self.transparent,
             })
-            .center_y(Length::Shrink)
+            .height(Length::Fixed(32.0 + padding[0] as f32 + padding[2] as f32))
+            .padding(padding)
             .apply(widget::mouse_area);
 
-        // Assigns a message to emit when the headerbar is dragged.
-        if let Some(message) = self.on_drag.clone() {
+        if let Some(message) = self.on_drag {
             widget = widget.on_drag(message);
         }
-
-        // Assigns a message to emit when the headerbar is double-clicked.
-        if let Some(message) = self.on_maximize.clone() {
+        if let Some(message) = self.on_maximize {
             widget = widget.on_release(message);
         }
-        if let Some(message) = self.on_double_click.clone() {
+        if let Some(message) = self.on_double_click {
             widget = widget.on_double_press(message);
         }
-        if let Some(message) = self.on_right_click.clone() {
+        if let Some(message) = self.on_right_click {
             widget = widget.on_right_press(message);
         }
 
         widget.into()
     }
 
-    fn title_widget(&mut self, title_portion: u16) -> Element<'a, Message> {
-        let mut title = Cow::default();
-        std::mem::swap(&mut title, &mut self.title);
-
-        widget::text::heading(title)
-            .wrapping(iced_core::text::Wrapping::None)
-            .ellipsize(iced_core::text::Ellipsize::End(
-                iced_core::text::EllipsizeHeightLimit::Lines(1),
-            ))
-            .apply(widget::container)
-            .center(Length::FillPortion(title_portion))
-            .into()
-    }
-
     /// Creates the widget for window controls.
-    fn window_controls(&mut self) -> Element<'a, Message> {
+    fn window_controls(&mut self, spacing: u16) -> Element<'a, Message> {
         macro_rules! icon {
             ($name:expr, $size:expr, $on_press:expr) => {{
-                let icon = {
-                    widget::icon::from_name($name)
-                        .apply(widget::button::icon)
-                        .padding(8)
-                };
-
-                icon.class(crate::theme::Button::HeaderBar)
+                widget::icon::from_name($name)
+                    .apply(widget::button::icon)
+                    .padding(8)
+                    .class(theme::Button::HeaderBar)
                     .selected(self.focused)
                     .icon_size($size)
                     .on_press($on_press)
@@ -475,7 +464,7 @@ impl<'a, Message: Clone + 'static> HeaderBar<'a, Message> {
             .push_maybe(
                 self.on_minimize
                     .take()
-                    .map(|m: Message| icon!("window-minimize-symbolic", 16, m)),
+                    .map(|m| icon!("window-minimize-symbolic", 16, m)),
             )
             .push_maybe(self.on_maximize.take().map(|m| {
                 if self.maximized {
@@ -489,21 +478,14 @@ impl<'a, Message: Clone + 'static> HeaderBar<'a, Message> {
                     .take()
                     .map(|m| icon!("window-close-symbolic", 16, m)),
             )
-            .spacing(theme::spacing().space_xxs)
-            .apply(widget::container)
-            .center_y(Length::Fill)
+            .spacing(spacing)
+            .align_y(iced::Alignment::Center)
             .into()
     }
 }
 
 impl<'a, Message: Clone + 'static> From<HeaderBar<'a, Message>> for Element<'a, Message> {
     fn from(headerbar: HeaderBar<'a, Message>) -> Self {
-        Element::new(headerbar.build())
-    }
-}
-
-impl<'a, Message: Clone + 'static> From<HeaderBarWidget<'a, Message>> for Element<'a, Message> {
-    fn from(headerbar: HeaderBarWidget<'a, Message>) -> Self {
-        Element::new(headerbar)
+        headerbar.view()
     }
 }

src/widget/icon/bundle.rs

@@ -4,12 +4,12 @@
 //! Embedded icons for platforms which do not support icon themes yet.
 
 /// Icon bundling is not enabled on unix platforms.
-#[cfg(unix)]
+#[cfg(all(unix, not(target_os = "macos")))]
 pub fn get(icon_name: &str) -> Option<super::Data> {
     None
 }
 
-#[cfg(not(unix))]
+#[cfg(any(not(unix), target_os = "macos"))]
 /// Get a bundled icon on non-unix platforms.
 pub fn get(icon_name: &str) -> Option<super::Data> {
     ICONS
@@ -17,5 +17,5 @@ pub fn get(icon_name: &str) -> Option<super::Data> {
         .map(|bytes| super::Data::Svg(crate::iced::widget::svg::Handle::from_memory(*bytes)))
 }
 
-#[cfg(not(unix))]
+#[cfg(any(not(unix), target_os = "macos"))]
 include!(concat!(env!("OUT_DIR"), "/bundled_icons.rs"));

src/widget/icon/mod.rs

@@ -15,7 +15,7 @@ pub use handle::{Data, Handle, from_path, from_raster_bytes, from_raster_pixels,
 use crate::Element;
 use derive_setters::Setters;
 use iced::widget::{Image, Svg};
-use iced::{ContentFit, Length, Rectangle};
+use iced::{ContentFit, Length, Radians, Rectangle};
 use iced_core::Rotation;
 
 /// Create an [`Icon`] from a pre-existing [`Handle`]
@@ -125,17 +125,22 @@ pub fn draw(renderer: &mut crate::Renderer, handle: &Handle, icon_bounds: Rectan
             renderer,
             iced_core::svg::Svg::new(handle),
             icon_bounds,
+            icon_bounds,
         ),
 
         Data::Image(handle) => {
             iced_core::image::Renderer::draw_image(
                 renderer,
-                handle,
-                iced_core::image::FilterMethod::Linear,
+                iced_core::Image {
+                    handle,
+                    filter_method: iced_core::image::FilterMethod::Linear,
+                    rotation: Radians(0.),
+                    border_radius: [0.0; 4].into(),
+                    opacity: 1.0,
+                    snap: true,
+                },
+                icon_bounds,
                 icon_bounds,
-                iced_core::Radians::from(0),
-                1.0,
-                [0.0; 4],
             );
         }
     }

src/widget/icon/named.rs

@@ -52,7 +52,7 @@ impl Named {
         }
     }
 
-    #[cfg(not(windows))]
+    #[cfg(all(unix, not(target_os = "macos")))]
     #[must_use]
     pub fn path(self) -> Option<PathBuf> {
         let name = &*self.name;
@@ -107,7 +107,7 @@ impl Named {
         result
     }
 
-    #[cfg(windows)]
+    #[cfg(any(not(unix), target_os = "macos"))]
     #[must_use]
     pub fn path(self) -> Option<PathBuf> {
         //TODO: implement icon lookup for Windows

src/widget/id_container.rs

@@ -3,7 +3,7 @@ use iced_core::layout;
 use iced_core::mouse;
 use iced_core::overlay;
 use iced_core::renderer;
-use iced_core::widget::{Id, Tree};
+use iced_core::widget::{Id, Operation, Tree};
 use iced_core::{Clipboard, Element, Layout, Length, Rectangle, Shell, Vector, Widget};
 pub use iced_widget::container::{Catalog, Style};
 
@@ -57,7 +57,7 @@ where
     }
 
     fn diff(&mut self, tree: &mut Tree) {
-        tree.children[0].diff(&mut self.content);
+        tree.diff_children(std::slice::from_mut(&mut self.content));
     }
 
     fn size(&self) -> iced_core::Size<Length> {
@@ -65,28 +65,29 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
         let node = self
             .content
-            .as_widget()
+            .as_widget_mut()
             .layout(&mut tree.children[0], renderer, limits);
         let size = node.size();
         layout::Node::with_children(size, vec![node])
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn iced_core::widget::Operation<()>,
+        operation: &mut dyn Operation,
     ) {
-        operation.container(Some(&self.id), layout.bounds(), &mut |operation| {
-            self.content.as_widget().operate(
+        operation.container(Some(&self.id), layout.bounds());
+        operation.traverse(&mut |operation| {
+            self.content.as_widget_mut().operate(
                 &mut tree.children[0],
                 layout
                     .children()
@@ -99,18 +100,18 @@ where
         });
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor_position: mouse::Cursor,
         renderer: &Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         viewport: &Rectangle,
-    ) -> event::Status {
-        self.content.as_widget_mut().on_event(
+    ) {
+        self.content.as_widget_mut().update(
             &mut tree.children[0],
             event,
             layout
@@ -123,7 +124,7 @@ where
             clipboard,
             shell,
             viewport,
-        )
+        );
     }
 
     fn mouse_interaction(
@@ -169,8 +170,9 @@ where
     fn overlay<'b>(
         &'b mut self,
         tree: &'b mut Tree,
-        layout: Layout<'_>,
+        layout: Layout<'b>,
         renderer: &Renderer,
+        viewport: &Rectangle,
         translation: Vector,
     ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
         self.content.as_widget_mut().overlay(
@@ -181,6 +183,7 @@ where
                 .unwrap()
                 .with_virtual_offset(layout.virtual_offset()),
             renderer,
+            viewport,
             translation,
         )
     }

src/widget/layer_container.rs

@@ -172,7 +172,7 @@ where
     }
 
     fn layout(
-        &self,
+        &mut self,
         tree: &mut Tree,
         renderer: &Renderer,
         limits: &layout::Limits,
@@ -181,7 +181,7 @@ where
     }
 
     fn operate(
-        &self,
+        &mut self,
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -190,18 +190,18 @@ where
         self.container.operate(tree, layout, renderer, operation);
     }
 
-    fn on_event(
+    fn update(
         &mut self,
         tree: &mut Tree,
-        event: Event,
+        event: &Event,
         layout: Layout<'_>,
         cursor_position: mouse::Cursor,
         renderer: &Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         viewport: &Rectangle,
-    ) -> event::Status {
-        self.container.on_event(
+    ) {
+        self.container.update(
             tree,
             event,
             layout,
@@ -257,11 +257,13 @@ where
     fn overlay<'b>(
         &'b mut self,
         tree: &'b mut Tree,
-        layout: Layout<'_>,
+        layout: Layout<'b>,
         renderer: &Renderer,
+        viewport: &Rectangle,
         translation: Vector,
     ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
-        self.container.overlay(tree, layout, renderer, translation)
+        self.container
+            .overlay(tree, layout, renderer, viewport, translation)
     }
 
     fn drag_destinations(