diff --git a/crates/layers/src/ui/filter/mod.rs b/crates/layers/src/ui/filter/mod.rs index 5aee61668..4f04f741e 100644 --- a/crates/layers/src/ui/filter/mod.rs +++ b/crates/layers/src/ui/filter/mod.rs @@ -63,6 +63,12 @@ impl FilterBy { FilterBy::Artboard, FilterBy::Group, ]; + + /// The type the filter uses when `by` is not among `offered`: `by` itself when offered, else the + /// first offered type in [`ALL`](Self::ALL) order, or `by` when nothing is offered. + pub(crate) fn among(self, offered: &[FilterBy]) -> FilterBy { + if offered.contains(&self) { self } else { Self::ALL.into_iter().find(|by| offered.contains(by)).unwrap_or(self) } + } } /// A layer kind the Kind filter toggles. @@ -584,6 +590,8 @@ pub struct LayerFilterBar<'a> { /// text selected, so typing replaces it. #[prop] focus_name: bool, + /// The filter types the type select offers, in [`FilterBy::ALL`] order. + types: Vec, } /// What [`LayerFilterBar::show`] returns. @@ -617,29 +625,45 @@ struct FindName { impl<'a> LayerFilterBar<'a> { /// The bar editing `filter`. pub fn new(filter: Bind<'a, LayerFilter>) -> Self { - Self { filter, blend_modes: &[], focus_name: false } + Self { filter, blend_modes: &[], focus_name: false, types: FilterBy::ALL.to_vec() } + } + + /// The filter types the type select offers (default: all of [`FilterBy::ALL`]), listed in the + /// order `FilterBy` declares them whatever the order given. A filter whose type is not offered + /// shows and uses the first offered type, and reports that type as an edit. An empty list + /// draws no bar. + pub fn filter_types(mut self, types: impl Into>) -> Self { + let given = types.into(); + self.types = FilterBy::ALL.into_iter().filter(|by| given.contains(by)).collect(); + self } /// Draws the bar on one row of the available width. pub fn show(self, ui: &mut Ui) -> LayerFilterOutput { - let Self { mut filter, blend_modes, focus_name } = self; + let Self { mut filter, blend_modes, focus_name, types: offered } = self; + if offered.is_empty() { + return LayerFilterOutput { response: ui.allocate_response(egui::Vec2::ZERO, egui::Sense::hover()), changed: false, edit: None }; + } let words = Env::of(ui).words::(); let size = ControlSize::Sm; let mut edit = None; let row = Row::new().show(ui, |ui, cx| { let select_name = std::mem::replace(&mut cx.memory::().select, focus_name); let Some(Mixed::Same(current)) = filter.reborrow().read(cx) else { return }; + let stored = current; + let mut current = stored.clone(); + current.by = current.by.among(&offered); let mut next = current.clone(); if focus_name { - next.by = FilterBy::Name; + next.by = FilterBy::Name.among(&offered); } - let types: Vec> = FilterBy::ALL.into_iter().map(|by| Entry::new(by, type_label(by, &words).clone())).collect(); + let types: Vec> = offered.iter().copied().map(|by| Entry::new(by, type_label(by, &words).clone())).collect(); let picked = Select::new(words.filter_type.clone(), Bind::given(next.by), &types).size(size).show(ui); if let Some(by) = picked.value() { next.by = *by; } // Controls follow the type picked before this pass; a find shows the Name field at once. - let shown = if focus_name { FilterBy::Name } else { current.by }; + let shown = if focus_name { next.by } else { current.by }; match shown { FilterBy::Kind => { let kinds = [ @@ -710,9 +734,9 @@ impl<'a> LayerFilterBar<'a> { // The selected layers pick the artboards; Group lists every group. FilterBy::Artboard | FilterBy::Group => {} } - if next != current { + if next != stored { let name: std::sync::Arc = std::sync::Arc::from(words.filter_type.as_str()); - let event = EditEvent::set(Mixed::Same(current), next, name, None); + let event = EditEvent::set(Mixed::Same(stored), next, name, None); filter.reborrow().write(cx, &event); edit = Some(event); } diff --git a/crates/layers/src/ui/filter/stories.rs b/crates/layers/src/ui/filter/stories.rs index c193893c7..ad4c66eb5 100644 --- a/crates/layers/src/ui/filter/stories.rs +++ b/crates/layers/src/ui/filter/stories.rs @@ -36,6 +36,16 @@ fn by_name(ui: &mut Ui, data: &mut StoryData) -> StoryOutput { show(ui, filter) } +/// An app that offers three of the nine types. +#[story(LayerFilterBar<'static>, covers = [], drive = Drive::Never, group = "Types", title = "Offering Kind, Name and Mode")] +fn offered_types(ui: &mut Ui, data: &mut StoryData) -> StoryOutput { + let filter = data.value("filter", LayerFilter { by: FilterBy::Mode, mode: String::from("multiply"), ..LayerFilter::default() }); + let tree = FakeLayers::fifty(); + let modes = tree.blend_modes(false, "normal"); + let bar = LayerFilterBar::new(Bind::bound(filter)).filter_types([FilterBy::Kind, FilterBy::Name, FilterBy::Mode]).blend_modes(&modes); + StoryOutput::from(bar.show(ui)) +} + #[story(LayerFilterBar<'static>, covers = [], drive = Drive::Never, group = "Types", title = "Filter by Effect")] fn by_effect(ui: &mut Ui, data: &mut StoryData) -> StoryOutput { let filter = data.value("filter", LayerFilter { by: FilterBy::Effect, effect: EffectKind::Stroke, ..LayerFilter::default() }); diff --git a/crates/layers/src/ui/panel/mod.rs b/crates/layers/src/ui/panel/mod.rs index ed014111c..4e193fa32 100644 --- a/crates/layers/src/ui/panel/mod.rs +++ b/crates/layers/src/ui/panel/mod.rs @@ -38,7 +38,7 @@ use footer::show_footer; use menu::{OpenMenu, RowMenu, show_row_menus}; use std::marker::PhantomData; -use super::filter::{LayerFilter, LayerFilterBar}; +use super::filter::{FilterBy, LayerFilter, LayerFilterBar}; use super::options::LayersSettings; use super::rows::BlendRows; use super::thumbs::LayerThumb; @@ -169,6 +169,7 @@ pub struct LayersPanel<'a, T: LayerTree> { visibility_key: Option, blend_rows: bool, filter_bar: bool, + filter_types: Vec, find_name: bool, row_menu: Option>>, trailing: Option + 'a>>, @@ -213,6 +214,7 @@ impl<'a, T: LayerTree> LayersPanel<'a, T> { visibility_key: None, blend_rows: true, filter_bar: true, + filter_types: FilterBy::ALL.to_vec(), find_name: false, row_menu: None, trailing: None, @@ -269,6 +271,14 @@ impl<'a, T: LayerTree> LayersPanel<'a, T> { self } + /// The filter types the filter bar offers (default: all of [`FilterBy::ALL`]), listed in the order `FilterBy` declares + /// them. A filter whose type is not offered falls back to the first offered type: the bar shows it, the rows are + /// listed as if it were chosen, and the correction is a [`LayersEvent::Filter`]. An empty list draws no bar. + pub fn filter_types(mut self, types: impl Into>) -> Self { + self.filter_types = types.into(); + self + } + /// Find Layers (PhotoCraft's Select › Find Layers): this pass the filter bar switches to Name and its field takes /// the focus with its text selected, so typing replaces it. A hidden filter bar stays hidden and takes no focus. pub fn focus_filter_name(mut self) -> Self { @@ -318,6 +328,7 @@ impl<'a, T: LayerTree> LayersPanel<'a, T> { visibility_key, blend_rows, filter_bar, + filter_types, find_name, row_menu, trailing, @@ -358,20 +369,32 @@ impl<'a, T: LayerTree> LayersPanel<'a, T> { } }; let before = held(&mut filter, stack); - if filter_bar && settings.show_filters { + if filter_bar && settings.show_filters && !filter_types.is_empty() { let modes = tree.blend_modes(false, &before.mode); match filter.as_mut() { Some(bind) => { - let out = LayerFilterBar::new(bind.reborrowed()).blend_modes(&modes).focus_name(find_name).show(ui); + let out = LayerFilterBar::new(bind.reborrowed()) + .filter_types(filter_types.as_slice()) + .blend_modes(&modes) + .focus_name(find_name) + .show(ui); events.borrow_mut().extend(out.edit.map(LayersEvent::Filter)); } None => { let own = &mut stack.memory::>().filter; - let _ = LayerFilterBar::new(Bind::bound(own)).blend_modes(&modes).focus_name(find_name).show(ui); + let _ = LayerFilterBar::new(Bind::bound(own)) + .filter_types(filter_types.as_slice()) + .blend_modes(&modes) + .focus_name(find_name) + .show(ui); } } } - *current.borrow_mut() = held(&mut filter, stack); + let mut listed = held(&mut filter, stack); + if !filter_types.is_empty() { + listed.by = listed.by.among(&filter_types); + } + *current.borrow_mut() = listed; if blend_rows { let properties = tree.properties(); let modes = diff --git a/crates/layers/tests/it/panel_filter.rs b/crates/layers/tests/it/panel_filter.rs index a06614076..d1d2db918 100644 --- a/crates/layers/tests/it/panel_filter.rs +++ b/crates/layers/tests/it/panel_filter.rs @@ -124,3 +124,31 @@ fn find_layers_puts_the_caret_in_the_name_field_with_its_text_selected() { assert_eq!(rig.filter.borrow().name, "pine", "the typed text replaces the old"); assert_eq!(rig.rows(), ["Pine"]); } + +/// A panel offering Kind and Name lists only those two in the type select, and a filter set to Artboard falls back to +/// Kind, reported as a filter event so the app stores it. +#[trial] +fn the_type_select_lists_only_the_offered_types() { + let tree = Rc::new(RefCell::new(FakeLayers::boards())); + let mut start = LayerFilter::default(); + start.by = FilterBy::Artboard; + let filter = Rc::new(RefCell::new(start)); + let (shown, by) = (Rc::clone(&tree), Rc::clone(&filter)); + let mut fixture = Fixture::new(move |ui| { + let tree = shown.borrow(); + let mut filter = by.borrow_mut(); + let _ = LayersPanel::new(&*tree).filter(Bind::bound(&mut *filter)).filter_types([FilterBy::Name, FilterBy::Kind]).show(ui); + }); + fixture.room(ONE_PANEL); + fixture.settle(); + assert_eq!(filter.borrow().by, FilterBy::Kind, "the stored type falls back to the first offered"); + let select = fixture.by_label("Filter type").expect("the type select is shown"); + fixture.click(&select); + fixture.idle(3); + assert!(fixture.by_label("Name").is_some(), "Name is offered"); + for hidden in ["Mode", "Effect", "Artboard", "Group"] { + assert!(fixture.by_label(hidden).is_none(), "{hidden} is not offered"); + } + let rows = BOARDS.iter().filter(|label| fixture.by_label(label).is_some()).count(); + assert_eq!(rows, BOARDS.len(), "the fallback Kind filter is empty, so every layer is listed"); +}