use super::{Entry, FocusGroups, Group, Memory};
use crate::context::{gesture::Gestures, id_map::IdSet, HitRegion, Id};
impl FocusGroups {
pub(crate) fn publish(&mut self, hits: &[HitRegion], focused: Option<Id>) {
let building = std::mem::take(&mut self.building);
let registered = std::mem::take(&mut self.registered);
self.seen.clear();
self.open.clear();
self.groups.clear();
self.parent.clear();
if building.is_empty() {
self.memory.clear();
return;
}
let present: IdSet = hits
.iter()
.filter(|hit| hit.action.focusable() && registered.contains_key(&hit.id))
.map(|hit| hit.id)
.collect();
let mut reachable: Vec<Vec<Id>> = vec![Vec::new(); building.len()];
for (index, group) in building.iter().enumerate().rev() {
reachable[index] = group
.items
.iter()
.filter_map(|entry| match *entry {
Entry::Member(id) => present.contains(&id).then_some(id),
Entry::Group(child) => {
(!reachable[child].is_empty()).then_some(building[child].id)
}
})
.collect();
}
for (index, open) in building.iter().enumerate() {
let items = std::mem::take(&mut reachable[index]);
if items.is_empty() {
continue;
}
for item in &items {
self.parent.insert(*item, open.id);
}
let entry = open.entry.filter(|entry| items.contains(entry));
self.groups.insert(
open.id,
Group {
axis: open.axis,
wrap: open.wrap,
items,
entry,
},
);
}
self.fit_memory();
if let Some(focus) = focused {
self.remember(focus);
}
}
fn fit_memory(&mut self) {
let groups = &self.groups;
self.memory.retain(|id, _| groups.contains_key(id));
for (id, memory) in &mut self.memory {
let items = &groups[id].items;
match items.iter().position(|item| *item == memory.item) {
Some(index) => memory.index = index,
None => {
memory.index = memory.index.min(items.len() - 1);
memory.item = items[memory.index];
}
}
}
}
pub(super) fn chain(&self, id: Option<Id>) -> Vec<Id> {
let mut chain = Vec::new();
let mut item = id;
while let Some(&group) = item.and_then(|item| self.parent.get(&item)) {
chain.push(group);
item = Some(group);
}
chain
}
pub(crate) fn remember(&mut self, id: Id) {
let mut item = id;
while let Some(&group) = self.parent.get(&item) {
if let Some(index) = self.groups[&group].items.iter().position(|i| *i == item) {
self.memory.insert(group, Memory { item, index });
}
item = group;
}
}
pub(crate) fn focus_changed(
&mut self,
lost: Option<Id>,
gained: Option<Id>,
gestures: &mut Gestures,
) {
if self.parent.is_empty() {
return;
}
let (before, after) = (self.chain(lost), self.chain(gained));
for group in before.iter().filter(|group| !after.contains(group)) {
gestures.focus_changed(Some(*group), None);
}
for group in after.iter().filter(|group| !before.contains(group)) {
gestures.focus_changed(None, Some(*group));
}
if let Some(focus) = gained {
self.remember(focus);
}
}
pub(crate) fn contains_focus(&self, group: Id, focused: Option<Id>) -> bool {
let mut item = focused;
while let Some(&outer) = item.and_then(|item| self.parent.get(&item)) {
if outer == group {
return true;
}
item = Some(outer);
}
false
}
}