use super::{queue::Pushed, Claim, Owner, CLAIMS_PER_WIDGET};
use crate::{
actions::Mods,
context::{id_map::IdSet, key_events::KeyEvent, Context, DiagnosticKind, Id, KeyInterest},
};
use winit::{
event::ElementState,
keyboard::{Key, KeyCode, NativeKey, PhysicalKey},
};
impl Claim {
fn matches(&self, code: KeyCode, layout: KeyCode, mods: Mods) -> bool {
let key = if self.by_position { code } else { layout };
key == self.key && self.mods.is_none_or(|wanted| wanted == mods)
}
}
impl Context {
pub(crate) fn claim_keys(&mut self, id: Id, interest: &KeyInterest<'_>) {
let mods = interest
.mods
.map(|mods| mods.concrete(self.action_platform()));
let list = self.keys.claims_of(id);
let mut full = false;
for &key in interest.keys {
let claim = Claim {
key,
mods,
by_position: interest.by_position,
repeats: interest.repeats,
releases: interest.releases,
};
if list.contains(&claim) {
continue;
}
if list.len() >= CLAIMS_PER_WIDGET {
full = true;
break;
}
list.push(claim);
}
if full {
self.report(DiagnosticKind::InvalidUsage, Some(id), None, || {
"too many key claims for one widget; the extra keys are ignored".into()
});
}
}
pub(crate) fn take_key_events(&mut self, id: Id) -> Vec<KeyEvent> {
if self.keys.pending() == 0 || self.input_blocked() {
return Vec::new();
}
self.keys.take(id)
}
pub(crate) fn publish_key_claims(&mut self) {
let fresh = std::mem::take(&mut self.keys.fresh);
if fresh || !self.keys.invalid.is_empty() {
self.check_key_claims(fresh);
}
let invalid: Vec<Id> = self.keys.invalid.iter().copied().collect();
for id in invalid {
self.report(DiagnosticKind::InvalidUsage, Some(id), None, || {
"key claims need a region that takes focus (Sense::FOCUS) that is not a \
text field, slider or other control that keeps its keys"
.into()
});
}
self.keys.publish();
}
fn check_key_claims(&mut self, fresh: bool) {
let keys = &self.keys;
let watched = |id: &Id| {
if fresh {
keys.declared.contains_key(id)
} else {
keys.invalid.contains(id)
}
};
let ok: IdSet = self
.interaction
.previous_hits
.iter()
.filter(|hit| hit.action.focusable() && !hit.action.keeps_keys() && watched(&hit.id))
.map(|hit| hit.id)
.collect();
let candidates: Vec<Id> = if fresh {
keys.declared.keys().copied().collect()
} else {
keys.invalid.iter().copied().collect()
};
for id in candidates {
if ok.contains(&id) {
self.keys.invalid.remove(&id);
} else {
self.keys.invalid.insert(id);
}
}
}
pub(in crate::context) fn key_layer_open(&self, window: Id) -> bool {
if self.popups.is_active() {
return self.popups.is_top_layer(window);
}
self.top_modal_id().is_none_or(|top| window == top)
}
pub(in crate::context) fn owned_key_tail(
&mut self,
code: KeyCode,
layout: KeyCode,
state: ElementState,
repeat: bool,
) -> bool {
let Some(owner) = self.keys.owners.get(&code).copied() else {
return false;
};
let pressed = state == ElementState::Pressed;
if pressed && !repeat {
self.keys.owners.remove(&code);
return false;
}
self.input.record_key(code, pressed);
if pressed {
match owner {
Owner::Navigation => {
self.group_key(code);
}
Owner::Widget {
id,
repeats: true,
dropped: false,
..
} => {
let event = self.key_event(code, layout, state, repeat);
self.keys.push(id, event);
}
Owner::Widget { .. } => {}
}
return true;
}
self.keys.owners.remove(&code);
if let Owner::Widget {
id,
releases: true,
dropped: false,
..
} = owner
{
let event = self.key_event(code, layout, state, repeat);
self.keys.push(id, event);
}
true
}
pub(in crate::context) fn claimed_key(
&mut self,
code: KeyCode,
layout: KeyCode,
state: ElementState,
repeat: bool,
) -> bool {
if state != ElementState::Pressed
|| repeat
|| !self.keys.has_claims()
|| self.key_capture_active()
|| self.pending_strokes().is_some()
{
return false;
}
let Some(id) = self.interaction.focused else {
return false;
};
let mods = Mods::from_state(self.input.modifiers);
let Some(claims) = self.keys.published.get(&id) else {
return false;
};
let mut wanted: Option<(bool, bool)> = None;
for claim in claims.iter().filter(|c| c.matches(code, layout, mods)) {
let (repeats, releases) = wanted.unwrap_or_default();
wanted = Some((repeats | claim.repeats, releases | claim.releases));
}
let Some((repeats, releases)) = wanted else {
return false;
};
let Some(hit) = self
.interaction
.previous_hits
.iter()
.find(|hit| hit.id == id && hit.action.focusable())
else {
return false;
};
if hit.action.keeps_keys() || !self.key_layer_open(hit.window) {
return false;
}
let event = self.key_event(code, layout, state, repeat);
let dropped = match self.keys.push(id, event) {
Pushed::Queued => false,
Pushed::Dropped { first } => {
if first {
self.report(DiagnosticKind::InvalidUsage, Some(id), None, || {
"key queue full: events are dropped until the widget takes its keys \
with Ui::keys in every pass"
.into()
});
}
true
}
};
self.keys.owners.insert(
code,
Owner::Widget {
id,
repeats,
releases,
dropped,
},
);
self.input.record_key(code, true);
self.keys.claimed = true;
true
}
fn key_event(
&self,
code: KeyCode,
layout: KeyCode,
state: ElementState,
repeat: bool,
) -> KeyEvent {
let (physical, logical, text) = self.keys.raw.clone().unwrap_or((
PhysicalKey::Code(code),
Key::Unidentified(NativeKey::Unidentified),
None,
));
KeyEvent {
code,
layout,
physical,
logical,
state,
repeat,
modifiers: self.input.modifiers,
text,
}
}
}