use std::sync::{
Arc,
atomic::{AtomicBool, Ordering},
};
use super::{LIST_INSET, MenuFocus, WindowTabEntry, WindowTabsPart, WindowTabsView};
use crate::{
app::{
ctx::Placement,
events::{KeyboardEvent, MouseButton, MouseEvent},
},
components::{self, Column, Popup, Row, ScrollVertical},
layout::{Alignment, layout_kind::Justify},
node::{Element, FocusGroup, dimension::Dimension},
ui::{
icons,
recipe::{Name, ResolvedPart},
search_field::SearchField,
shared::{glyph, one_line, pressable},
},
};
const SEARCH_ABOVE: usize = 8;
const LIST_OFFSET: f32 = 4.0;
const LEAST_HEIGHT: f32 = 120.0;
pub(super) fn searched(count: usize) -> bool {
count > SEARCH_ABOVE
}
fn matches(query: &str, tab: &WindowTabEntry) -> bool {
let query = query.trim().to_lowercase();
let holds = |text: &str| text.to_lowercase().contains(&query);
query.is_empty()
|| holds(&tab.label)
|| tab.list_label.as_deref().is_some_and(holds)
|| tab.list_detail.as_deref().is_some_and(holds)
}
pub(super) fn kept_in_view(tabs: &[WindowTabEntry], query: &str) -> Option<usize> {
let mut listed = tabs.iter().enumerate().filter(|(_, tab)| matches(query, tab));
let first = listed.clone().next().map(|(index, _)| index);
listed.find(|(_, tab)| tab.selected).map(|(index, _)| index).or(first)
}
fn the_lists(event: &KeyboardEvent) -> bool {
closes(event) || !(event.ctrl || event.alt || event.meta)
}
fn closes(event: &KeyboardEvent) -> bool {
let held = if cfg!(target_os = "macos") {
event.meta && !event.ctrl
} else {
event.ctrl && !event.meta
};
held && !event.shift && !event.alt && event.key.eq_ignore_ascii_case("w")
}
impl WindowTabsView {
fn searched(&self) -> bool {
searched(self.tabs.len())
}
pub(super) fn menu_entry(&self) -> MenuFocus {
if self.searched() {
return MenuFocus::Search;
}
MenuFocus::Item(self.tabs.iter().position(|tab| tab.selected).unwrap_or(0))
}
fn item_part(&self, index: usize, part: WindowTabsPart) -> ResolvedPart {
let tab = &self.tabs[index];
let recipe = self.recipe(tab.selected, false, false, self.disabled || tab.disabled, false);
let recipe = match (&tab.id, &tab.key) {
(None, Some(key)) => recipe.keyed_item(key, WindowTabsPart::Item),
(id, _) => recipe.item(id.as_ref(), WindowTabsPart::Item),
};
recipe.part(part)
}
fn listed(&self, query: &str) -> Vec<usize> {
(0..self.tabs.len())
.filter(|index| matches(query, &self.tabs[*index]))
.collect()
}
fn list_anchor(&self) -> (crate::core::ElementRef, Placement) {
if self.hidden_count() == 0 {
(self.kept.list.clone(), Placement::BottomEnd)
} else {
(self.kept.anchor.clone(), Placement::BottomStart)
}
}
pub(super) fn all_tabs(&self) -> Element {
let query = self.kept.query.get();
let listed: Arc<[usize]> = self.listed(&query).into();
let mut panel = Column::new()
.align_items(Alignment::Stretch)
.part(&self.part(WindowTabsPart::Panel))
.describe("a11y_role", "dialog")
.describe("a11y_name", crate::ui::current_locale().navigation.open_tabs.clone());
if let Some(id) = &self.id {
panel = panel.id(format!("{id}-panel"));
}
let held = self.kept.query.clone();
panel = panel.on_key_down(move |event: KeyboardEvent| {
if event.focus_within && event.key == "Escape" && !event.composing && !held.get_untracked().is_empty() {
event.prevent_default();
held.set(String::new());
}
});
if self.searched() {
panel = panel.child(self.search(&listed));
}
panel = if listed.is_empty() {
panel.child(self.no_match(&query))
} else {
panel.child(self.items(&listed))
};
if let Some(height) = self.list_height() {
panel = panel.max_height(Dimension::Px(height));
}
let within = Arc::new(AtomicBool::new(false));
let learned = within.clone();
let content = Column::new()
.keys_first(true)
.on_key_down(move |event: KeyboardEvent| learned.store(event.focus_within, Ordering::Relaxed))
.child(panel)
.child(Row::new().on_key_down(move |event: KeyboardEvent| {
if within.load(Ordering::Relaxed) && !event.composing && the_lists(&event) {
event.stop_propagation();
}
}));
let inset = self.list_inset();
let told = self.open_told();
let (anchor, placement) = self.list_anchor();
let mut popup = Popup::new(anchor, content)
.open(self.kept.open.clone())
.placement(placement)
.offset(0.0, LIST_OFFSET)
.keep_clear(inset, inset, inset, inset)
.takes_focus(true)
.on_dismiss(move || told(false));
if let Some(frame) = &self.list.clear_of {
popup = popup.clear_of(frame.clone());
}
popup.into()
}
fn list_inset(&self) -> f32 {
self.list.inset.unwrap_or(LIST_INSET)
}
fn list_height(&self) -> Option<f32> {
let window = (*self.kept.window_height.lock())?;
let anchor = self.list_anchor().0;
let frame = self
.list
.clear_of
.as_ref()
.filter(|frame| frame.is_attached())
.unwrap_or(&anchor);
let top = if frame.is_attached() {
frame.y() + frame.height() + LIST_OFFSET
} else {
0.0
};
Some((window - top - self.list_inset()).max(LEAST_HEIGHT))
}
fn search(&self, listed: &Arc<[usize]>) -> Element {
let locale = crate::ui::current_locale();
let placeholder = locale.count(&locale.navigation.search_tabs, self.tabs.len());
let first = listed.first().copied();
let choose = first.map(|index| self.chooser(index));
let mut field = SearchField::new(self.kept.query.clone())
.placeholder(&placeholder)
.label(&placeholder)
.full_width(true)
.ref_element(self.kept.search.clone())
.on_submit(move |_| {
if let Some(choose) = &choose {
choose();
}
});
if self.list_shortcut {
field = field.shortcut(&super::list::list_keys());
}
if let Some(id) = &self.id {
field = field.id(format!("{id}-search"));
}
let kept = self.kept.clone();
Row::new()
.part(&self.part(WindowTabsPart::Search))
.on_key_down(move |event: KeyboardEvent| {
let plain = !(event.ctrl || event.alt || event.meta || event.shift);
if event.focus_within
&& plain
&& !event.composing
&& event.key == "ArrowDown"
&& let Some(first) = first
{
event.prevent_default();
kept.focus_menu(MenuFocus::Item(first));
}
})
.child(field)
.into()
}
fn no_match(&self, query: &str) -> Element {
let part = self.part(WindowTabsPart::Empty);
let words = crate::core::fill(
&crate::ui::current_locale().navigation.no_tab_matches,
&[("query", query.trim())],
);
Row::new().part(&part).child(part.text(&words)).into()
}
fn items(&self, listed: &Arc<[usize]>) -> Element {
let mut rows = Column::new()
.align_items(Alignment::Stretch)
.part(&self.part(WindowTabsPart::Items))
.focus_group(FocusGroup::vertical().one_stop(true))
.describe("a11y_role", "listbox")
.describe("a11y_name", crate::ui::current_locale().navigation.open_tabs.clone());
for (at, index) in listed.iter().enumerate() {
rows = rows.child(self.item(*index, at, listed));
}
ScrollVertical::new(rows).flex_shrink(1.0).min_height(0.0).into()
}
fn chooser(&self, index: usize) -> impl Fn() + Send + Sync + 'static {
let (select, kept, follows) = (self.tabs[index].select.clone(), self.kept.clone(), self.tab_stop);
let told = self.open_told();
move || {
kept.refocus.store(follows, Ordering::Relaxed);
kept.open.set(false);
told(false);
select();
}
}
fn item(&self, index: usize, at: usize, listed: &Arc<[usize]>) -> Element {
let entry = &self.tabs[index];
let part = |part: WindowTabsPart| self.item_part(index, part);
let disabled = self.disabled || entry.disabled;
let choose = self.chooser(index);
let label = entry.list_label.as_ref().unwrap_or(&entry.label);
let mut row = pressable(&part(WindowTabsPart::Item), disabled)
.justify(Justify::Start)
.align_items(Alignment::Center)
.interaction_group(true)
.focus_entry(entry.selected)
.ref_element(self.kept.item_ref(index))
.describe("a11y_role", "option")
.describe("a11y_name", label.clone())
.describe("a11y_selected", if entry.selected { "true" } else { "false" })
.on_click(move |_| choose());
if self.hidden[index] {
row = row.describe(
"a11y_description",
crate::ui::current_locale().navigation.not_in_strip.clone(),
);
}
if !disabled {
row = row.on_key_down(self.item_keys(index, at, listed));
if self.closable(index) {
let close = entry.close.clone();
row = row.on_mouse_click(MouseButton::Middle, move |event: MouseEvent| {
event.stop_propagation();
close();
});
}
}
if let Some(icon) = entry.icon {
row = row.child(glyph(&part(WindowTabsPart::ItemIcon), icon, false));
}
let (grow, basis) = if entry.list_detail.is_some() {
(0.0, None)
} else {
(1.0, Some(0.0))
};
row = row.child(
Row::new()
.flex_full(grow, 1.0, basis)
.min_width(0.0)
.child(one_line(&part(WindowTabsPart::ItemLabel), label)),
);
if let Some(detail) = &entry.list_detail {
row = row.child(
Row::new()
.flex_full(1.0, 1.0, Some(0.0))
.min_width(0.0)
.child(one_line(&part(WindowTabsPart::ItemDetail), detail)),
);
}
let mark = |what: WindowTabsPart, name: &str, suffix: &str| {
let mut mark = Row::new().child(glyph(&part(what), Name::new(name), false));
if let Some(id) = &entry.id {
mark = mark.id(format!("{id}-item-{suffix}"));
}
mark
};
if self.hidden[index] {
row = row.child(mark(WindowTabsPart::ItemHidden, icons::EYE_OFF, "hidden"));
}
if !entry.list_trailing.is_empty() {
row = row.child(
Row::new()
.part(&part(WindowTabsPart::ItemMarks))
.align_items(Alignment::Center)
.flex_shrink(0.0)
.with_children(entry.list_trailing.iter().cloned()),
);
}
if entry.selected {
row = row.child(mark(WindowTabsPart::ItemCurrent, icons::CHECK, "current"));
}
row = row.child(self.item_close(index));
if let Some(id) = &entry.id {
row = row.id(format!("{id}-item"));
}
if let Some(key) = entry.key.as_ref().or(entry.id.as_ref()) {
row = row.key(key.clone());
}
row.into()
}
fn item_close(&self, index: usize) -> Element {
let entry = &self.tabs[index];
let part = self.item_part(index, WindowTabsPart::ItemClose);
if !self.closable(index) {
return Row::new().part(&part.clone().unnamed()).into();
}
let close = entry.close.clone();
let mut button = components::Button::empty()
.focusable(false)
.part(&part)
.justify(Justify::Center)
.align_items(Alignment::Center)
.describe("a11y_name", format!("{} {}", self.words.close, entry.label))
.on_mouse_down(|event: MouseEvent| event.stop_propagation())
.on_click(move |event: MouseEvent| {
event.stop_propagation();
close();
})
.child(glyph(
&self.item_part(index, WindowTabsPart::ItemCloseIcon),
Name::new(icons::CLOSE),
false,
));
if let Some(id) = &entry.id {
button = button.id(format!("{id}-item-close"));
}
button.into()
}
fn item_keys(&self, index: usize, at: usize, listed: &Arc<[usize]>) -> impl Fn(KeyboardEvent) + Send + Sync + 'static {
let (kept, listed) = (self.kept.clone(), listed.clone());
let close = self.closable(index).then(|| self.tabs[index].close.clone());
let (searched, count) = (self.searched(), self.tabs.len());
move |event: KeyboardEvent| {
if !event.focus_within || event.composing {
return;
}
if closes(&event) {
event.prevent_default();
event.stop_propagation();
let Some(close) = &close else {
return;
};
close();
let next = listed
.get(at + 1)
.map(|next| next - 1)
.or_else(|| at.checked_sub(1).and_then(|before| listed.get(before).copied()));
if let Some(next) = next {
kept.focus_menu_with(MenuFocus::Item(next), count - 1);
}
return;
}
let plain = !(event.ctrl || event.alt || event.meta || event.shift);
if plain && at == 0 && searched && event.key == "ArrowUp" {
event.prevent_default();
kept.focus_menu(MenuFocus::Search);
}
}
}
}