// Copyright 2023 System76 <info@system76.com>
// SPDX-License-Identifier: GPL-3.0-only

use crate::{
    fl, icon_catalog,
    launcher_edit::{self, LauncherEditRequest},
    wayland_subscription::{
        OutputUpdate, ToplevelRequest, ToplevelUpdate, WaylandImage, WaylandRequest, WaylandUpdate,
        wayland_subscription,
    },
};
use cctk::{
    sctk::{output::OutputInfo, reexports::calloop::channel::Sender},
    toplevel_info::ToplevelInfo,
    wayland_client::protocol::{
        wl_data_device_manager::DndAction, wl_output::WlOutput, wl_seat::WlSeat,
    },
    wayland_protocols::ext::{
        foreign_toplevel_list::v1::client::ext_foreign_toplevel_handle_v1::ExtForeignToplevelHandleV1,
        workspace::v1::client::ext_workspace_handle_v1::ExtWorkspaceHandleV1,
    },
};
use cosmic::{
    Apply, Element, Task, app,
    applet::{
        Context, Size,
        cosmic_panel_config::{PanelAnchor, PanelSize},
    },
    cosmic_config::{Config, CosmicConfigEntry},
    desktop::IconSourceExt,
    iced::runtime::{core::event, dnd::peek_dnd},
    iced::{
        self, Alignment, Background, Border, Length, Limits, Padding, Subscription,
        advanced::text::{Ellipsize, EllipsizeHeightLimit},
        clipboard::mime::{AllowedMimeTypes, AsMimeTypes},
        event::listen_with,
        platform_specific::shell::commands::popup::{destroy_popup, get_popup},
        widget::{
            Column, Row, column, mouse_area, row, rule::vertical as vertical_rule,
            space::horizontal as horizontal_space, space::vertical as vertical_space, stack,
        },
        window,
    },
    surface,
    theme::{self, Button, Container},
    widget::{
        DndDestination, Image, button, container, divider, dnd_source, grid,
        icon::{self, from_name},
        image::Handle,
        rectangle_tracker::{RectangleTracker, RectangleUpdate, rectangle_tracker_subscription},
        scrollable, svg, text, text_input,
    },
};
use cosmic::{
    desktop::fde::{self, DesktopEntry, get_languages_from_env, unicase::Ascii},
    widget::DndSource,
};
use cosmic_app_list_config::{APP_ID, AppListConfig};
use cosmic_protocols::toplevel_info::v1::client::zcosmic_toplevel_handle_v1::State;
use futures::future::pending;
use rustc_hash::FxHashMap;
use std::{borrow::Cow, path::PathBuf, rc::Rc, str::FromStr, time::Duration};
use switcheroo_control::Gpu;
use tokio::time::sleep;
use url::Url;

static MIME_TYPE: &str = "text/uri-list";
const MAX_VISIBLE_ICON_CHOICES: usize = 120;
const ICON_CATALOG_COLUMNS: usize = 6;

pub fn run() -> cosmic::iced::Result {
    cosmic::applet::run::<CosmicAppList>(())
}

#[derive(Debug, Clone)]
struct AppletIconData {
    icon_size: u16,
    icon_spacing: f32,
    dot_radius: f32,
    bar_size: f32,
    padding: Padding,
}

static DND_FAVORITES: u64 = u64::MAX;

impl AppletIconData {
    fn new(applet: &Context) -> Self {
        let icon_size = applet.suggested_size(false).0;
        let (major_padding, cross_padding) = applet.suggested_padding(false);
        let (h_padding, v_padding) = if applet.is_horizontal() {
            (major_padding as f32, cross_padding as f32)
        } else {
            (cross_padding as f32, major_padding as f32)
        };
        let icon_spacing = applet.spacing as f32;

        let (dot_radius, bar_size) = match applet.size {
            Size::Hardcoded(_) => (2.0, 8.0),
            Size::PanelSize(ref s) => {
                let size = s.get_applet_icon_size_with_padding(false);
                // Define size thresholds, to handle custom sizes
                let small_size_threshold = PanelSize::S.get_applet_icon_size_with_padding(false);
                let medium_size_threshold = PanelSize::M.get_applet_icon_size_with_padding(false);
                if size <= small_size_threshold {
                    (1.0, 8.0)
                } else if size <= medium_size_threshold {
                    (2.0, 8.0)
                } else {
                    (2.0, 12.0)
                }
            }
        };
        let padding = match applet.anchor {
            PanelAnchor::Top => [
                v_padding - (dot_radius * 2. + 1.),
                h_padding,
                v_padding,
                h_padding,
            ],
            PanelAnchor::Bottom => [
                v_padding,
                h_padding,
                v_padding - (dot_radius * 2. + 1.),
                h_padding,
            ],
            PanelAnchor::Left => [
                v_padding,
                h_padding,
                v_padding,
                h_padding - (dot_radius * 2. + 1.),
            ],
            PanelAnchor::Right => [
                v_padding,
                h_padding - (dot_radius * 2. + 1.),
                v_padding,
                h_padding,
            ],
        };
        AppletIconData {
            icon_size,
            icon_spacing,
            dot_radius,
            bar_size,
            padding: padding.into(),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum DockItemId {
    Item(u32),
    ActiveOverflow,
    FavoritesOverflow,
}

impl From<u32> for DockItemId {
    fn from(id: u32) -> Self {
        DockItemId::Item(id)
    }
}

impl From<usize> for DockItemId {
    fn from(id: usize) -> Self {
        DockItemId::Item(id as u32)
    }
}

#[derive(Debug, Clone)]
struct DockItem {
    // ID used internally in the applet. Each dock item
    // have an unique id
    id: u32,
    toplevels: Vec<(ToplevelInfo, Option<WaylandImage>)>,
    // Information found in the .desktop file
    desktop_info: DesktopEntry,
    // We must use this because the id in `DesktopEntry` is an estimation.
    // Thus, if we unpin an item, we want to be sure to use the real id
    original_app_id: String,
}

impl DockItem {
    fn as_icon(
        &self,
        applet: &Context,
        rectangle_tracker: Option<&RectangleTracker<DockItemId>>,
        interaction_enabled: bool,
        dnd_source_enabled: bool,
        gpus: Option<&[Gpu]>,
        is_focused: bool,
        dot_border_radius: [f32; 4],
        window_id: window::Id,
        filter: Option<&dyn Fn(&ToplevelInfo) -> bool>,
        // Yoda: multiplier on the computed icon size (1.0 = default,
        // >1.0 = magnified e.g. on hover for the macOS Tahoe effect).
        // Applied to the icon's rendered width/height only — indicator
        // dot and surrounding layout stay at base size.
        icon_scale: f32,
    ) -> Element<'_, Message> {
        let Self {
            toplevels,
            desktop_info,
            id,
            ..
        } = self;

        let filtered_toplevels: Vec<_> = if let Some(filter_fn) = filter {
            toplevels
                .iter()
                .filter(|(info, _)| filter_fn(info))
                .collect()
        } else {
            toplevels.iter().collect()
        };
        let toplevel_count = filtered_toplevels.len();

        // Cairo-like : pastille plus petite + atténuée quand toutes les fenêtres
        // de cette app sont minimisées.
        let all_minimized = toplevel_count > 0
            && filtered_toplevels
                .iter()
                .all(|(info, _)| info.state.contains(&State::Minimized));

        let app_icon = AppletIconData::new(applet);

        // Yoda: scaled icon size for hover magnification. Clamped so
        // tiny floats don't round to 0 and huge ones stay within u16.
        let scaled_icon_size = ((f32::from(app_icon.icon_size) * icon_scale).round() as i32)
            .clamp(1, u16::MAX as i32) as u16;
        let cosmic_icon = cosmic::widget::icon(
            fde::IconSource::from_unknown(desktop_info.icon().unwrap_or_default()).as_cosmic_icon(),
        )
        // sets the preferred icon size variant
        .size(128)
        .width(scaled_icon_size.into())
        .height(scaled_icon_size.into());

        let indicator = {
            // Padding réduit quand minimisée → pastille plus petite.
            let effective_radius = if all_minimized {
                (app_icon.dot_radius * 0.55).max(1.0)
            } else {
                app_icon.dot_radius
            };

            let container = if toplevel_count <= 1 {
                vertical_space().height(Length::Fixed(0.0))
            } else {
                match applet.anchor {
                    PanelAnchor::Left | PanelAnchor::Right => {
                        vertical_space().height(app_icon.bar_size)
                    }
                    PanelAnchor::Top | PanelAnchor::Bottom => {
                        horizontal_space().width(app_icon.bar_size)
                    }
                }
            }
            .apply(container)
            .padding(effective_radius);

            if toplevel_count == 0 {
                container
            } else {
                container.class(theme::Container::custom(move |theme| {
                    let cosmic = theme.cosmic();
                    let accent: iced::Color = cosmic.accent_color().into();
                    let on_bg: iced::Color = cosmic.on_bg_color().into();
                    // Teinte neutre atténuée quand toutes les fenêtres sont minimisées.
                    let muted = iced::Color { a: 0.45, ..on_bg };

                    let fill = if all_minimized {
                        muted
                    } else if is_focused {
                        accent
                    } else {
                        on_bg
                    };

                    container::Style {
                        background: Some(Background::Color(fill)),
                        border: Border {
                            radius: dot_border_radius.into(),
                            ..Default::default()
                        },
                        ..Default::default()
                    }
                }))
            }
        };

        let icon_wrapper: Element<_> = match applet.anchor {
            PanelAnchor::Left => row([
                indicator.into(),
                horizontal_space().width(Length::Fixed(1.0)).into(),
                cosmic_icon.clone().into(),
            ])
            .align_y(Alignment::Center)
            .into(),
            PanelAnchor::Right => row([
                cosmic_icon.clone().into(),
                horizontal_space().width(Length::Fixed(1.0)).into(),
                indicator.into(),
            ])
            .align_y(Alignment::Center)
            .into(),
            PanelAnchor::Top => column([
                indicator.into(),
                vertical_space().height(Length::Fixed(1.0)).into(),
                cosmic_icon.clone().into(),
            ])
            .align_x(Alignment::Center)
            .into(),
            PanelAnchor::Bottom => column([
                cosmic_icon.clone().into(),
                vertical_space().height(Length::Fixed(1.0)).into(),
                indicator.into(),
            ])
            .align_x(Alignment::Center)
            .into(),
        };

        let icon_button = button::custom(icon_wrapper)
            .padding(app_icon.padding)
            .selected(is_focused)
            .class(app_list_icon_style(is_focused));

        let icon_button: Element<_> = if interaction_enabled {
            mouse_area(
                icon_button
                    .on_press_maybe(if toplevel_count == 0 {
                        launch_on_preferred_gpu(desktop_info, gpus)
                    } else if toplevel_count == 1 {
                        filtered_toplevels
                            .first()
                            .map(|t| Message::Toggle(t.0.foreign_toplevel.clone()))
                    } else {
                        Some(Message::ToplevelListPopup(*id, window_id))
                    })
                    .width(Length::Shrink)
                    .height(Length::Shrink),
            )
            .on_right_release(Message::Popup(*id, window_id))
            .on_middle_release({
                launch_on_preferred_gpu(desktop_info, gpus)
                    .unwrap_or(Message::Popup(*id, window_id))
            })
            .into()
        } else {
            icon_button.into()
        };

        let path = desktop_info.path.clone();
        let icon_button = if dnd_source_enabled && interaction_enabled {
            DndSource::with_id(icon_button, cosmic::widget::Id::new("asdfasdfadfs"))
                .window(window_id)
                .drag_icon(move |_| {
                    (
                        cosmic_icon.clone().into(),
                        iced::core::widget::tree::State::None,
                        iced::Vector::ZERO,
                    )
                })
                .drag_threshold(16.)
                .drag_content(move || DndPathBuf(path.clone()))
                .on_start(Some(Message::StartDrag(*id)))
                .on_cancel(Some(Message::DragFinished))
                .on_finish(Some(Message::DragFinished))
        } else {
            dnd_source(icon_button)
        };

        if let Some(tracker) = rectangle_tracker {
            tracker.container((*id).into(), icon_button).into()
        } else {
            icon_button.into()
        }
    }
}

#[derive(Debug, Clone, Default)]
struct DndOffer {
    dock_item: Option<DockItem>,
    preview_index: usize,
}

#[derive(Debug, Clone)]
pub struct Popup {
    parent: window::Id,
    id: window::Id,
    dock_item: DockItem,
    popup_type: PopupType,
}

#[derive(Debug, Clone)]
struct LauncherEditState {
    original_app_id: String,
    source_path: PathBuf,
    original_name: String,
    original_exec: String,
    name: String,
    exec: String,
    icon: String,
    terminal: bool,
    saving: bool,
    error: Option<String>,
    icon_catalog: IconCatalogState,
}

#[derive(Debug, Clone)]
struct IconCatalogState {
    theme: String,
    query: String,
    entries: Vec<icon_catalog::IconCatalogEntry>,
    loading: bool,
    truncated: bool,
}

#[derive(Clone, Default)]
struct CosmicAppList {
    core: cosmic::app::Core,
    popup: Option<Popup>,
    launcher_edit: Option<LauncherEditState>,
    subscription_ctr: u32,
    item_ctr: u32,
    desktop_entries: Vec<DesktopEntry>,
    active_list: Vec<DockItem>,
    pinned_list: Vec<DockItem>,
    dnd_source: Option<(window::Id, DockItem, DndAction, Option<usize>)>,
    config: AppListConfig,
    wayland_sender: Option<Sender<WaylandRequest>>,
    seat: Option<WlSeat>,
    rectangle_tracker: Option<RectangleTracker<DockItemId>>,
    rectangles: FxHashMap<DockItemId, iced::Rectangle>,
    dnd_offer: Option<DndOffer>,
    is_listening_for_dnd: bool,
    gpus: Option<Vec<Gpu>>,
    active_workspaces: Vec<ExtWorkspaceHandleV1>,
    output_list: FxHashMap<WlOutput, OutputInfo>,
    locales: Vec<String>,
    hovered_toplevel: Option<ExtForeignToplevelHandleV1>,
    /// Yoda: which dock icon the pointer is currently over (for hover
    /// magnification). None = no dock icon hovered.
    hovered_dock_item: Option<DockItemId>,
    /// Yoda: animated "virtual cursor" center used by the fisheye
    /// formula — lerps toward the real hovered icon's center on each
    /// AnimTick, so the bell curve slides smoothly from one icon to the
    /// next instead of snapping.
    anim_hover_center: Option<(f32, f32)>,
    /// Yoda: fade-in/out intensity of the magnification effect
    /// (0.0 = icons flat, 1.0 = full fisheye). Targets 1.0 while the
    /// pointer is over any dock icon, 0.0 otherwise. Lerped on AnimTick.
    anim_hover_intensity: f32,
    /// Yoda: timestamp of the last AnimTick, for dt-based exponential
    /// smoothing. `None` on first tick.
    anim_last_tick: Option<std::time::Instant>,
    overflow_favorites_popup: Option<window::Id>,
    overflow_active_popup: Option<window::Id>,
}

#[derive(Debug, Clone, PartialEq)]
pub enum PopupType {
    RightClickMenu,
    ToplevelList,
    LauncherEditor,
}

#[derive(Debug, Clone)]
#[allow(dead_code)]
enum Message {
    Wayland(WaylandUpdate),
    PinApp(u32),
    UnpinApp(u32),
    EditLauncher(u32),
    LauncherNameChanged(String),
    LauncherExecChanged(String),
    LauncherIconChanged(String),
    LauncherIconSearchChanged(String),
    LauncherIconSelected(String),
    ReloadLauncherIconCatalog,
    LauncherIconCatalogLoaded(icon_catalog::IconCatalog),
    SaveLauncherEdit,
    CancelLauncherEdit,
    LauncherEditSaved(Result<launcher_edit::LauncherEditResult, String>),
    /// Yoda: pointer entered (Some) or left (None) a dock icon — drives
    /// the macOS Tahoe-style hover magnification effect.
    DockItemHover(Option<DockItemId>),
    /// Yoda: ticked at ~60fps by the animation subscription. Advances
    /// anim_hover_center + anim_hover_intensity toward their targets so
    /// the fisheye effect transitions smoothly instead of snapping.
    AnimTick(std::time::Instant),
    Popup(u32, window::Id),
    Pressed(window::Id),
    ToplevelListPopup(u32, window::Id),
    ToplevelHoverChanged(ExtForeignToplevelHandleV1, bool),
    GpuRequest(Option<Vec<Gpu>>),
    CloseRequested(window::Id),
    ClosePopup,
    Activate(ExtForeignToplevelHandleV1),
    Toggle(ExtForeignToplevelHandleV1),
    Exec(String, Option<usize>, bool),
    CloseToplevel(ExtForeignToplevelHandleV1),
    Quit(String),
    NewSeat(WlSeat),
    RemovedSeat,
    Rectangle(RectangleUpdate<DockItemId>),
    StartDrag(u32),
    DragFinished,
    DndEnter(f64, f64),
    DndLeave,
    DndMotion(f64, f64),
    DndDropFinished,
    DndData(Option<DndPathBuf>),
    StartListeningForDnd,
    StopListeningForDnd,
    IncrementSubscriptionCtr,
    ConfigUpdated(AppListConfig),
    OpenFavorites,
    OpenActive,
    Surface(surface::Action),
}

fn index_in_list(
    mut list_len: usize,
    item_size: f32,
    divider_size: f32,
    existing_preview: Option<usize>,
    pos_in_list: f32,
) -> usize {
    if existing_preview.is_some() {
        list_len += 1;
    }

    let index = if (list_len == 0) || (pos_in_list < item_size / 2.0) {
        0
    } else {
        let mut i = 1;
        let mut pos = item_size / 2.0;
        while i < list_len {
            let next_pos = pos + item_size + divider_size;
            if pos < pos_in_list && pos_in_list < next_pos {
                break;
            }
            pos = next_pos;
            i += 1;
        }
        i
    };

    if let Some(existing_preview) = existing_preview {
        if index >= existing_preview {
            index.saturating_sub(1)
        } else {
            index
        }
    } else {
        index
    }
}

async fn try_get_gpus() -> Option<Vec<Gpu>> {
    let connection = zbus::Connection::system().await.ok()?;
    let proxy = switcheroo_control::SwitcherooControlProxy::new(&connection)
        .await
        .ok()?;

    if !proxy.has_dual_gpu().await.ok()? {
        return None;
    }

    let gpus = proxy.get_gpus().await.ok()?;
    if gpus.is_empty() {
        return None;
    }

    Some(gpus)
}

const TOPLEVEL_BUTTON_WIDTH: f32 = 192.0;
const TOPLEVEL_BUTTON_HEIGHT: f32 = 156.0;

fn toplevel_button<'a>(
    img: Option<WaylandImage>,
    title: String,
    handle: ExtForeignToplevelHandleV1,
    is_focused: bool,
    is_hovered: bool,
) -> Element<'a, Message> {
    let border = 1.0;
    let preview = column![
        container(if let Some(img) = img {
            Element::from(Image::new(Handle::from_rgba(
                img.width,
                img.height,
                img.img.clone(),
            )))
        } else {
            Image::new(Handle::from_rgba(1, 1, [0u8, 0u8, 0u8, 255u8].as_slice())).into()
        })
        .class(Container::custom(move |theme| container::Style {
            border: Border {
                color: theme.cosmic().bg_divider().into(),
                width: border,
                radius: 1.0.into(),
            },
            ..Default::default()
        }))
        .padding(border as u16)
        .apply(container)
        .center(Length::Fill),
        text::body(title)
            .ellipsize(Ellipsize::End(EllipsizeHeightLimit::Lines(1)))
            .width(Length::Fill)
            .center()
    ]
    .spacing(4)
    .padding([4, 4, 0, 4]);
    let close_button_overlay = if is_hovered {
        row![
            horizontal_space(),
            button::custom(icon::from_name("window-close-symbolic").size(16))
                .class(Button::Destructive)
                .on_press(Message::CloseToplevel(handle.clone()))
                .padding(4)
        ]
    } else {
        row![]
    }
    .width(Length::Fill)
    .height(Length::Fill);

    stack![preview, close_button_overlay]
        .apply(button::custom)
        .on_press(Message::Toggle(handle.clone()))
        .class(window_menu_style(is_focused))
        .width(Length::Fixed(TOPLEVEL_BUTTON_WIDTH))
        .height(Length::Fixed(TOPLEVEL_BUTTON_HEIGHT))
        .padding(4)
        .selected(is_focused)
        .apply(mouse_area)
        .on_enter(Message::ToplevelHoverChanged(handle.clone(), true))
        .on_middle_press(Message::CloseToplevel(handle.clone()))
        .on_exit(Message::ToplevelHoverChanged(handle, false))
        .apply(Element::from)
}

fn window_menu_style(selected: bool) -> cosmic::theme::Button {
    let radius = theme::active()
        .cosmic()
        .radius_m()
        .map(|x| if x < 8.0 { x } else { x - 4.0 });

    Button::Custom {
        active: Box::new(move |focused, theme| {
            let a = button::Catalog::active(theme, focused, selected, &Button::AppletMenu);
            button::Style {
                background: if selected {
                    Some(Background::Color(
                        theme.cosmic().icon_button.selected_state_color().into(),
                    ))
                } else {
                    a.background
                },
                border_radius: radius.into(),
                outline_width: 0.0,
                ..a
            }
        }),
        hovered: Box::new(move |focused, theme| {
            let focused = selected || focused;
            let text = button::Catalog::hovered(theme, focused, focused, &Button::AppletMenu);
            button::Style {
                border_radius: radius.into(),
                outline_width: 0.0,
                ..text
            }
        }),
        disabled: Box::new(move |theme| {
            let text = button::Catalog::disabled(theme, &Button::AppletMenu);
            button::Style {
                border_radius: radius.into(),
                outline_width: 0.0,
                ..text
            }
        }),
        pressed: Box::new(move |focused, theme| {
            let focused = selected || focused;
            let text = button::Catalog::pressed(theme, focused, focused, &Button::AppletMenu);
            button::Style {
                border_radius: radius.into(),
                outline_width: 0.0,
                ..text
            }
        }),
    }
}

fn app_list_icon_style(selected: bool) -> cosmic::theme::Button {
    Button::Custom {
        active: Box::new(move |focused, theme| {
            let a = button::Catalog::active(theme, focused, selected, &Button::AppletIcon);
            button::Style {
                background: if selected {
                    Some(Background::Color(
                        theme.cosmic().icon_button.selected_state_color().into(),
                    ))
                } else {
                    a.background
                },
                ..a
            }
        }),
        hovered: Box::new(move |focused, theme| {
            button::Catalog::hovered(theme, focused, selected, &Button::AppletIcon)
        }),
        disabled: Box::new(|theme| button::Catalog::disabled(theme, &Button::AppletIcon)),
        pressed: Box::new(move |focused, theme| {
            button::Catalog::pressed(theme, focused, selected, &Button::AppletIcon)
        }),
    }
}

#[inline]
pub fn menu_control_padding() -> Padding {
    let spacing = theme::spacing();
    [spacing.space_xxs, spacing.space_s].into()
}

fn launcher_icon_editor(edit: &LauncherEditState) -> Element<'_, Message> {
    let spacing = theme::spacing();
    let selected_icon = edit.icon.trim();
    let query = edit.icon_catalog.query.trim().to_ascii_lowercase();
    let mut total_matches = 0usize;
    let mut visible_count = 0usize;
    let mut icon_grid = grid()
        .width(Length::Fill)
        .column_spacing(spacing.space_xxs)
        .row_spacing(spacing.space_xxs);

    for entry in edit.icon_catalog.entries.iter().filter(|entry| {
        query.is_empty() || entry.name.to_ascii_lowercase().contains(query.as_str())
    }) {
        total_matches += 1;
        if visible_count >= MAX_VISIBLE_ICON_CHOICES {
            continue;
        }

        if visible_count > 0 && visible_count % ICON_CATALOG_COLUMNS == 0 {
            icon_grid = icon_grid.insert_row();
        }

        let selected = selected_icon == entry.name;
        let icon_preview = cosmic::widget::icon(
            fde::IconSource::from_unknown(entry.name.as_str()).as_cosmic_icon(),
        )
        .size(32)
        .width(Length::Fixed(32.0))
        .height(Length::Fixed(32.0));

        let label = text::caption(entry.name.as_str())
            .ellipsize(Ellipsize::End(EllipsizeHeightLimit::Lines(1)))
            .width(Length::Fill)
            .center();

        let tile = column![icon_preview, label]
            .align_x(Alignment::Center)
            .spacing(4)
            .width(Length::Fixed(70.0));

        let tile_button = button::custom(tile)
            .class(if selected {
                Button::Suggested
            } else {
                Button::Image
            })
            .selected(selected)
            .on_press(Message::LauncherIconSelected(entry.name.clone()))
            .padding(6)
            .width(Length::Fixed(74.0))
            .height(Length::Fixed(76.0));

        icon_grid = icon_grid.push(tile_button);
        visible_count += 1;
    }

    let current_icon =
        cosmic::widget::icon(fde::IconSource::from_unknown(edit.icon.as_str()).as_cosmic_icon())
            .size(32)
            .width(Length::Fixed(36.0))
            .height(Length::Fixed(36.0));

    let icon_value = row![
        current_icon,
        text_input("", edit.icon.as_str())
            .label(fl!("launcher-icon"))
            .on_input(Message::LauncherIconChanged)
            .on_submit(|_| Message::SaveLauncherEdit)
            .width(Length::Fill)
            .size(14),
        button::icon(from_name("view-refresh-symbolic"))
            .on_press(Message::ReloadLauncherIconCatalog)
            .padding(spacing.space_xxs),
    ]
    .spacing(spacing.space_xs)
    .align_y(Alignment::Center);

    let visible_total = if edit.icon_catalog.truncated {
        format!(
            "{}/{}+ {}",
            visible_count,
            total_matches,
            fl!("launcher-icons")
        )
    } else {
        format!(
            "{}/{} {}",
            visible_count,
            total_matches,
            fl!("launcher-icons")
        )
    };

    let catalog_header = row![
        text::caption(format!(
            "{}: {}",
            fl!("launcher-icon-theme"),
            edit.icon_catalog.theme
        )),
        horizontal_space(),
        text::caption(visible_total),
    ]
    .align_y(Alignment::Center);

    let catalog_body: Element<_> = if edit.icon_catalog.loading {
        container(text::body(fl!("launcher-icon-catalog-loading")))
            .center(Length::Fill)
            .height(Length::Fixed(220.0))
            .into()
    } else if total_matches == 0 {
        container(text::body(fl!("launcher-icon-catalog-empty")))
            .center(Length::Fill)
            .height(Length::Fixed(220.0))
            .into()
    } else {
        scrollable(icon_grid)
            .height(Length::Fixed(240.0))
            .width(Length::Fill)
            .into()
    };

    column![
        icon_value,
        catalog_header,
        text_input("", edit.icon_catalog.query.as_str())
            .label(fl!("launcher-icon-search"))
            .on_input(Message::LauncherIconSearchChanged)
            .width(Length::Fill)
            .size(14),
        catalog_body,
    ]
    .spacing(spacing.space_s)
    .width(Length::Fill)
    .into()
}

fn find_desktop_entries<'a>(
    desktop_entries: &'a [fde::DesktopEntry],
    app_ids: &'a [String],
) -> impl Iterator<Item = fde::DesktopEntry> + 'a {
    app_ids.iter().map(|fav| {
        let unicase_fav = fde::unicase::Ascii::new(fav.as_str());
        fde::find_app_by_id(desktop_entries, unicase_fav).map_or_else(
            || fde::DesktopEntry::from_appid(fav.clone()),
            ToOwned::to_owned,
        )
    })
}

impl CosmicAppList {
    // Cache all desktop entries to use when new apps are added to the dock.
    fn update_desktop_entries(&mut self) {
        self.desktop_entries = fde::Iter::new(fde::default_paths())
            .filter_map(|p| fde::DesktopEntry::from_path(p, Some(&self.locales)).ok())
            .collect::<Vec<_>>();
    }

    /// Yoda: macOS-Tahoe fisheye-style magnification. Returns the
    /// per-icon size multiplier based on the distance (in pixels) from
    /// the currently hovered icon's center to this icon's center.
    ///
    /// Uses a gaussian bell curve so the hovered icon peaks at
    /// 1.0 + PEAK, immediate neighbors still bulge noticeably, and icons
    /// further away relax back to 1.0× — that's the smooth neighbour
    /// deformation people associate with the macOS Dock.
    ///
    /// Falls back to binary 1.3×/1.0× when the rectangle tracker hasn't
    /// populated yet (first render, or just after layout changes).
    ///
    /// Uses the animated hover center (anim_hover_center) and intensity
    /// (anim_hover_intensity) so inter-icon transitions slide smoothly
    /// and the whole effect fades in/out at the dock's edges.
    fn icon_scale_for(&self, id: &DockItemId) -> f32 {
        const PEAK: f32 = 0.35;
        // sigma expressed in multiples of the hovered icon's size —
        // 1.4 means the ±1 neighbors sit ~0.7σ away and still bulge
        // visibly, while ±3+ has collapsed to ~1.0× (fisheye footprint
        // close to 5 icons wide, Tahoe-ish).
        const SIGMA_FACTOR: f32 = 1.4;

        // No intensity at all → skip the rest.
        if self.anim_hover_intensity < 0.001 {
            return 1.0;
        }

        // Prefer the animated center (smooth); fall back to the real
        // hovered icon's center (first render, before tick fires).
        let hover_center = self.anim_hover_center.or_else(|| {
            let hovered_id = self.hovered_dock_item.as_ref()?;
            let r = self.rectangles.get(hovered_id)?;
            Some((r.x + r.width / 2.0, r.y + r.height / 2.0))
        });
        let Some(hover_center) = hover_center else {
            // No coords yet — visibly peak on the exact hovered id so
            // the very first frame still responds.
            return if self.hovered_dock_item.as_ref() == Some(id) {
                1.0 + PEAK * self.anim_hover_intensity
            } else {
                1.0
            };
        };

        let this_rect = match self.rectangles.get(id) {
            Some(r) => r,
            None => return 1.0,
        };

        let is_horizontal = matches!(
            self.core.applet.anchor,
            PanelAnchor::Top | PanelAnchor::Bottom
        );
        let this_center = if is_horizontal {
            this_rect.x + this_rect.width / 2.0
        } else {
            this_rect.y + this_rect.height / 2.0
        };
        let hover_axis = if is_horizontal { hover_center.0 } else { hover_center.1 };
        let distance = (this_center - hover_axis).abs();
        let icon_extent = if is_horizontal {
            this_rect.width
        } else {
            this_rect.height
        }
        .max(1.0);
        let sigma = icon_extent * SIGMA_FACTOR;
        // exp(-t²) bell curve, t = distance / sigma
        let t = distance / sigma;
        1.0 + PEAK * self.anim_hover_intensity * (-t * t).exp()
    }

    fn is_on_current_monitor_and_workspace(&self, toplevel_info: &ToplevelInfo) -> bool {
        use cosmic_app_list_config::ToplevelFilter;

        let on_active_workspace = self.active_workspaces.is_empty()
            || toplevel_info.workspace.is_empty()
            || self
                .active_workspaces
                .iter()
                .any(|workspace| toplevel_info.workspace.contains(workspace));

        match &self.config.filter_top_levels {
            None => true,
            Some(ToplevelFilter::ActiveWorkspace) => on_active_workspace,
            Some(ToplevelFilter::ConfiguredOutput) => {
                let on_active_output = self
                    .output_list
                    .iter()
                    .find(|(_, info)| info.name.as_ref() == Some(&self.core.applet.output_name))
                    .map_or(true, |(active_output, _)| {
                        toplevel_info
                            .output
                            .iter()
                            .any(|output| output == active_output)
                    });

                on_active_output && on_active_workspace
            }
        }
    }

    // Update pinned items using the cached desktop entries as a source.
    fn update_pinned_list(&mut self) {
        self.pinned_list = find_desktop_entries(&self.desktop_entries, &self.config.favorites)
            .zip(&self.config.favorites)
            .enumerate()
            .map(|(pinned_ctr, (e, original_id))| DockItem {
                id: pinned_ctr as u32,
                toplevels: Vec::new(),
                desktop_info: e,
                original_app_id: original_id.clone(),
            })
            .collect();
    }

    fn sync_pinned_list_from_config(&mut self) {
        for item in self.pinned_list.drain(..) {
            if !item.toplevels.is_empty() {
                self.active_list.push(item);
            }
        }

        self.pinned_list = find_desktop_entries(&self.desktop_entries, &self.config.favorites)
            .zip(&self.config.favorites)
            .map(|(de, original_id)| {
                if let Some(p) = self
                    .active_list
                    .iter()
                    .position(|dock_item| dock_item.desktop_info.id() == de.id())
                {
                    let mut d = self.active_list.remove(p);
                    d.desktop_info = de.clone();
                    d.original_app_id.clone_from(original_id);
                    d
                } else {
                    self.item_ctr += 1;
                    DockItem {
                        id: self.item_ctr,
                        toplevels: Vec::new(),
                        desktop_info: de.clone(),
                        original_app_id: original_id.clone(),
                    }
                }
            })
            .collect();
    }

    /// Close any open popups.
    fn close_popups(&mut self) -> Task<cosmic::Action<Message>> {
        let mut commands = Vec::new();
        if let Some(popup) = self.popup.take() {
            if popup.popup_type == PopupType::LauncherEditor {
                self.launcher_edit = None;
            }
            commands.push(destroy_popup(popup.id));
        }
        if let Some(popup) = self.overflow_active_popup.take() {
            commands.push(destroy_popup(popup));
        }
        if let Some(popup) = self.overflow_favorites_popup.take() {
            commands.push(destroy_popup(popup));
        }
        Task::batch(commands)
    }

    /// Returns the length of the group in the favorite list after which items are displayed in a popup.
    /// Shrink the favorite list until it only has active windows, or until it fits in the length provided.
    fn panel_overflow_lengths(&self) -> (Option<usize>, Option<usize>) {
        let mut favorite_index;
        let mut active_index = None;
        let Some(mut max_major_axis_len) = self.core.applet.suggested_bounds.as_ref().map(|c| {
            // if we have a configure for width and height, we're in a overflow popup
            match self.core.applet.anchor {
                PanelAnchor::Top | PanelAnchor::Bottom => c.width as u32,
                PanelAnchor::Left | PanelAnchor::Right => c.height as u32,
            }
        }) else {
            return (None, active_index);
        };
        // tracing::error!("{} {}", max_major_axis_len, self.pinned_list.len());
        // subtract the divider width
        max_major_axis_len -= 1;
        let applet_icon = AppletIconData::new(&self.core.applet);

        let button_total_size = self.core.applet.suggested_size(true).0
            + self.core.applet.suggested_padding(true).0 * 2
            + applet_icon.icon_spacing as u16;

        let favorite_active_cnt = self
            .pinned_list
            .iter()
            .filter(|t| !t.toplevels.is_empty())
            .count();

        // initial calculation of favorite_index
        let btn_count = max_major_axis_len / button_total_size as u32;
        if btn_count >= self.pinned_list.len() as u32 + self.active_list.len() as u32 {
            return (None, active_index);
        } else {
            favorite_index = (btn_count as usize).min(favorite_active_cnt).max(2);
        }

        // calculation of active_index based on favorite_index if there is still not enough space
        let active_index_max = (btn_count as i32)
            - (self.pinned_list.len() as i32).saturating_sub(favorite_index as i32);
        if active_index_max >= self.active_list.len() as i32 {
            active_index = Some(self.active_list.len());
        } else {
            active_index = Some((active_index_max.max(2) as usize).min(self.active_list.len()));
        }

        // final calculation of favorite_index if there is still not enough space
        if let Some(active_index) = active_index {
            let favorite_index_max = (btn_count as i32) - active_index as i32;
            favorite_index = favorite_index_max.max(2) as usize;
        } else {
            favorite_index = (btn_count as usize).min(self.pinned_list.len());
        }
        // tracing::error!("{} {} {:?}", btn_count, favorite_index, active_index);
        (Some(favorite_index), active_index)
    }

    fn currently_active_toplevel(&self) -> Vec<ExtForeignToplevelHandleV1> {
        if self.active_workspaces.is_empty() {
            return Vec::new();
        }
        let current_output = &self.core.applet.output_name;
        let mut focused_toplevels: Vec<ExtForeignToplevelHandleV1> = Vec::new();
        let active_workspaces = &self.active_workspaces;
        for toplevel_list in self.active_list.iter().chain(self.pinned_list.iter()) {
            for (t_info, _) in &toplevel_list.toplevels {
                if t_info.state.contains(&State::Activated)
                    && active_workspaces
                        .iter()
                        .any(|workspace| t_info.workspace.contains(workspace))
                    && t_info.output.iter().any(|x| {
                        self.output_list.get(x).is_some_and(|val| {
                            val.name.as_ref().is_some_and(|n| n == current_output)
                        })
                    })
                {
                    focused_toplevels.push(t_info.foreign_toplevel.clone());
                }
            }
        }
        focused_toplevels
    }

    fn find_desktop_entry_for_toplevel(
        &mut self,
        info: &ToplevelInfo,
        unicase_appid: Ascii<&str>,
    ) -> DesktopEntry {
        if let Some(appid) = fde::find_app_by_id(&self.desktop_entries, unicase_appid) {
            appid.clone()
        } else {
            // Update desktop entries in case it was not found.
            self.update_desktop_entries();
            if let Some(appid) = fde::find_app_by_id(&self.desktop_entries, unicase_appid) {
                appid.clone()
            } else {
                tracing::error!(id = info.app_id, "could not find desktop entry for app");
                let mut fallback_entry = fde::DesktopEntry::from_appid(info.app_id.clone());
                // proton opens games as steam_app_X, where X is either
                // the steam appid or "default". games with a steam appid
                // can have a desktop entry generated elsewhere; this
                // specifically handles non-steam games opened
                // under proton
                // in addition, try to match WINE entries who have its
                // appid = the full name of the executable (incl. .exe)
                let is_proton_game = info.app_id == "steam_app_default";
                if is_proton_game || info.app_id.ends_with(".exe") {
                    for entry in &self.desktop_entries {
                        let localised_name = entry.name(&self.locales).unwrap_or_default();
                        if localised_name == info.title {
                            // if this is a proton game, we only want
                            // to look for game entries
                            if is_proton_game
                                && !entry.categories().unwrap_or_default().contains(&"Game")
                            {
                                continue;
                            }
                            fallback_entry = entry.clone();
                            break;
                        }
                    }
                }
                fallback_entry
            }
        }
    }

    // Check if a specific toplevel is focused
    fn is_focused(&self, handle: &ExtForeignToplevelHandleV1) -> bool {
        self.currently_active_toplevel().contains(handle)
    }

    // Check if a specific toplevel button is currently hovered
    fn is_hovered(&self, handle: &ExtForeignToplevelHandleV1) -> bool {
        self.hovered_toplevel.as_ref() == Some(handle)
    }
}

impl cosmic::Application for CosmicAppList {
    type Message = Message;
    type Executor = cosmic::SingleThreadExecutor;
    type Flags = ();
    const APP_ID: &'static str = APP_ID;

    fn init(core: cosmic::app::Core, _flags: Self::Flags) -> (Self, app::Task<Self::Message>) {
        let config = Config::new(APP_ID, AppListConfig::VERSION)
            .ok()
            .and_then(|c| AppListConfig::get_entry(&c).ok())
            .unwrap_or_default();

        let mut app_list = Self {
            core,
            config,
            locales: get_languages_from_env(),
            ..Default::default()
        };

        app_list.update_desktop_entries();
        app_list.update_pinned_list();

        app_list.item_ctr = app_list.pinned_list.len() as u32;

        (
            app_list,
            Task::perform(try_get_gpus(), |gpus| {
                cosmic::Action::App(Message::GpuRequest(gpus))
            }),
        )
    }

    fn core(&self) -> &cosmic::app::Core {
        &self.core
    }

    fn core_mut(&mut self) -> &mut cosmic::app::Core {
        &mut self.core
    }

    fn update(&mut self, message: Self::Message) -> app::Task<Self::Message> {
        match message {
            Message::Popup(id, parent_window_id) => {
                if let Some(Popup {
                    parent,
                    id: popup_id,
                    ..
                }) = self.popup.take()
                {
                    if parent == parent_window_id {
                        return destroy_popup(popup_id);
                    } else {
                        self.overflow_active_popup = None;
                        self.overflow_favorites_popup = None;
                        return Task::batch([destroy_popup(popup_id), destroy_popup(parent)]);
                    }
                }
                if let Some(toplevel_group) = self
                    .active_list
                    .iter()
                    .chain(self.pinned_list.iter())
                    .find(|t| t.id == id)
                {
                    let Some(rectangle) = self.rectangles.get(&toplevel_group.id.into()) else {
                        tracing::error!("No rectangle found for toplevel group");
                        return Task::none();
                    };

                    let new_id = window::Id::unique();
                    self.popup = Some(Popup {
                        parent: parent_window_id,
                        id: new_id,
                        dock_item: toplevel_group.clone(),
                        popup_type: PopupType::RightClickMenu,
                    });

                    let mut popup_settings = self.core.applet.get_popup_settings(
                        parent_window_id,
                        new_id,
                        None,
                        None,
                        None,
                    );
                    let iced::Rectangle {
                        x,
                        y,
                        width,
                        height,
                    } = *rectangle;
                    popup_settings.positioner.anchor_rect = iced::Rectangle::<i32> {
                        x: x as i32,
                        y: y as i32,
                        width: width as i32,
                        height: height as i32,
                    };

                    let gpu_update = Task::perform(try_get_gpus(), |gpus| {
                        cosmic::Action::App(Message::GpuRequest(gpus))
                    });
                    return Task::batch([gpu_update, get_popup(popup_settings)]);
                }
            }
            Message::ToplevelListPopup(id, parent_window_id) => {
                if let Some(Popup {
                    parent,
                    id: popup_id,
                    ..
                }) = self.popup.take()
                {
                    if parent == parent_window_id {
                        return destroy_popup(popup_id);
                    } else {
                        self.overflow_active_popup = None;
                        self.overflow_favorites_popup = None;
                        return Task::batch([destroy_popup(popup_id), destroy_popup(parent)]);
                    }
                }
                if let Some(toplevel_group) = self
                    .active_list
                    .iter()
                    .chain(self.pinned_list.iter())
                    .find(|t| t.id == id)
                {
                    for (info, _) in &toplevel_group.toplevels {
                        if let Some(tx) = self.wayland_sender.as_ref() {
                            let _ =
                                tx.send(WaylandRequest::Screencopy(info.foreign_toplevel.clone()));
                        }
                    }

                    let Some(rectangle) = self.rectangles.get(&toplevel_group.id.into()) else {
                        return Task::none();
                    };

                    let new_id = window::Id::unique();
                    self.popup = Some(Popup {
                        parent: parent_window_id,
                        id: new_id,
                        dock_item: toplevel_group.clone(),
                        popup_type: PopupType::ToplevelList,
                    });

                    let mut popup_settings = self.core.applet.get_popup_settings(
                        parent_window_id,
                        new_id,
                        None,
                        None,
                        None,
                    );
                    let iced::Rectangle {
                        x,
                        y,
                        width,
                        height,
                    } = *rectangle;
                    popup_settings.positioner.anchor_rect = iced::Rectangle::<i32> {
                        x: x as i32,
                        y: y as i32,
                        width: width as i32,
                        height: height as i32,
                    };
                    let max_windows = 7.0;
                    let window_spacing = 8.0;
                    popup_settings.positioner.size_limits = match self.core.applet.anchor {
                        PanelAnchor::Right | PanelAnchor::Left => Limits::NONE
                            .min_width(100.0)
                            .min_height(30.0)
                            .max_width(window_spacing * 2.0 + TOPLEVEL_BUTTON_WIDTH)
                            .max_height(
                                TOPLEVEL_BUTTON_HEIGHT * max_windows
                                    + window_spacing * (max_windows + 1.0),
                            ),
                        PanelAnchor::Bottom | PanelAnchor::Top => Limits::NONE
                            .min_width(30.0)
                            .min_height(100.0)
                            .max_width(
                                TOPLEVEL_BUTTON_WIDTH * max_windows
                                    + window_spacing * (max_windows + 1.0),
                            )
                            .max_height(window_spacing * 2.0 + TOPLEVEL_BUTTON_HEIGHT),
                    };

                    return get_popup(popup_settings);
                }
            }
            Message::ToplevelHoverChanged(handle, entering) => {
                match (entering, &self.hovered_toplevel) {
                    (true, _) => self.hovered_toplevel = Some(handle),
                    // prevents race condition
                    (false, Some(h)) if h == &handle => self.hovered_toplevel = None,
                    _ => {}
                }
            }
            Message::PinApp(id) => {
                if let Some(i) = self.active_list.iter().position(|t| t.id == id) {
                    let entry = self.active_list.remove(i);
                    self.config.add_pinned(
                        entry.original_app_id.clone(),
                        &Config::new(APP_ID, AppListConfig::VERSION).unwrap(),
                    );
                    self.pinned_list.push(entry);
                }
                if let Some(Popup { id: popup_id, .. }) = self.popup.take() {
                    return destroy_popup(popup_id);
                }
            }
            Message::UnpinApp(id) => {
                if let Some(i) = self.pinned_list.iter().position(|t| t.id == id) {
                    let entry = self.pinned_list.remove(i);

                    self.config.remove_pinned(
                        &entry.original_app_id,
                        &Config::new(APP_ID, AppListConfig::VERSION).unwrap(),
                    );

                    self.rectangles.remove(&entry.id.into());
                    if !entry.toplevels.is_empty() {
                        self.active_list.push(entry);
                    }
                }
                if let Some(Popup { id: popup_id, .. }) = self.popup.take() {
                    return destroy_popup(popup_id);
                }
            }
            Message::EditLauncher(id) => {
                let Some(dock_item) = self.pinned_list.iter().find(|t| t.id == id).cloned() else {
                    return Task::none();
                };
                let Some(exec) = dock_item.desktop_info.exec() else {
                    return Task::none();
                };
                let Some(existing_popup) = self.popup.as_mut() else {
                    return Task::none();
                };

                let original_name = dock_item
                    .desktop_info
                    .desktop_entry("Name")
                    .map(ToString::to_string)
                    .or_else(|| {
                        dock_item
                            .desktop_info
                            .name(&self.locales)
                            .map(Cow::into_owned)
                    })
                    .unwrap_or_else(|| dock_item.original_app_id.clone());
                let original_exec = exec.to_string();
                let original_icon = dock_item
                    .desktop_info
                    .icon()
                    .unwrap_or_default()
                    .to_string();
                let icon_theme = cosmic::icon_theme::default();

                self.launcher_edit = Some(LauncherEditState {
                    original_app_id: dock_item.original_app_id.clone(),
                    source_path: dock_item.desktop_info.path.clone(),
                    original_name: original_name.clone(),
                    original_exec: original_exec.clone(),
                    name: original_name,
                    exec: original_exec,
                    icon: original_icon.clone(),
                    terminal: dock_item.desktop_info.terminal(),
                    saving: false,
                    error: None,
                    icon_catalog: IconCatalogState {
                        theme: icon_theme.clone(),
                        query: String::new(),
                        entries: Vec::new(),
                        loading: true,
                        truncated: false,
                    },
                });

                existing_popup.dock_item = dock_item;
                existing_popup.popup_type = PopupType::LauncherEditor;

                return Task::perform(
                    icon_catalog::load_icon_catalog(icon_theme, original_icon),
                    |catalog| cosmic::Action::App(Message::LauncherIconCatalogLoaded(catalog)),
                );
            }
            Message::LauncherNameChanged(name) => {
                if let Some(edit) = self.launcher_edit.as_mut()
                    && !edit.saving
                {
                    edit.name = name;
                    edit.error = None;
                }
            }
            Message::LauncherExecChanged(exec) => {
                if let Some(edit) = self.launcher_edit.as_mut()
                    && !edit.saving
                {
                    edit.exec = exec;
                    edit.error = None;
                }
            }
            Message::LauncherIconChanged(icon) => {
                if let Some(edit) = self.launcher_edit.as_mut()
                    && !edit.saving
                {
                    edit.icon = icon;
                    edit.error = None;
                }
            }
            Message::LauncherIconSearchChanged(query) => {
                if let Some(edit) = self.launcher_edit.as_mut() {
                    edit.icon_catalog.query = query;
                }
            }
            Message::LauncherIconSelected(icon) => {
                if let Some(edit) = self.launcher_edit.as_mut()
                    && !edit.saving
                {
                    edit.icon = icon;
                    edit.error = None;
                }
            }
            Message::ReloadLauncherIconCatalog => {
                if let Some(edit) = self.launcher_edit.as_mut() {
                    edit.icon_catalog.theme = cosmic::icon_theme::default();
                    edit.icon_catalog.entries.clear();
                    edit.icon_catalog.loading = true;
                    edit.icon_catalog.truncated = false;

                    return Task::perform(
                        icon_catalog::load_icon_catalog(
                            edit.icon_catalog.theme.clone(),
                            edit.icon.clone(),
                        ),
                        |catalog| cosmic::Action::App(Message::LauncherIconCatalogLoaded(catalog)),
                    );
                }
            }
            Message::LauncherIconCatalogLoaded(catalog) => {
                if let Some(edit) = self.launcher_edit.as_mut()
                    && edit.icon_catalog.theme == catalog.theme
                {
                    edit.icon_catalog.entries = catalog.entries;
                    edit.icon_catalog.loading = false;
                    edit.icon_catalog.truncated = catalog.truncated;
                }
            }
            Message::SaveLauncherEdit => {
                let Some(edit) = self.launcher_edit.as_mut() else {
                    return Task::none();
                };
                if edit.saving {
                    return Task::none();
                }
                if let Err(error) =
                    launcher_edit::validate_launcher_fields(&edit.name, &edit.exec, &edit.icon)
                {
                    edit.error = Some(error);
                    return Task::none();
                }

                let request = LauncherEditRequest {
                    current_app_id: edit.original_app_id.clone(),
                    source_path: edit.source_path.clone(),
                    name: edit.name.clone(),
                    exec: edit.exec.clone(),
                    icon: edit.icon.clone(),
                    terminal: edit.terminal,
                    replace_localized_name: edit.name.trim() != edit.original_name.trim(),
                    disable_dbus_activation: edit.exec.trim() != edit.original_exec.trim(),
                };

                edit.saving = true;
                edit.error = None;

                return Task::perform(launcher_edit::save_launcher_edit(request), |result| {
                    cosmic::Action::App(Message::LauncherEditSaved(result))
                });
            }
            Message::CancelLauncherEdit => {
                return self.close_popups();
            }
            Message::LauncherEditSaved(result) => match result {
                Ok(result) => {
                    tracing::info!(
                        app_id = result.new_app_id,
                        path = ?result.path,
                        "saved editable launcher"
                    );

                    let mut favorites = self.config.favorites.clone();
                    let mut favorites_changed = false;
                    for favorite in &mut favorites {
                        if *favorite == result.old_app_id && *favorite != result.new_app_id {
                            *favorite = result.new_app_id.clone();
                            favorites_changed = true;
                        }
                    }

                    if favorites_changed {
                        self.config.update_pinned(
                            favorites.clone(),
                            &Config::new(APP_ID, AppListConfig::VERSION).unwrap(),
                        );
                        self.config.favorites = favorites;
                    }

                    self.update_desktop_entries();
                    self.sync_pinned_list_from_config();
                    self.launcher_edit = None;
                    return self.close_popups();
                }
                Err(error) => {
                    if let Some(edit) = self.launcher_edit.as_mut() {
                        edit.saving = false;
                        edit.error = Some(error);
                    }
                }
            },
            Message::Activate(handle) => {
                if let Some(tx) = self.wayland_sender.as_ref() {
                    let _ = tx.send(WaylandRequest::Toplevel(ToplevelRequest::Activate(handle)));
                }
                if let Some(p) = self.popup.take() {
                    return destroy_popup(p.id);
                }
            }
            Message::Toggle(handle) => {
                if let Some(tx) = self.wayland_sender.as_ref() {
                    let _ = tx.send(WaylandRequest::Toplevel(if self.is_focused(&handle) {
                        ToplevelRequest::Minimize(handle)
                    } else {
                        ToplevelRequest::Activate(handle)
                    }));
                }
                if let Some(p) = self.popup.take() {
                    return destroy_popup(p.id);
                }
            }
            Message::CloseToplevel(handle) => {
                if let Some(tx) = self.wayland_sender.as_ref() {
                    let _ = tx.send(WaylandRequest::Toplevel(ToplevelRequest::Quit(handle)));
                }
            }
            Message::Quit(id) => {
                if let Some(toplevel_group) = self
                    .active_list
                    .iter()
                    .chain(self.pinned_list.iter())
                    .find(|t| t.desktop_info.id() == id)
                {
                    for (info, _) in &toplevel_group.toplevels {
                        if let Some(tx) = self.wayland_sender.as_ref() {
                            let _ = tx.send(WaylandRequest::Toplevel(ToplevelRequest::Quit(
                                info.foreign_toplevel.clone(),
                            )));
                        }
                    }
                }
                if let Some(Popup { id: popup_id, .. }) = self.popup.take() {
                    return destroy_popup(popup_id);
                }
            }
            Message::StartDrag(id) => {
                if let Some((_, toplevel_group, pos)) = self
                    .active_list
                    .iter()
                    .find_map(|t| {
                        if t.id == id {
                            Some((false, t.clone(), None))
                        } else {
                            None
                        }
                    })
                    .or_else(|| {
                        self.pinned_list
                            .iter()
                            .position(|t| t.id == id)
                            .map(|pos| (true, self.pinned_list[pos].clone(), Some(pos)))
                    })
                {
                    let icon_id = window::Id::unique();
                    self.dnd_source =
                        Some((icon_id, toplevel_group.clone(), DndAction::empty(), pos));
                }
            }
            Message::DragFinished => {
                if let Some((_, mut toplevel_group, _, _pinned_pos)) = self.dnd_source.take() {
                    if self.dnd_offer.take().is_some() {
                        if let Some((_, toplevel_group, _, pinned_pos)) = self.dnd_source.as_ref() {
                            let mut pos = 0;
                            self.pinned_list.retain_mut(|pinned| {
                                let matched_id =
                                    pinned.desktop_info.id() == toplevel_group.desktop_info.id();
                                let pinned_match =
                                    pinned_pos.is_some_and(|pinned_pos| pinned_pos == pos);
                                let ret = !matched_id || pinned_match;

                                pos += 1;
                                ret
                            });
                        }
                    }

                    if !self
                        .pinned_list
                        .iter()
                        .chain(self.active_list.iter())
                        .any(|t| t.desktop_info.id() == toplevel_group.desktop_info.id())
                        && !toplevel_group.toplevels.is_empty()
                    {
                        self.item_ctr += 1;
                        toplevel_group.id = self.item_ctr;
                        self.active_list.push(toplevel_group);
                    }
                }
            }
            Message::DndEnter(x, y) => {
                let item_size = self.core.applet.suggested_size(false).0
                    + 2 * self.core.applet.suggested_padding(false).0;
                let pos_in_list = match self.core.applet.anchor {
                    PanelAnchor::Top | PanelAnchor::Bottom => x as f32,
                    PanelAnchor::Left | PanelAnchor::Right => y as f32,
                };
                let num_pinned = self.pinned_list.len();
                let index = index_in_list(num_pinned, item_size as f32, 4.0, None, pos_in_list);
                self.dnd_offer = Some(DndOffer {
                    preview_index: index,
                    ..DndOffer::default()
                });
                if let Some(dnd_source) = self.dnd_source.as_ref() {
                    self.dnd_offer.as_mut().unwrap().dock_item = Some(dnd_source.1.clone());
                } else {
                    // TODO dnd
                    return peek_dnd::<DndPathBuf>()
                        .map(Message::DndData)
                        .map(cosmic::Action::App);
                }
            }
            Message::DndMotion(x, y) => {
                let item_size = self.core.applet.suggested_size(false).0
                    + 2 * self.core.applet.suggested_padding(false).0;
                let pos_in_list = match self.core.applet.anchor {
                    PanelAnchor::Top | PanelAnchor::Bottom => x as f32,
                    PanelAnchor::Left | PanelAnchor::Right => y as f32,
                };
                let num_pinned = self.pinned_list.len();
                let index = index_in_list(
                    num_pinned,
                    item_size as f32,
                    4.0,
                    self.dnd_offer.as_ref().map(|o| o.preview_index),
                    pos_in_list,
                );
                if let Some(o) = self.dnd_offer.as_mut() {
                    o.preview_index = index;
                }
            }
            Message::DndLeave => {
                if let Some((_, toplevel_group, _, pinned_pos)) = self.dnd_source.as_ref() {
                    let mut pos = 0;
                    self.pinned_list.retain_mut(|pinned| {
                        let matched_id =
                            pinned.desktop_info.id() == toplevel_group.desktop_info.id();
                        let pinned_match = pinned_pos.is_some_and(|pinned_pos| pinned_pos == pos);
                        let ret = !matched_id || pinned_match;

                        pos += 1;
                        ret
                    });
                }
                self.dnd_offer = None;
            }
            Message::DndData(file_path) => {
                let Some(file_path) = file_path else {
                    tracing::error!("Couldn't peek at hovered path.");
                    return Task::none();
                };
                if let Some(DndOffer { dock_item, .. }) = self.dnd_offer.as_mut() {
                    if let Ok(de) = fde::DesktopEntry::from_path(file_path.0, Some(&self.locales)) {
                        self.item_ctr += 1;
                        *dock_item = Some(DockItem {
                            id: self.item_ctr,
                            toplevels: Vec::new(),
                            original_app_id: de.id().to_string(),
                            desktop_info: de,
                        });
                    }
                }
            }
            Message::DndDropFinished => {
                // we actually should have the data already, if not, we probably shouldn't do
                // anything anyway
                if let Some((mut dock_item, index)) = self
                    .dnd_offer
                    .take()
                    .and_then(|o| o.dock_item.map(|i| (i, o.preview_index)))
                {
                    self.item_ctr += 1;

                    if let Some((pos, is_pinned)) = self
                        .active_list
                        .iter()
                        .position(|de| de.original_app_id == dock_item.original_app_id)
                        .map(|pos| (pos, false))
                        .or_else(|| {
                            self.pinned_list
                                .iter()
                                .position(|de| de.original_app_id == dock_item.original_app_id)
                                .map(|pos| (pos, true))
                        })
                    {
                        let t = if is_pinned {
                            let t = self.pinned_list.remove(pos);
                            self.config.remove_pinned(
                                &t.original_app_id,
                                &Config::new(APP_ID, AppListConfig::VERSION).unwrap(),
                            );
                            t
                        } else {
                            self.active_list.remove(pos)
                        };
                        dock_item.toplevels = t.toplevels;
                    }
                    dock_item.id = self.item_ctr;

                    if dock_item.desktop_info.exec().is_some() {
                        self.pinned_list
                            .insert(index.min(self.pinned_list.len()), dock_item);
                        self.config.update_pinned(
                            self.pinned_list
                                .iter()
                                .map(|dock_item| dock_item.original_app_id.clone())
                                .collect(),
                            &Config::new(APP_ID, AppListConfig::VERSION).unwrap(),
                        );
                    }
                }
            }
            Message::Wayland(event) => {
                match event {
                    WaylandUpdate::Init(tx) => {
                        self.wayland_sender.replace(tx);
                    }
                    WaylandUpdate::Image(handle, img) => {
                        'img_update: for x in self
                            .active_list
                            .iter_mut()
                            .chain(self.pinned_list.iter_mut())
                        {
                            if let Some((_, handle_img)) = x
                                .toplevels
                                .iter_mut()
                                .find(|(info, _)| info.foreign_toplevel == handle)
                            {
                                *handle_img = Some(img);
                                break 'img_update;
                            }
                        }
                    }
                    WaylandUpdate::Finished => {
                        for t in &mut self.pinned_list {
                            t.toplevels.clear();
                        }
                        self.active_list.clear();
                        let subscription_ctr = self.subscription_ctr;
                        let rand_d = fastrand::u64(0..100);
                        return iced::Task::perform(
                            async move {
                                if let Some(millis) = 2u64
                                    .checked_pow(subscription_ctr)
                                    .and_then(|d| d.checked_add(rand_d))
                                {
                                    sleep(Duration::from_millis(millis)).await;
                                } else {
                                    pending::<()>().await;
                                }
                            },
                            |()| Message::IncrementSubscriptionCtr,
                        )
                        .map(cosmic::action::app);
                    }
                    WaylandUpdate::Toplevel(event) => match event {
                        ToplevelUpdate::Add(mut info) => {
                            let unicase_appid = fde::unicase::Ascii::new(&*info.app_id);
                            let new_desktop_info =
                                self.find_desktop_entry_for_toplevel(&info, unicase_appid);

                            if let Some(t) = self
                                .active_list
                                .iter_mut()
                                .chain(self.pinned_list.iter_mut())
                                .find(|DockItem { desktop_info, .. }| {
                                    desktop_info.id() == new_desktop_info.id()
                                })
                            {
                                t.toplevels.push((info, None));
                            } else {
                                if info.app_id.is_empty() {
                                    info.app_id = format!("Unknown Application {}", self.item_ctr);
                                }
                                self.item_ctr += 1;

                                self.active_list.push(DockItem {
                                    id: self.item_ctr,
                                    original_app_id: info.app_id.clone(),
                                    toplevels: vec![(info, None)],
                                    desktop_info: new_desktop_info,
                                });
                            }
                        }
                        ToplevelUpdate::Remove(handle) => {
                            for t in self
                                .active_list
                                .iter_mut()
                                .chain(self.pinned_list.iter_mut())
                            {
                                t.toplevels
                                    .retain(|(info, _)| info.foreign_toplevel != handle);
                            }
                            self.active_list.retain(|t| !t.toplevels.is_empty());

                            if let Some(popup) = &mut self.popup
                                && popup.popup_type == PopupType::ToplevelList
                            {
                                popup
                                    .dock_item
                                    .toplevels
                                    .retain(|(info, _)| info.foreign_toplevel != handle);

                                if popup.dock_item.toplevels.is_empty() {
                                    let id = popup.id;
                                    self.popup = None;
                                    return destroy_popup(id);
                                }
                            }
                        }
                        ToplevelUpdate::Update(info) => {
                            // TODO probably want to make sure it is removed
                            if info.app_id.is_empty() {
                                return Task::none();
                            }
                            let mut updated_appid = false;

                            'toplevel_loop: for toplevel_list in self
                                .active_list
                                .iter_mut()
                                .chain(self.pinned_list.iter_mut())
                            {
                                for (t_info, _) in &mut toplevel_list.toplevels {
                                    if info.foreign_toplevel == t_info.foreign_toplevel {
                                        if info.app_id != t_info.app_id {
                                            updated_appid = true;
                                        }

                                        *t_info = info.clone();
                                        break 'toplevel_loop;
                                    }
                                }
                            }

                            if updated_appid {
                                // remove the current toplevel from its dock item
                                for t in self
                                    .active_list
                                    .iter_mut()
                                    .chain(self.pinned_list.iter_mut())
                                {
                                    t.toplevels
                                        .retain(|(t_info, _)| t_info.app_id != info.app_id);
                                }
                                self.active_list.retain(|t| !t.toplevels.is_empty());

                                // find a new one for it
                                let new_desktop_entry = self.find_desktop_entry_for_toplevel(
                                    &info,
                                    Ascii::new(&info.app_id),
                                );

                                if let Some(t) = self
                                    .active_list
                                    .iter_mut()
                                    .chain(self.pinned_list.iter_mut())
                                    .find(|DockItem { desktop_info, .. }| {
                                        desktop_info.id() == new_desktop_entry.id()
                                    })
                                {
                                    t.toplevels.push((info, None));
                                } else {
                                    self.item_ctr += 1;

                                    self.active_list.push(DockItem {
                                        id: self.item_ctr,
                                        original_app_id: info.app_id.clone(),
                                        toplevels: vec![(info, None)],
                                        desktop_info: new_desktop_entry,
                                    });
                                }
                            }
                        }
                    },
                    WaylandUpdate::Workspace(workspaces) => self.active_workspaces = workspaces,
                    WaylandUpdate::Output(event) => match event {
                        OutputUpdate::Add(output, info) => {
                            self.output_list.insert(output, info);
                        }
                        OutputUpdate::Update(output, info) => {
                            self.output_list.insert(output, info);
                        }
                        OutputUpdate::Remove(output) => {
                            self.output_list.remove(&output);
                        }
                    },
                    WaylandUpdate::ActivationToken {
                        token,
                        app_id,
                        exec,
                        gpu_idx,
                        terminal,
                    } => {
                        let mut envs = Vec::new();
                        if let Some(token) = token {
                            envs.push(("XDG_ACTIVATION_TOKEN".to_string(), token.clone()));
                            envs.push(("DESKTOP_STARTUP_ID".to_string(), token));
                        }
                        if let (Some(gpus), Some(idx)) = (self.gpus.as_ref(), gpu_idx) {
                            envs.extend(
                                gpus[idx]
                                    .environment
                                    .iter()
                                    .map(|(k, v)| (k.clone(), v.clone())),
                            );
                        }
                        tokio::spawn(async move {
                            cosmic::desktop::spawn_desktop_exec(
                                exec,
                                envs,
                                app_id.as_deref(),
                                terminal,
                            )
                            .await;
                        });
                    }
                }
            }
            Message::NewSeat(s) => {
                self.seat.replace(s);
            }
            Message::RemovedSeat => {
                self.seat.take();
            }
            Message::Exec(exec, gpu_idx, terminal) => {
                if let Some(tx) = self.wayland_sender.as_ref() {
                    let _ = tx.send(WaylandRequest::TokenRequest {
                        app_id: Self::APP_ID.to_string(),
                        exec,
                        gpu_idx,
                        terminal,
                    });
                }
            }
            Message::Rectangle(u) => match u {
                RectangleUpdate::Rectangle(r) => {
                    self.rectangles.insert(r.0, r.1);
                }
                RectangleUpdate::Init(tracker) => {
                    self.rectangle_tracker.replace(tracker);
                }
            },
            Message::ClosePopup => {
                if let Some(p) = self.popup.take() {
                    if p.popup_type == PopupType::LauncherEditor {
                        self.launcher_edit = None;
                    }
                    return destroy_popup(p.id);
                }
            }
            Message::StartListeningForDnd => {
                self.is_listening_for_dnd = true;
            }
            Message::StopListeningForDnd => {
                self.is_listening_for_dnd = false;
            }
            Message::IncrementSubscriptionCtr => {
                self.subscription_ctr += 1;
            }
            Message::ConfigUpdated(config) => {
                self.config = config;
                self.update_desktop_entries();
                self.sync_pinned_list_from_config();
            }
            Message::CloseRequested(id) => {
                if let Some(popup) = &self.popup
                    && popup.id == id
                {
                    if popup.popup_type == PopupType::LauncherEditor {
                        self.launcher_edit = None;
                    }
                    self.popup = None;
                }
                if self.overflow_active_popup.is_some_and(|p| p == id) {
                    self.overflow_active_popup = None;
                }
                if self.overflow_favorites_popup.is_some_and(|p| p == id) {
                    self.overflow_favorites_popup = None;
                }
            }
            Message::GpuRequest(gpus) => {
                self.gpus = gpus;
            }
            Message::DockItemHover(id) => {
                self.hovered_dock_item = id;
                // Seed the animated center on the very first hover so
                // the bell doesn't "fly in" from (0,0).
                if self.anim_hover_center.is_none()
                    && let Some(hovered_id) = self.hovered_dock_item.as_ref()
                    && let Some(r) = self.rectangles.get(hovered_id)
                {
                    self.anim_hover_center = Some((
                        r.x + r.width / 2.0,
                        r.y + r.height / 2.0,
                    ));
                }
            }
            Message::AnimTick(now) => {
                // dt-based exponential smoothing: reach ~99% of the
                // target in ~120ms at 60fps (about 7 ticks).
                let dt = self
                    .anim_last_tick
                    .map(|prev| now.saturating_duration_since(prev).as_secs_f32())
                    .unwrap_or(0.016)
                    .min(0.1); // clamp so a long pause doesn't snap
                self.anim_last_tick = Some(now);

                // Intensity: target 1.0 when any icon is hovered, 0.0 else.
                let intensity_target = if self.hovered_dock_item.is_some() { 1.0 } else { 0.0 };
                let tau = 0.060_f32; // time-constant (s); smaller = snappier
                let alpha = 1.0 - (-dt / tau).exp();
                self.anim_hover_intensity += (intensity_target - self.anim_hover_intensity) * alpha;

                // Hovered-center smoothing: chase the real rect's center.
                if let Some(hovered_id) = self.hovered_dock_item.as_ref()
                    && let Some(r) = self.rectangles.get(hovered_id)
                {
                    let target = (r.x + r.width / 2.0, r.y + r.height / 2.0);
                    let current = self.anim_hover_center.unwrap_or(target);
                    self.anim_hover_center = Some((
                        current.0 + (target.0 - current.0) * alpha,
                        current.1 + (target.1 - current.1) * alpha,
                    ));
                } else if self.anim_hover_intensity < 0.01 {
                    // Nothing hovered + intensity faded out → forget the
                    // animated center so the next hover seeds fresh.
                    self.anim_hover_center = None;
                }
            }
            Message::OpenActive => {
                let create_new = self.overflow_active_popup.is_none();
                let mut cmds = vec![self.close_popups()];

                // create a popup with the active list
                if create_new {
                    let new_id = window::Id::unique();
                    self.overflow_active_popup = Some(new_id);
                    let rectangle = self.rectangles.get(&DockItemId::ActiveOverflow);
                    let mut popup_settings = self.core.applet.get_popup_settings(
                        self.core.main_window_id().unwrap(),
                        new_id,
                        None,
                        None,
                        None,
                    );
                    if let Some(iced::Rectangle {
                        x,
                        y,
                        width,
                        height,
                    }) = rectangle
                    {
                        popup_settings.positioner.anchor_rect = iced::Rectangle::<i32> {
                            x: *x as i32,
                            y: *y as i32,
                            width: *width as i32,
                            height: *height as i32,
                        };
                    }
                    let applet_suggested_size = self.core.applet.suggested_size(false).0
                        + 2 * self.core.applet.suggested_padding(false).0;
                    let (_favorite_popup_cutoff, active_popup_cutoff) =
                        self.panel_overflow_lengths();
                    let popup_applet_count =
                        self.active_list.len().saturating_sub(
                            (active_popup_cutoff.unwrap_or_default()).saturating_sub(1),
                        ) as f32;
                    let popup_applet_size = applet_suggested_size as f32 * popup_applet_count
                        + 4.0 * (popup_applet_count - 1.);
                    let (max_width, max_height) = match self.core.applet.anchor {
                        PanelAnchor::Top | PanelAnchor::Bottom => {
                            (popup_applet_size, applet_suggested_size as f32)
                        }
                        PanelAnchor::Left | PanelAnchor::Right => {
                            (applet_suggested_size as f32, popup_applet_size)
                        }
                    };
                    popup_settings.positioner.size_limits = Limits::NONE
                        .max_width(max_width)
                        .min_width(1.)
                        .max_height(max_height)
                        .min_height(1.);
                    cmds.push(get_popup(popup_settings));
                }
                return Task::batch(cmds);
            }
            Message::OpenFavorites => {
                let create_new = self.overflow_favorites_popup.is_none();
                let mut cmds = vec![self.close_popups()];

                // create a popup with the favorites list
                if create_new {
                    let new_id = window::Id::unique();
                    self.overflow_favorites_popup = Some(new_id);
                    let rectangle = self.rectangles.get(&DockItemId::FavoritesOverflow);
                    let mut popup_settings = self.core.applet.get_popup_settings(
                        self.core.main_window_id().unwrap(),
                        new_id,
                        None,
                        None,
                        None,
                    );
                    if let Some(iced::Rectangle {
                        x,
                        y,
                        width,
                        height,
                    }) = rectangle
                    {
                        popup_settings.positioner.anchor_rect = iced::Rectangle::<i32> {
                            x: *x as i32,
                            y: *y as i32,
                            width: *width as i32,
                            height: *height as i32,
                        };
                    }
                    let applet_suggested_size = self.core.applet.suggested_size(false).0
                        + 2 * self.core.applet.suggested_padding(false).0;
                    let (favorite_popup_cutoff, _active_popup_cutoff) =
                        self.panel_overflow_lengths();
                    let popup_applet_count =
                        self.pinned_list.len().saturating_sub(
                            favorite_popup_cutoff.unwrap_or_default().saturating_sub(1),
                        ) as f32;
                    let popup_applet_size = applet_suggested_size as f32 * popup_applet_count
                        + 4.0 * (popup_applet_count - 1.);
                    let (max_width, max_height) = match self.core.applet.anchor {
                        PanelAnchor::Top | PanelAnchor::Bottom => {
                            (popup_applet_size, applet_suggested_size as f32)
                        }
                        PanelAnchor::Left | PanelAnchor::Right => {
                            (applet_suggested_size as f32, popup_applet_size)
                        }
                    };
                    popup_settings.positioner.size_limits = Limits::NONE
                        .max_width(max_width)
                        .min_width(1.)
                        .max_height(max_height)
                        .min_height(1.);
                    cmds.push(get_popup(popup_settings));
                }
                return Task::batch(cmds);
            }
            Message::Pressed(id) => {
                if self.popup.is_some() && self.core.main_window_id() == Some(id) {
                    return self.close_popups();
                }
            }
            Message::Surface(a) => {
                return cosmic::task::message(cosmic::Action::Cosmic(
                    cosmic::app::Action::Surface(a),
                ));
            }
        }

        Task::none()
    }

    fn view(&self) -> Element<'_, Message> {
        let focused_item = self.currently_active_toplevel();
        let theme = self.core.system_theme();
        let dot_radius = theme.cosmic().radius_xs();
        let app_icon = AppletIconData::new(&self.core.applet);
        let is_horizontal = match self.core.applet.anchor {
            PanelAnchor::Top | PanelAnchor::Bottom => true,
            PanelAnchor::Left | PanelAnchor::Right => false,
        };
        let divider_padding = match self.core.applet.size {
            Size::Hardcoded(_) => 4,
            Size::PanelSize(ref s) => {
                let size = s.get_applet_icon_size_with_padding(false);

                let small_size_threshold = PanelSize::S.get_applet_icon_size_with_padding(false);

                if size <= small_size_threshold { 4 } else { 8 }
            }
        };
        let (favorite_popup_cutoff, active_popup_cutoff) = self.panel_overflow_lengths();
        let mut favorite_to_remove = if let Some(cutoff) = favorite_popup_cutoff {
            if cutoff < self.pinned_list.len() {
                self.pinned_list.len() - cutoff + 1
            } else {
                0
            }
        } else {
            0
        };
        let favorites: Vec<_> = self
            .pinned_list
            .iter()
            .rev()
            .filter(|f| {
                if favorite_to_remove > 0 && f.toplevels.is_empty() {
                    favorite_to_remove -= 1;
                    false
                } else {
                    true
                }
            })
            .collect();
        let mut favorites: Vec<_> = favorites[favorite_to_remove..]
            .iter()
            .rev()
            .map(|dock_item| {
                let filtered_is_focused = dock_item
                    .toplevels
                    .iter()
                    .filter(|(info, _)| self.is_on_current_monitor_and_workspace(info))
                    .any(|y| focused_item.contains(&y.0.foreign_toplevel));

                let dock_id = dock_item.id;
                let icon_scale = self.icon_scale_for(&DockItemId::from(dock_id));
                let tooltip = self.core
                    .applet
                    .applet_tooltip::<Message>(
                        dock_item.as_icon(
                            &self.core.applet,
                            self.rectangle_tracker.as_ref(),
                            self.popup.is_none(),
                            self.config.enable_drag_source,
                            self.gpus.as_deref(),
                            filtered_is_focused,
                            dot_radius,
                            self.core.main_window_id().unwrap(),
                            Some(&|info| self.is_on_current_monitor_and_workspace(info)),
                            icon_scale,
                        ),
                        dock_item
                            .desktop_info
                            .full_name(&self.locales)
                            .unwrap_or_default()
                            .into_owned(),
                        self.popup.is_some(),
                        Message::Surface,
                        None,
                    );
                cosmic::widget::mouse_area(tooltip)
                    .on_enter(Message::DockItemHover(Some(DockItemId::from(dock_id))))
                    .on_exit(Message::DockItemHover(None))
                    .into()
            })
            .collect();

        if favorite_popup_cutoff.is_some() {
            // button to show more favorites
            let icon = match self.core.applet.anchor {
                PanelAnchor::Bottom => "go-up-symbolic",
                PanelAnchor::Left => "go-next-symbolic",
                PanelAnchor::Right => "go-previous-symbolic",
                PanelAnchor::Top => "go-down-symbolic",
            };
            let btn = self
                .core
                .applet
                .icon_button(icon)
                .on_press(Message::OpenFavorites);
            let btn: Element<_> = if let Some(rectangle_tracker) = self.rectangle_tracker.as_ref() {
                rectangle_tracker
                    .container(DockItemId::FavoritesOverflow, btn)
                    .into()
            } else {
                btn.into()
            };
            favorites.push(btn);
        }

        if let Some((item, index)) = self
            .dnd_offer
            .as_ref()
            .and_then(|o| o.dock_item.as_ref().map(|item| (item, o.preview_index)))
        {
            let filtered_is_focused = item
                .toplevels
                .iter()
                .filter(|(info, _)| self.is_on_current_monitor_and_workspace(info))
                .any(|y| focused_item.contains(&y.0.foreign_toplevel));

            favorites.insert(
                index.min(favorites.len()),
                item.as_icon(
                    &self.core.applet,
                    None,
                    false,
                    self.config.enable_drag_source,
                    self.gpus.as_deref(),
                    filtered_is_focused,
                    dot_radius,
                    self.core.main_window_id().unwrap(),
                    Some(&|info| self.is_on_current_monitor_and_workspace(info)),
                    // Yoda: no magnification on DnD-preview icons — these
                    // float around as the user drags, so static 1.0 is
                    // less visually confusing.
                    1.0,
                ),
            );
        } else if self.is_listening_for_dnd && self.pinned_list.is_empty() {
            // show star indicating pinned_list is drag target
            favorites.push(
                container(
                    icon::from_name("starred-symbolic.symbolic")
                        .size(self.core.applet.suggested_size(false).0),
                )
                .padding(self.core.applet.suggested_padding(false).1) // TODO
                .into(),
            );
        }

        let filtered_active_list: Vec<_> = self
            .active_list
            .iter()
            .filter(|dock_item| {
                dock_item.toplevels.iter().any(|(toplevel_info, _)| {
                    self.is_on_current_monitor_and_workspace(toplevel_info)
                })
            })
            .collect();

        let mut active: Vec<_> =
            filtered_active_list[..active_popup_cutoff.map_or(filtered_active_list.len(), |n| {
                if n < filtered_active_list.len() {
                    n.saturating_sub(1)
                } else {
                    n
                }
            })]
                .iter()
                .map(|dock_item| {
                    let filtered_is_focused = dock_item
                        .toplevels
                        .iter()
                        .filter(|(info, _)| self.is_on_current_monitor_and_workspace(info))
                        .any(|y| focused_item.contains(&y.0.foreign_toplevel));
                    let dock_id = dock_item.id;
                    let icon_scale = self.icon_scale_for(&DockItemId::from(dock_id));

                    let tooltip = self.core
                        .applet
                        .applet_tooltip(
                            dock_item.as_icon(
                                &self.core.applet,
                                self.rectangle_tracker.as_ref(),
                                self.popup.is_none(),
                                self.config.enable_drag_source,
                                self.gpus.as_deref(),
                                filtered_is_focused,
                                dot_radius,
                                self.core.main_window_id().unwrap(),
                                Some(&|info| self.is_on_current_monitor_and_workspace(info)),
                                icon_scale,
                            ),
                            dock_item
                                .desktop_info
                                .full_name(&self.locales)
                                .unwrap_or_default()
                                .into_owned(),
                            self.popup.is_some(),
                            Message::Surface,
                            None,
                        );
                    cosmic::widget::mouse_area(tooltip)
                        .on_enter(Message::DockItemHover(Some(DockItemId::from(dock_id))))
                        .on_exit(Message::DockItemHover(None))
                        .into()
                })
                .collect();

        if active_popup_cutoff.is_some_and(|n| n < filtered_active_list.len()) {
            // button to show more active
            let icon = match self.core.applet.anchor {
                PanelAnchor::Bottom => "go-up-symbolic",
                PanelAnchor::Left => "go-next-symbolic",
                PanelAnchor::Right => "go-previous-symbolic",
                PanelAnchor::Top => "go-down-symbolic",
            };
            let btn = self
                .core
                .applet
                .icon_button(icon)
                .on_press(Message::OpenActive);
            let btn: Element<_> = if let Some(rectangle_tracker) = self.rectangle_tracker.as_ref() {
                rectangle_tracker
                    .container(DockItemId::ActiveOverflow, btn)
                    .into()
            } else {
                btn.into()
            };
            active.push(btn);
        }

        let window_size = self.core.applet.suggested_bounds.as_ref();
        let max_num = if self.core.applet.is_horizontal() {
            let suggested_width = self.core.applet.suggested_size(false).0
                + self.core.applet.suggested_padding(false).0 * 2;
            window_size
                .map(|w| w.width)
                .map_or(u32::MAX, |b| (b / suggested_width as f32) as u32) as usize
        } else {
            let suggested_height = self.core.applet.suggested_size(false).1
                + self.core.applet.suggested_padding(false).0 * 2;
            window_size
                .map(|w| w.height)
                .map_or(u32::MAX, |b| (b / suggested_height as f32) as u32) as usize
        }
        .max(4);
        if max_num < favorites.len() + active.len() {
            let active_leftover = max_num.saturating_sub(favorites.len());
            favorites.truncate(max_num - active_leftover);
            active.truncate(active_leftover);
        }
        let (w, h, favorites, active, divider) = if is_horizontal {
            (
                Length::Shrink,
                Length::Shrink,
                DndDestination::for_data::<DndPathBuf>(
                    row(favorites).spacing(app_icon.icon_spacing),
                    |_, _| Message::DndDropFinished,
                )
                .drag_id(DND_FAVORITES),
                row(active).spacing(app_icon.icon_spacing).into(),
                container(vertical_rule(1))
                    .height(Length::Fill)
                    .padding([divider_padding, 0])
                    .into(),
            )
        } else {
            (
                Length::Shrink,
                Length::Shrink,
                DndDestination::for_data(
                    column(favorites).spacing(app_icon.icon_spacing),
                    |_data: Option<DndPathBuf>, _| Message::DndDropFinished,
                )
                .drag_id(DND_FAVORITES),
                column(active).spacing(app_icon.icon_spacing).into(),
                container(divider::horizontal::default())
                    .width(Length::Fill)
                    .padding([0, divider_padding])
                    .into(),
            )
        };

        let favorites = favorites
            .on_enter(|x, y, _| Message::DndEnter(x, y))
            .on_motion(Message::DndMotion)
            .on_leave(|| Message::DndLeave);

        let show_pinned =
            !self.pinned_list.is_empty() || self.dnd_offer.is_some() || self.is_listening_for_dnd;
        let content_list: Vec<Element<_>> = if show_pinned && !self.active_list.is_empty() {
            vec![favorites.into(), divider, active]
        } else if show_pinned {
            vec![favorites.into()]
        } else if !self.active_list.is_empty() {
            vec![active]
        } else {
            vec![
                icon::from_name("com.system76.CosmicAppList")
                    .size(self.core.applet.suggested_size(false).0)
                    .into(),
            ]
        };

        let mut content = match &self.core.applet.anchor {
            PanelAnchor::Left | PanelAnchor::Right => container(
                Column::with_children(content_list)
                    .spacing(4.0)
                    .align_x(Alignment::Center)
                    .height(h)
                    .width(w),
            ),
            PanelAnchor::Top | PanelAnchor::Bottom => container(
                Row::with_children(content_list)
                    .spacing(4.0)
                    .align_y(Alignment::Center)
                    .height(h)
                    .width(w),
            ),
        };
        if self.active_list.is_empty() && self.pinned_list.is_empty() {
            let suggested_size = self.core.applet.suggested_size(false);
            content = content.width(suggested_size.0).height(suggested_size.1);
        }

        let mut limits = Limits::NONE.min_width(1.).min_height(1.);

        if let Some(b) = self.core.applet.suggested_bounds {
            if b.width as i32 > 0 {
                limits = limits.max_width(b.width);
            }
            if b.height as i32 > 0 {
                limits = limits.max_height(b.height);
            }
        }

        self.core
            .applet
            .autosize_window(content)
            .limits(limits)
            .into()
    }

    fn view_window(&self, id: window::Id) -> Element<'_, Message> {
        let theme = self.core.system_theme();

        if let Some((_, item, _, _)) = self.dnd_source.as_ref().filter(|s| s.0 == id) {
            cosmic::widget::icon(
                fde::IconSource::from_unknown(item.desktop_info.icon().unwrap_or_default())
                    .as_cosmic_icon(),
            )
            .size(self.core.applet.suggested_size(false).0)
            .into()
        } else if let Some(Popup {
            dock_item: DockItem { id, .. },
            popup_type,
            ..
        }) = self.popup.as_ref().filter(|p| id == p.id)
        {
            let (dock_item, is_pinned) = match self.pinned_list.iter().find(|i| i.id == *id) {
                Some(e) => (e, true),
                None => match self.active_list.iter().find(|i| i.id == *id) {
                    Some(e) => (e, false),
                    None => return text::body("").into(),
                },
            };

            // Filter toplevels to only show windows on current monitor and workspace
            let filtered_toplevels: Vec<_> = dock_item
                .toplevels
                .iter()
                .filter(|(toplevel_info, _)| {
                    self.is_on_current_monitor_and_workspace(toplevel_info)
                })
                .collect();

            let toplevels = &filtered_toplevels;
            let desktop_info = &dock_item.desktop_info;

            match popup_type {
                PopupType::RightClickMenu => {
                    fn menu_button<'a, Message: Clone + 'a>(
                        content: impl Into<Element<'a, Message>>,
                    ) -> cosmic::widget::Button<'a, Message> {
                        button::custom(content)
                            .height(20 + 2 * theme::spacing().space_xxs)
                            .class(Button::MenuItem)
                            .padding(menu_control_padding())
                            .width(Length::Fill)
                    }

                    let mut content = column![].align_x(Alignment::Center);

                    if let Some(exec) = desktop_info.exec() {
                        if !toplevels.is_empty() {
                            content =
                                content.push(menu_button(text::body(fl!("new-window"))).on_press(
                                    Message::Exec(exec.to_string(), None, desktop_info.terminal()),
                                ));
                        } else if let Some(gpus) = self.gpus.as_ref() {
                            let default_idx = preferred_gpu_idx(desktop_info, gpus.iter());
                            for (i, gpu) in gpus.iter().enumerate() {
                                content = content.push(
                                    menu_button(text::body(format!(
                                        "{} {}",
                                        fl!("run-on", gpu = gpu.name.clone()),
                                        if i == default_idx {
                                            fl!("run-on-default")
                                        } else {
                                            String::new()
                                        }
                                    )))
                                    .on_press(Message::Exec(
                                        exec.to_string(),
                                        Some(i),
                                        desktop_info.terminal(),
                                    )),
                                );
                            }
                        } else {
                            content = content.push(menu_button(text::body(fl!("run"))).on_press(
                                Message::Exec(exec.to_string(), None, desktop_info.terminal()),
                            ));
                        }
                        for action in desktop_info.actions().into_iter().flatten() {
                            if action == "new-window" {
                                continue;
                            }

                            let Some(exec) = desktop_info.action_entry(action, "Exec") else {
                                continue;
                            };
                            let Some(name) =
                                desktop_info.action_entry_localized(action, "Name", &self.locales)
                            else {
                                continue;
                            };
                            content = content.push(menu_button(text::body(name)).on_press(
                                Message::Exec(exec.into(), None, desktop_info.terminal()),
                            ));
                        }
                        content = content.push(divider::horizontal::light());
                    }

                    if !toplevels.is_empty() {
                        let mut list_col = column![];
                        for (info, _) in toplevels {
                            list_col = list_col.push(
                                menu_button(
                                    text::body(&info.title)
                                        .ellipsize(Ellipsize::End(EllipsizeHeightLimit::Lines(1))),
                                )
                                .on_press(Message::Activate(info.foreign_toplevel.clone())),
                            );
                        }
                        content = content.push(list_col);
                        content = content.push(divider::horizontal::light());
                    }

                    let svg_accent = Rc::new(|theme: &cosmic::Theme| {
                        let color = theme.cosmic().accent_color().into();
                        svg::Style { color: Some(color) }
                    });
                    content = content.push(
                        menu_button(
                            if is_pinned {
                                row![
                                    icon::icon(from_name("checkbox-checked-symbolic").into())
                                        .size(16)
                                        .class(cosmic::theme::Svg::Custom(svg_accent.clone())),
                                    text::body(fl!("pin"))
                                ]
                            } else {
                                row![text::body(fl!("pin"))]
                            }
                            .spacing(8),
                        )
                        .on_press(if is_pinned {
                            Message::UnpinApp(*id)
                        } else {
                            Message::PinApp(*id)
                        }),
                    );

                    if is_pinned && desktop_info.exec().is_some() {
                        content = content.push(
                            menu_button(
                                row![
                                    icon::icon(from_name("edit-symbolic").into()).size(16),
                                    text::body(fl!("edit-launcher"))
                                ]
                                .spacing(8),
                            )
                            .on_press(Message::EditLauncher(*id)),
                        );
                    }

                    if !toplevels.is_empty() {
                        content = content.push(divider::horizontal::light());
                        content = match toplevels.len() {
                            1 => content.push(
                                menu_button(text::body(fl!("quit")))
                                    .on_press(Message::Quit(desktop_info.id().to_string())),
                            ),
                            _ => content.push(
                                menu_button(text::body(fl!("quit-all")))
                                    .on_press(Message::Quit(desktop_info.id().to_string())),
                            ),
                        };
                    }
                    self.core
                        .applet
                        .popup_container(
                            container(content)
                                .padding(1)
                                //TODO: move style to libcosmic
                                .class(theme::Container::custom(|theme| {
                                    let cosmic = theme.cosmic();
                                    let component = &cosmic.background.component;
                                    container::Style {
                                        icon_color: Some(component.on.into()),
                                        text_color: Some(component.on.into()),
                                        background: Some(Background::Color(component.base.into())),
                                        border: Border {
                                            radius: cosmic.radius_s().into(),
                                            width: 1.0,
                                            color: component.divider.into(),
                                        },
                                        ..Default::default()
                                    }
                                }))
                                .height(Length::Shrink)
                                .width(Length::Fill),
                        )
                        .limits(
                            Limits::NONE
                                .min_width(1.)
                                .min_height(1.)
                                .max_width(300.)
                                .max_height(1000.),
                        )
                        .into()
                }
                PopupType::LauncherEditor => {
                    let Some(edit) = self.launcher_edit.as_ref() else {
                        return text::body("").into();
                    };

                    let spacing = theme::spacing();
                    let can_save = !edit.saving
                        && launcher_edit::validate_launcher_fields(
                            &edit.name, &edit.exec, &edit.icon,
                        )
                        .is_ok();

                    let mut form = column![
                        text::title4(fl!("edit-launcher")),
                        text_input("", edit.name.as_str())
                            .label(fl!("launcher-name"))
                            .on_input(Message::LauncherNameChanged)
                            .on_submit(|_| Message::SaveLauncherEdit)
                            .width(Length::Fill)
                            .size(14),
                        text_input("", edit.exec.as_str())
                            .label(fl!("launcher-command"))
                            .on_input(Message::LauncherExecChanged)
                            .on_submit(|_| Message::SaveLauncherEdit)
                            .width(Length::Fill)
                            .size(14),
                        launcher_icon_editor(edit),
                    ]
                    .spacing(spacing.space_s)
                    .width(Length::Fill);

                    if let Some(error) = edit.error.as_ref() {
                        form = form.push(text::caption(error.as_str()).class(
                            cosmic::theme::Text::Color(theme.cosmic().destructive_color().into()),
                        ));
                    }

                    let cancel =
                        button::custom(text::body(fl!("cancel")).center().width(Length::Fill))
                            .on_press_maybe(if edit.saving {
                                None
                            } else {
                                Some(Message::CancelLauncherEdit)
                            })
                            .padding([spacing.space_xxs, spacing.space_s])
                            .width(142);

                    let save = button::custom(text::body(fl!("save")).center().width(Length::Fill))
                        .class(Button::Suggested)
                        .on_press_maybe(if can_save {
                            Some(Message::SaveLauncherEdit)
                        } else {
                            None
                        })
                        .padding([spacing.space_xxs, spacing.space_s])
                        .width(142);

                    let actions = row![horizontal_space(), cancel, save]
                        .spacing(spacing.space_xxs)
                        .align_y(Alignment::Center);

                    let content = column![form, actions]
                        .spacing(spacing.space_m)
                        .padding(spacing.space_m)
                        .width(Length::Fill);

                    self.core
                        .applet
                        .popup_container(container(content).width(Length::Fill))
                        .limits(
                            Limits::NONE
                                .min_width(480.)
                                .min_height(1.)
                                .max_width(520.)
                                .max_height(1000.),
                        )
                        .into()
                }
                PopupType::ToplevelList => match self.core.applet.anchor {
                    PanelAnchor::Left | PanelAnchor::Right => {
                        let mut content =
                            column![].padding(8).align_x(Alignment::Center).spacing(8);
                        for (info, img) in toplevels {
                            content = content.push(toplevel_button(
                                img.clone(),
                                info.title.clone(),
                                info.foreign_toplevel.clone(),
                                self.is_focused(&info.foreign_toplevel),
                                self.is_hovered(&info.foreign_toplevel),
                            ));
                        }
                        self.core
                            .applet
                            .popup_container(content)
                            .limits(Limits::NONE.min_width(1.).min_height(1.).max_height(1000.))
                            .into()
                    }
                    PanelAnchor::Bottom | PanelAnchor::Top => {
                        let mut content = row![].padding(8).align_y(Alignment::Center).spacing(8);
                        for (info, img) in toplevels {
                            content = content.push(toplevel_button(
                                img.clone(),
                                info.title.clone(),
                                info.foreign_toplevel.clone(),
                                self.is_focused(&info.foreign_toplevel),
                                self.is_hovered(&info.foreign_toplevel),
                            ));
                        }
                        self.core
                            .applet
                            .popup_container(content)
                            .limits(Limits::NONE.min_width(1.).min_height(1.).max_height(1000.))
                            .into()
                    }
                },
            }
        } else if self
            .overflow_active_popup
            .as_ref()
            .is_some_and(|overflow_id| overflow_id == &id)
        {
            let (_favorite_popup_cutoff, active_popup_cutoff) = self.panel_overflow_lengths();

            let focused_item = self.currently_active_toplevel();
            let dot_radius = theme.cosmic().radius_xs();

            let filtered_active_list: Vec<_> = self
                .active_list
                .iter()
                .filter(|dock_item| {
                    dock_item.toplevels.iter().any(|(toplevel_info, _)| {
                        self.is_on_current_monitor_and_workspace(toplevel_info)
                    })
                })
                .collect();

            let active: Vec<_> = filtered_active_list
                .iter()
                .rev()
                .take(active_popup_cutoff.map_or(filtered_active_list.len(), |n| {
                    if n < filtered_active_list.len() {
                        filtered_active_list.len() - n + 1
                    } else {
                        0
                    }
                }))
                .map(|dock_item| {
                    let filtered_is_focused = dock_item
                        .toplevels
                        .iter()
                        .filter(|(info, _)| self.is_on_current_monitor_and_workspace(info))
                        .any(|y| focused_item.contains(&y.0.foreign_toplevel));

                    self.core
                        .applet
                        .applet_tooltip(
                            dock_item.as_icon(
                                &self.core.applet,
                                self.rectangle_tracker.as_ref(),
                                self.popup.is_none(),
                                self.config.enable_drag_source,
                                self.gpus.as_deref(),
                                filtered_is_focused,
                                dot_radius,
                                id,
                                Some(&|info| self.is_on_current_monitor_and_workspace(info)),
                                // Yoda: icons in the overflow popup are
                                // already smaller-grid — keep them at 1.0
                                // so the popup doesn't reshuffle on hover.
                                1.0,
                            ),
                            dock_item
                                .desktop_info
                                .full_name(&self.locales)
                                .unwrap_or_default()
                                .into_owned(),
                            self.popup.is_some(),
                            Message::Surface,
                            Some(id),
                        )
                        .into()
                })
                .collect();
            let content = match &self.core.applet.anchor {
                PanelAnchor::Left | PanelAnchor::Right => container(
                    Column::with_children(active)
                        .spacing(4.0)
                        .align_x(Alignment::Center)
                        .width(Length::Shrink)
                        .height(Length::Shrink),
                ),
                PanelAnchor::Top | PanelAnchor::Bottom => container(
                    Row::with_children(active)
                        .spacing(4.0)
                        .align_y(Alignment::Center)
                        .width(Length::Shrink)
                        .height(Length::Shrink),
                ),
            };
            // send clear popup on press content if there is an active popup
            let content: Element<_> = if self.popup.is_some() {
                mouse_area(content)
                    .on_release(Message::ClosePopup)
                    .on_right_release(Message::ClosePopup)
                    .into()
            } else {
                content.into()
            };
            self.core
                .applet
                .popup_container(content)
                .limits(
                    Limits::NONE
                        .min_width(1.)
                        .min_height(1.)
                        .max_width(1920.)
                        .max_height(1000.),
                )
                .into()
        } else if self
            .overflow_favorites_popup
            .as_ref()
            .is_some_and(|popup_id| popup_id == &id)
        {
            let (favorite_popup_cutoff, _active_popup_cutoff) = self.panel_overflow_lengths();

            let focused_item = self.currently_active_toplevel();
            let dot_radius = theme.cosmic().radius_xs();
            // show the overflow popup for favorites list

            let mut favorite_to_remove = if let Some(cutoff) = favorite_popup_cutoff {
                if cutoff < self.pinned_list.len() {
                    self.pinned_list.len() - cutoff + 1
                } else {
                    0
                }
            } else {
                0
            };
            let mut favorites_extra = Vec::with_capacity(favorite_to_remove);
            let mut favorites: Vec<_> = self
                .pinned_list
                .iter()
                .rev()
                .filter(|f| {
                    if favorite_to_remove > 0 && f.toplevels.is_empty() {
                        favorite_to_remove -= 1;
                        true
                    } else {
                        favorites_extra.push(*f);
                        false
                    }
                })
                .collect();
            favorites.extend(favorites_extra[..favorite_to_remove].iter().copied());
            let favorites: Vec<_> = favorites
                .iter()
                .rev()
                .map(|dock_item| {
                    let filtered_is_focused = dock_item
                        .toplevels
                        .iter()
                        .filter(|(info, _)| self.is_on_current_monitor_and_workspace(info))
                        .any(|y| focused_item.contains(&y.0.foreign_toplevel));

                    self.core
                        .applet
                        .applet_tooltip(
                            dock_item.as_icon(
                                &self.core.applet,
                                self.rectangle_tracker.as_ref(),
                                self.popup.is_none(),
                                self.config.enable_drag_source,
                                self.gpus.as_deref(),
                                filtered_is_focused,
                                dot_radius,
                                id,
                                Some(&|info| self.is_on_current_monitor_and_workspace(info)),
                                // Yoda: popup icons stay at 1.0 (hover
                                // magnification is applied to the main
                                // dock row only).
                                1.0,
                            ),
                            dock_item
                                .desktop_info
                                .full_name(&self.locales)
                                .unwrap_or_default()
                                .to_string(),
                            self.popup.is_some(),
                            Message::Surface,
                            Some(id),
                        )
                        .into()
                })
                .collect();
            let content = match &self.core.applet.anchor {
                PanelAnchor::Left | PanelAnchor::Right => container(
                    Column::with_children(favorites)
                        .spacing(4.0)
                        .align_x(Alignment::Center)
                        .width(Length::Shrink)
                        .height(Length::Shrink),
                ),
                PanelAnchor::Top | PanelAnchor::Bottom => container(
                    Row::with_children(favorites)
                        .spacing(4.0)
                        .align_y(Alignment::Center)
                        .width(Length::Shrink)
                        .height(Length::Shrink),
                ),
            };
            let content: Element<_> = if self.popup.is_some() {
                mouse_area(content)
                    .on_right_release(Message::ClosePopup)
                    .on_press(Message::ClosePopup)
                    .into()
            } else {
                content.into()
            };
            self.core
                .applet
                .popup_container(content)
                .limits(
                    Limits::NONE
                        .min_width(1.)
                        .min_height(1.)
                        .max_width(1920.)
                        .max_height(1000.),
                )
                .into()
        } else {
            let suggested = self.core.applet.suggested_size(false);
            iced::widget::row!()
                .width(Length::Fixed(suggested.0 as f32))
                .height(Length::Fixed(suggested.1 as f32))
                .into()
        }
    }

    fn subscription(&self) -> Subscription<Message> {
        // Yoda: ~60fps animation ticks for the fisheye magnification.
        // Only emitted when an animation is actually in progress (hover
        // intensity >0 OR still fading out) — keeps the panel idle when
        // the pointer is nowhere near the dock.
        let anim_active = self.hovered_dock_item.is_some()
            || self.anim_hover_intensity > 0.001;
        let anim_subscription = if anim_active {
            cosmic::iced::time::every(std::time::Duration::from_millis(16))
                .map(Message::AnimTick)
        } else {
            Subscription::none()
        };

        Subscription::batch([
            anim_subscription,
            wayland_subscription().map(Message::Wayland),
            listen_with(|e, _, id| match e {
                cosmic::iced::core::Event::PlatformSpecific(event::PlatformSpecific::Wayland(
                    event::wayland::Event::Seat(e, seat),
                )) => match e {
                    event::wayland::SeatEvent::Enter => Some(Message::NewSeat(seat)),
                    event::wayland::SeatEvent::Leave => Some(Message::RemovedSeat),
                },
                cosmic::iced::core::Event::Mouse(
                    cosmic::iced::core::mouse::Event::ButtonPressed(_),
                ) => Some(Message::Pressed(id)),
                _ => None,
            }),
            rectangle_tracker_subscription(0).map(|update| Message::Rectangle(update.1)),
            self.core.watch_config(APP_ID).map(|u| {
                for why in u.errors {
                    tracing::error!(why = why.to_string(), "Error watching config");
                }
                Message::ConfigUpdated(u.config)
            }),
        ])
    }

    fn style(&self) -> Option<iced::theme::Style> {
        Some(cosmic::applet::style())
    }

    fn on_close_requested(&self, id: window::Id) -> Option<Message> {
        Some(Message::CloseRequested(id))
    }
}

fn launch_on_preferred_gpu(desktop_info: &DesktopEntry, gpus: Option<&[Gpu]>) -> Option<Message> {
    let exec = desktop_info.exec()?;

    let gpu_idx = gpus.map(|gpus| preferred_gpu_idx(desktop_info, gpus.iter()));

    Some(Message::Exec(
        exec.to_string(),
        gpu_idx,
        desktop_info.terminal(),
    ))
}

fn preferred_gpu_idx<'a, I>(desktop_info: &DesktopEntry, mut gpus: I) -> usize
where
    I: Iterator<Item = &'a Gpu>,
{
    gpus.position(|gpu| gpu.default ^ desktop_info.prefers_non_default_gpu())
        .unwrap_or(0)
}

#[derive(Debug, Default, Clone)]
pub struct DndPathBuf(PathBuf);

impl AllowedMimeTypes for DndPathBuf {
    fn allowed() -> std::borrow::Cow<'static, [String]> {
        std::borrow::Cow::Owned(vec![MIME_TYPE.to_string()])
    }
}

impl TryFrom<(Vec<u8>, String)> for DndPathBuf {
    type Error = anyhow::Error;

    fn try_from((data, mime_type): (Vec<u8>, String)) -> Result<Self, Self::Error> {
        if mime_type == MIME_TYPE {
            if let Some(p) = String::from_utf8(data)
                .ok()
                .and_then(|s| Url::from_str(&s).ok())
                .and_then(|u| u.to_file_path().ok())
            {
                Ok(DndPathBuf(p))
            } else {
                anyhow::bail!("Failed to parse.")
            }
        } else {
            anyhow::bail!("Invalid mime type.")
        }
    }
}

impl AsMimeTypes for DndPathBuf {
    fn available(&self) -> std::borrow::Cow<'static, [String]> {
        std::borrow::Cow::Owned(vec![MIME_TYPE.to_string()])
    }

    fn as_bytes(&self, _mime_type: &str) -> Option<std::borrow::Cow<'static, [u8]>> {
        Some(Cow::Owned(self.0.to_str()?.as_bytes().to_vec()))
    }
}