functora-egui 0.2.0

shadcn/ui-inspired widget library for egui - buttons, inputs, selects, dialogs, and 70+ more components with light/dark theming
Documentation
//! Show method for Combobox — renders a searchable dropdown.

impl super::widget::Combobox {
    /// Shows the combobox. `selected` is the index of the selected item (or None).
    /// `search_text` holds the filter text state.
    pub fn show(
        self,
        ui: &mut egui::Ui,
        selected: &mut Option<usize>,
        search_text: &mut String,
    ) -> egui::Response {
        let entries: Vec<(usize, String)> = self.items.into_iter().enumerate().collect();
        let mut typed = super::widget::ComboboxValue::new(&entries).placeholder(self.placeholder);
        if let Some(width) = self.width {
            typed = typed.width(width);
        }
        typed.show(ui, selected, search_text)
    }
}

impl<T: Clone + PartialEq> super::widget::ComboboxValue<'_, T> {
    /// Shows the combobox. `selected` holds the selected value (or None).
    /// `search_text` holds the filter text state.
    /// A value missing from `entries` renders the placeholder.
    pub fn show(
        self,
        ui: &mut egui::Ui,
        selected: &mut Option<T>,
        search_text: &mut String,
    ) -> egui::Response {
        let theme = crate::theme::shadcn_theme_ext::ShadcnThemeExt::shadcn_theme(ui.ctx());

        let display = selected
            .as_ref()
            .and_then(|value| {
                self.entries
                    .iter()
                    .find(|entry| entry.0 == *value)
                    .map(|(_, label)| label.clone())
            })
            .unwrap_or_else(|| self.placeholder.clone());

        let text_color = if selected.is_some() {
            theme.foreground
        } else {
            theme.muted_foreground
        };

        // Trigger button: framed text + chevron icon
        let icon_size: f32 = 12.0;
        let h_padding: f32 = 10.0;
        let spacing =
            crate::responsive::responsive_ext::ResponsiveExt::responsive_spacing(ui.ctx());
        let height = spacing.touch_height;
        let width = crate::widgets::select::select_sizing::trigger_width(
            ui,
            self.width,
            self.entries
                .iter()
                .map(|(_, label)| label.as_str())
                .chain([self.placeholder.as_str()]),
            h_padding,
            icon_size + 4.0,
            220.0,
        );
        let galley =
            ui.painter()
                .layout_no_wrap(display, egui::FontId::proportional(14.0), text_color);
        let desired = egui::vec2(width, height);
        let (trigger_rect, trigger) = ui.allocate_exact_size(desired, egui::Sense::click());

        if ui.is_rect_visible(trigger_rect) {
            let cr = egui::CornerRadius::same(crate::utils::f32_to_u8_clamped(theme.radius));
            let bg = if trigger.is_pointer_button_down_on() {
                crate::paint::interpolate_color::interpolate_color(
                    theme.background,
                    theme.accent,
                    0.85,
                )
            } else if trigger.hovered() {
                theme.accent
            } else {
                theme.background
            };
            let _ = ui.painter().rect_filled(trigger_rect, cr, bg);
            let _ = ui.painter().rect_stroke(
                trigger_rect,
                cr,
                egui::Stroke::new(1.0, theme.input),
                egui::epaint::StrokeKind::Inside,
            );

            let text_pos = egui::pos2(
                trigger_rect.min.x + h_padding,
                trigger_rect.center().y - galley.size().y / 2.0,
            );
            let text_region = egui::Rect::from_min_max(
                egui::pos2(trigger_rect.min.x + h_padding, trigger_rect.min.y),
                egui::pos2(
                    (trigger_rect.max.x - h_padding - icon_size - 4.0).max(trigger_rect.min.x),
                    trigger_rect.max.y,
                ),
            );
            ui.painter()
                .with_clip_rect(text_region)
                .galley(text_pos, galley, text_color);

            let icon_rect = egui::Rect::from_min_size(
                egui::pos2(
                    trigger_rect.max.x - h_padding - icon_size,
                    trigger_rect.center().y - icon_size / 2.0,
                ),
                egui::vec2(icon_size, icon_size),
            );
            crate::icons::paint_icon::paint_icon(
                ui.painter(),
                icon_rect,
                &crate::icons::lucide_icon::LucideIcon::ChevronDown,
                theme.muted_foreground,
            );
        }

        if trigger.hovered() {
            ui.ctx().set_cursor_icon(egui::CursorIcon::PointingHand);
        }

        let popup_id = trigger.id.with("combobox_popup");

        let toggle_cmd = if trigger.clicked() {
            Some(egui::SetOpenCommand::Toggle)
        } else {
            None
        };

        let cr = crate::utils::f32_to_u8_clamped(theme.radius + 2.0);
        let themed_frame = egui::Frame::NONE
            .fill(theme.popover)
            .inner_margin(egui::Margin::same(8))
            .corner_radius(egui::CornerRadius::same(cr))
            .stroke(egui::Stroke::new(1.0, theme.border))
            .shadow(egui::Shadow {
                offset: [0, 4],
                blur: 12,
                spread: 0,
                color: egui::Color32::from_black_alpha(8),
            });

        let popup = egui::Popup::new(popup_id, ui.ctx().clone(), &trigger, ui.layer_id())
            .open_memory(toggle_cmd)
            .frame(themed_frame);

        let mut close = false;

        let popup_width = {
            let popup_spacing =
                crate::responsive::responsive_ext::ResponsiveExt::responsive_spacing(ui.ctx());
            let screen_w = ui.ctx().input(|i| i.viewport_rect().width());
            let mut content_w: f32 = 200.0;
            for (_, label) in self.entries {
                let w = ui
                    .painter()
                    .layout_no_wrap(
                        label.clone(),
                        egui::FontId::proportional(14.0),
                        egui::Color32::PLACEHOLDER,
                    )
                    .size()
                    .x
                    + 32.0;
                content_w = content_w.max(w);
            }
            let base = trigger_rect.width().max(content_w);
            let screen_cap = (screen_w - 2.0 * popup_spacing.page_padding - 16.0).max(0.0);
            if popup_spacing.is_mobile() {
                base.clamp(0.0, screen_cap).max(trigger_rect.width())
            } else {
                crate::utils::clamp_overlay_width(base.min(screen_w * 0.6), 200.0, screen_cap)
            }
        };
        let _ = popup.show(|popup_ui: &mut egui::Ui| {
            popup_ui.set_min_width(popup_width);
            popup_ui.set_max_width(popup_width);

            // Themed search input
            let input_resp = crate::widgets::input::widget::Input::new(search_text)
                .placeholder("Search...")
                .desired_width(popup_ui.available_width())
                .show(popup_ui);
            if trigger.clicked() {
                input_resp.request_focus();
            }

            popup_ui.add_space(4.0);

            // Filtered items
            let query = search_text.to_lowercase();
            let filtered: Vec<(&T, &String)> = self
                .entries
                .iter()
                .filter(|(_, label)| query.is_empty() || label.to_lowercase().contains(&query))
                .map(|(value, label)| (value, label))
                .collect();

            if filtered.is_empty() {
                let _ = popup_ui.label(
                    egui::RichText::new("No results found")
                        .color(theme.muted_foreground)
                        .size(13.0),
                );
            } else {
                let check_icon_size: f32 = 12.0;
                let item_left_pad: f32 = check_icon_size + 6.0;

                for (value, label) in filtered {
                    let is_selected = selected.as_ref().is_some_and(|current| current == value);
                    let item_galley = popup_ui.painter().layout_no_wrap(
                        label.clone(),
                        egui::FontId::proportional(14.0),
                        theme.popover_foreground,
                    );
                    let item_desired =
                        egui::vec2(popup_ui.available_width(), item_galley.size().y + 8.0);
                    let (rect, r) =
                        popup_ui.allocate_exact_size(item_desired, egui::Sense::click());

                    if r.hovered() || is_selected {
                        let _ = popup_ui.painter().rect_filled(
                            rect,
                            egui::CornerRadius::same(4),
                            theme.accent,
                        );
                    }

                    if r.hovered() {
                        popup_ui
                            .ctx()
                            .set_cursor_icon(egui::CursorIcon::PointingHand);
                    }

                    if popup_ui.is_rect_visible(rect) {
                        // Check icon for selected item
                        if is_selected {
                            let check_rect = egui::Rect::from_min_size(
                                egui::pos2(
                                    rect.min.x + 4.0,
                                    rect.center().y - check_icon_size / 2.0,
                                ),
                                egui::vec2(check_icon_size, check_icon_size),
                            );
                            crate::icons::paint_icon::paint_icon(
                                popup_ui.painter(),
                                check_rect,
                                &crate::icons::lucide_icon::LucideIcon::Check,
                                theme.popover_foreground,
                            );
                        }

                        let label_region = egui::Rect::from_min_max(
                            egui::pos2(rect.min.x + item_left_pad, rect.min.y),
                            rect.max,
                        );
                        popup_ui.painter().with_clip_rect(label_region).galley(
                            egui::pos2(
                                rect.min.x + item_left_pad,
                                rect.center().y - item_galley.size().y / 2.0,
                            ),
                            item_galley,
                            theme.popover_foreground,
                        );
                    }

                    if r.clicked() {
                        *selected = Some(value.clone());
                        search_text.clear();
                        close = true;
                    }
                }
            }
        });

        if close {
            egui::Popup::close_id(ui.ctx(), popup_id);
            ui.ctx().request_repaint();
        }

        trigger
    }
}