#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Landmark {
Banner,
Navigation,
Main,
Complementary,
ContentInfo,
Search,
Status,
}
impl Landmark {
pub fn as_str(self) -> &'static str {
match self {
Self::Banner => "banner",
Self::Navigation => "navigation",
Self::Main => "main",
Self::Complementary => "complementary",
Self::ContentInfo => "contentinfo",
Self::Search => "search",
Self::Status => "status",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Live {
Off,
Polite,
Assertive,
}
pub fn rove(active: usize, delta: i32, len: usize) -> usize {
if len == 0 {
return 0;
}
(active as i32 + delta).rem_euclid(len as i32) as usize
}
pub fn spatial_next(
from: usize,
press: crate::key::Press,
centers: &[(f32, f32)],
) -> Option<usize> {
let (fx, fy) = *centers.get(from)?;
let (dx, dy) = match press {
crate::key::Press::ArrowLeft => (-1.0, 0.0),
crate::key::Press::ArrowRight => (1.0, 0.0),
crate::key::Press::ArrowUp => (0.0, -1.0),
crate::key::Press::ArrowDown => (0.0, 1.0),
_ => return None,
};
let mut best: Option<(usize, f32)> = None;
for (i, (x, y)) in centers.iter().copied().enumerate() {
if i == from {
continue;
}
let vx = x - fx;
let vy = y - fy;
let along = vx * dx + vy * dy;
if along <= 0.0 {
continue;
}
let cross = (vx * dy - vy * dx).abs();
let score = along + cross * 2.0;
if best.is_none_or(|(_, s)| score < s) {
best = Some((i, score));
}
}
best.map(|(i, _)| i)
}
pub fn trap_escape(press: &crate::key::Press) -> bool {
matches!(press, crate::key::Press::Escape)
}
pub fn ring(tok: crate::theme::Tokens, focused: bool) -> iced::widget::container::Style {
let s = tok.scheme();
iced::widget::container::Style {
border: iced::Border {
color: if focused {
crate::theme::mix(s.primary, s.surface, 0.45)
} else {
iced::Color::TRANSPARENT
},
width: if focused { 2.0 } else { 0.0 },
radius: tok.radius(crate::m3::shape::Component::Field),
},
..iced::widget::container::Style::default()
}
}
fn ring_inset(bounds: iced::Rectangle, requested: f32) -> f32 {
let room = bounds.width.min(bounds.height);
let stroke = 2.0;
if room <= 24.0 {
stroke
} else {
requested.max(0.0)
}
}
fn start_child_bounds(
layout: iced::advanced::Layout<'_>,
direction: crate::i18n::Direction,
) -> Option<iced::Rectangle> {
let mut node = layout;
loop {
let kids: Vec<_> = node.children().collect();
match kids.len() {
0 => return Some(node.bounds()),
1 => node = kids[0],
_ => {
let mark = if direction == crate::i18n::Direction::Rtl {
*kids.last()?
} else {
kids[0]
};
return Some(
mark.children()
.next()
.map(|c| c.bounds())
.unwrap_or_else(|| mark.bounds()),
);
}
}
}
}
fn ring_bounds(bounds: iced::Rectangle, width: f32) -> iced::Rectangle {
let w = width.max(0.0);
iced::Rectangle {
x: bounds.x + w,
y: bounds.y + w,
width: (bounds.width - 2.0 * w).max(0.0),
height: (bounds.height - 2.0 * w).max(0.0),
}
}
pub fn target<'a, M: Clone + 'a>(
child: iced::Element<'a, M>,
tok: crate::theme::Tokens,
can_focus: bool,
) -> iced::Element<'a, M> {
Target {
content: child,
tok,
can_focus,
on_key: None,
open_on_activate: false,
keys_first: false,
paint_ring: true,
ring_start: false,
}
.into()
}
pub fn target_keys<'a, M: Clone + 'a>(
child: iced::Element<'a, M>,
tok: crate::theme::Tokens,
can_focus: bool,
on_key: impl Fn(crate::key::Press) -> Option<M> + 'a,
) -> iced::Element<'a, M> {
Target {
content: child,
tok,
can_focus,
on_key: Some(Box::new(on_key)),
open_on_activate: false,
keys_first: false,
paint_ring: true,
ring_start: false,
}
.into()
}
pub fn target_keys_start<'a, M: Clone + 'a>(
child: iced::Element<'a, M>,
tok: crate::theme::Tokens,
can_focus: bool,
on_key: impl Fn(crate::key::Press) -> Option<M> + 'a,
) -> iced::Element<'a, M> {
Target {
content: child,
tok,
can_focus,
on_key: Some(Box::new(on_key)),
open_on_activate: false,
keys_first: false,
paint_ring: true,
ring_start: true,
}
.into()
}
pub fn target_keys_open<'a, M: Clone + 'a>(
child: iced::Element<'a, M>,
tok: crate::theme::Tokens,
can_focus: bool,
on_key: impl Fn(crate::key::Press) -> Option<M> + 'a,
) -> iced::Element<'a, M> {
Target {
content: child,
tok,
can_focus,
on_key: Some(Box::new(on_key)),
open_on_activate: true,
keys_first: false,
paint_ring: true,
ring_start: false,
}
.into()
}
pub fn group<'a, M: Clone + 'a>(
child: iced::Element<'a, M>,
tok: crate::theme::Tokens,
can_focus: bool,
) -> iced::Element<'a, M> {
Target {
content: child,
tok,
can_focus,
on_key: None,
open_on_activate: false,
keys_first: false,
paint_ring: false,
ring_start: false,
}
.into()
}
pub fn group_keys<'a, M: Clone + 'a>(
child: iced::Element<'a, M>,
tok: crate::theme::Tokens,
can_focus: bool,
on_key: impl Fn(crate::key::Press) -> Option<M> + 'a,
) -> iced::Element<'a, M> {
Target {
content: child,
tok,
can_focus,
on_key: Some(Box::new(on_key)),
open_on_activate: false,
keys_first: false,
paint_ring: false,
ring_start: false,
}
.into()
}
pub fn group_keys_open<'a, M: Clone + 'a>(
child: iced::Element<'a, M>,
tok: crate::theme::Tokens,
can_focus: bool,
on_key: impl Fn(crate::key::Press) -> Option<M> + 'a,
) -> iced::Element<'a, M> {
Target {
content: child,
tok,
can_focus,
on_key: Some(Box::new(on_key)),
open_on_activate: true,
keys_first: false,
paint_ring: false,
ring_start: false,
}
.into()
}
pub fn intercept_keys<'a, M: Clone + 'a>(
child: iced::Element<'a, M>,
tok: crate::theme::Tokens,
can_focus: bool,
on_key: impl Fn(crate::key::Press) -> Option<M> + 'a,
) -> iced::Element<'a, M> {
Target {
content: child,
tok,
can_focus,
on_key: Some(Box::new(on_key)),
open_on_activate: false,
keys_first: true,
paint_ring: false,
ring_start: false,
}
.into()
}
struct Target<'a, Message> {
content: iced::Element<'a, Message>,
tok: crate::theme::Tokens,
can_focus: bool,
on_key: Option<Box<dyn Fn(crate::key::Press) -> Option<Message> + 'a>>,
open_on_activate: bool,
keys_first: bool,
paint_ring: bool,
ring_start: bool,
}
#[derive(Default)]
struct TargetState {
focused: bool,
}
impl iced::advanced::widget::operation::focusable::Focusable for TargetState {
fn is_focused(&self) -> bool {
self.focused
}
fn focus(&mut self) {
self.focused = true;
}
fn unfocus(&mut self) {
self.focused = false;
}
}
impl<Message: Clone> Target<'_, Message> {
fn apply_keys(
&self,
tree: &iced::advanced::widget::Tree,
event: &iced::Event,
shell: &mut iced::advanced::Shell<'_, Message>,
) -> bool {
if !self.can_focus {
return false;
}
let iced::Event::Keyboard(kev) = event else {
return false;
};
let state = tree.state.downcast_ref::<TargetState>();
if !state.focused || shell.is_event_captured() {
return false;
}
let Some(press) = crate::key::press(kev) else {
return false;
};
let Some(on_key) = &self.on_key else {
return false;
};
let Some(msg) = on_key(press) else {
return false;
};
shell.publish(msg);
shell.capture_event();
true
}
}
impl<'a, Message: Clone> iced::advanced::Widget<Message, iced::Theme, iced::Renderer>
for Target<'a, Message>
{
fn tag(&self) -> iced::advanced::widget::tree::Tag {
iced::advanced::widget::tree::Tag::of::<TargetState>()
}
fn state(&self) -> iced::advanced::widget::tree::State {
iced::advanced::widget::tree::State::new(TargetState::default())
}
fn children(&self) -> Vec<iced::advanced::widget::Tree> {
vec![iced::advanced::widget::Tree::new(&self.content)]
}
fn diff(&self, tree: &mut iced::advanced::widget::Tree) {
tree.diff_children(std::slice::from_ref(&self.content));
}
fn size(&self) -> iced::Size<iced::Length> {
self.content.as_widget().size()
}
fn layout(
&mut self,
tree: &mut iced::advanced::widget::Tree,
renderer: &iced::Renderer,
limits: &iced::advanced::layout::Limits,
) -> iced::advanced::layout::Node {
self.content
.as_widget_mut()
.layout(&mut tree.children[0], renderer, limits)
}
fn update(
&mut self,
tree: &mut iced::advanced::widget::Tree,
event: &iced::Event,
layout: iced::advanced::Layout<'_>,
cursor: iced::mouse::Cursor,
renderer: &iced::Renderer,
clipboard: &mut dyn iced::advanced::Clipboard,
shell: &mut iced::advanced::Shell<'_, Message>,
viewport: &iced::Rectangle,
) {
if self.keys_first && self.apply_keys(tree, event, shell) {
return;
}
self.content.as_widget_mut().update(
&mut tree.children[0],
event,
layout,
cursor,
renderer,
clipboard,
shell,
viewport,
);
if !self.can_focus {
return;
}
let over = cursor
.position()
.is_some_and(|p| layout.bounds().contains(p));
match event {
iced::Event::Mouse(iced::mouse::Event::ButtonPressed(iced::mouse::Button::Left))
| iced::Event::Touch(iced::touch::Event::FingerPressed { .. }) => {
let state = tree.state.downcast_mut::<TargetState>();
if state.focused != over {
state.focused = over;
shell.request_redraw();
}
}
iced::Event::Keyboard(kev) if !self.keys_first => {
if self.apply_keys(tree, event, shell) {
return;
}
if self.open_on_activate
&& tree.state.downcast_ref::<TargetState>().focused
&& !shell.is_event_captured()
{
if let Some(press) = crate::key::press(kev) {
if activate_press(&press) {
let at = iced::mouse::Cursor::Available(layout.bounds().center());
self.content.as_widget_mut().update(
&mut tree.children[0],
&iced::Event::Mouse(iced::mouse::Event::ButtonPressed(
iced::mouse::Button::Left,
)),
layout,
at,
renderer,
clipboard,
shell,
viewport,
);
shell.capture_event();
}
}
}
}
_ => {}
}
}
fn draw(
&self,
tree: &iced::advanced::widget::Tree,
renderer: &mut iced::Renderer,
theme: &iced::Theme,
style: &iced::advanced::renderer::Style,
layout: iced::advanced::Layout<'_>,
cursor: iced::mouse::Cursor,
viewport: &iced::Rectangle,
) {
self.content.as_widget().draw(
&tree.children[0],
renderer,
theme,
style,
layout,
cursor,
viewport,
);
let focused = self.can_focus && tree.state.downcast_ref::<TargetState>().focused;
if !focused || !self.paint_ring {
return;
}
let bounds = if self.ring_start {
start_child_bounds(layout, self.tok.direction).unwrap_or_else(|| layout.bounds())
} else {
layout.bounds()
};
let Some(layer) = bounds.intersection(viewport) else {
return;
};
let face = ring(self.tok, true);
let inset = ring_inset(bounds, crate::m3::density::GRID as f32);
iced::advanced::Renderer::with_layer(renderer, layer, |renderer| {
iced::advanced::Renderer::fill_quad(
renderer,
iced::advanced::renderer::Quad {
bounds: ring_bounds(bounds, inset),
border: face.border,
..iced::advanced::renderer::Quad::default()
},
iced::Background::Color(iced::Color::TRANSPARENT),
);
});
}
fn operate(
&mut self,
tree: &mut iced::advanced::widget::Tree,
layout: iced::advanced::Layout<'_>,
renderer: &iced::Renderer,
operation: &mut dyn iced::advanced::widget::Operation,
) {
if self.can_focus {
let state = tree.state.downcast_mut::<TargetState>();
operation.focusable(None, layout.bounds(), state);
}
self.content
.as_widget_mut()
.operate(&mut tree.children[0], layout, renderer, operation);
}
fn mouse_interaction(
&self,
tree: &iced::advanced::widget::Tree,
layout: iced::advanced::Layout<'_>,
cursor: iced::mouse::Cursor,
viewport: &iced::Rectangle,
renderer: &iced::Renderer,
) -> iced::mouse::Interaction {
self.content.as_widget().mouse_interaction(
&tree.children[0],
layout,
cursor,
viewport,
renderer,
)
}
fn overlay<'b>(
&'b mut self,
tree: &'b mut iced::advanced::widget::Tree,
layout: iced::advanced::Layout<'b>,
renderer: &iced::Renderer,
viewport: &iced::Rectangle,
translation: iced::Vector,
) -> Option<iced::advanced::overlay::Element<'b, Message, iced::Theme, iced::Renderer>> {
self.content.as_widget_mut().overlay(
&mut tree.children[0],
layout,
renderer,
viewport,
translation,
)
}
}
impl<'a, Message: Clone + 'a> From<Target<'a, Message>> for iced::Element<'a, Message> {
fn from(value: Target<'a, Message>) -> Self {
Self::new(value)
}
}
fn activate_press(press: &crate::key::Press) -> bool {
matches!(press, crate::key::Press::Enter)
|| matches!(press, crate::key::Press::Character(s) if s == " ")
}
pub fn dismiss_on_escape<'a, M: Clone + 'a>(
child: iced::Element<'a, M>,
on_escape: M,
) -> iced::Element<'a, M> {
DismissEscape {
content: child,
on_escape,
}
.into()
}
struct DismissEscape<'a, Message> {
content: iced::Element<'a, Message>,
on_escape: Message,
}
impl<'a, Message: Clone> iced::advanced::Widget<Message, iced::Theme, iced::Renderer>
for DismissEscape<'a, Message>
{
fn children(&self) -> Vec<iced::advanced::widget::Tree> {
vec![iced::advanced::widget::Tree::new(&self.content)]
}
fn diff(&self, tree: &mut iced::advanced::widget::Tree) {
tree.diff_children(std::slice::from_ref(&self.content));
}
fn size(&self) -> iced::Size<iced::Length> {
self.content.as_widget().size()
}
fn layout(
&mut self,
tree: &mut iced::advanced::widget::Tree,
renderer: &iced::Renderer,
limits: &iced::advanced::layout::Limits,
) -> iced::advanced::layout::Node {
self.content
.as_widget_mut()
.layout(&mut tree.children[0], renderer, limits)
}
fn update(
&mut self,
tree: &mut iced::advanced::widget::Tree,
event: &iced::Event,
layout: iced::advanced::Layout<'_>,
cursor: iced::mouse::Cursor,
renderer: &iced::Renderer,
clipboard: &mut dyn iced::advanced::Clipboard,
shell: &mut iced::advanced::Shell<'_, Message>,
viewport: &iced::Rectangle,
) {
self.content.as_widget_mut().update(
&mut tree.children[0],
event,
layout,
cursor,
renderer,
clipboard,
shell,
viewport,
);
if shell.is_event_captured() {
return;
}
if matches!(
event,
iced::Event::Keyboard(iced::keyboard::Event::KeyPressed {
key: iced::keyboard::Key::Named(iced::keyboard::key::Named::Escape),
..
})
) {
shell.publish(self.on_escape.clone());
shell.capture_event();
}
}
fn draw(
&self,
tree: &iced::advanced::widget::Tree,
renderer: &mut iced::Renderer,
theme: &iced::Theme,
style: &iced::advanced::renderer::Style,
layout: iced::advanced::Layout<'_>,
cursor: iced::mouse::Cursor,
viewport: &iced::Rectangle,
) {
self.content.as_widget().draw(
&tree.children[0],
renderer,
theme,
style,
layout,
cursor,
viewport,
);
}
fn operate(
&mut self,
tree: &mut iced::advanced::widget::Tree,
layout: iced::advanced::Layout<'_>,
renderer: &iced::Renderer,
operation: &mut dyn iced::advanced::widget::Operation,
) {
self.content
.as_widget_mut()
.operate(&mut tree.children[0], layout, renderer, operation);
}
fn mouse_interaction(
&self,
tree: &iced::advanced::widget::Tree,
layout: iced::advanced::Layout<'_>,
cursor: iced::mouse::Cursor,
viewport: &iced::Rectangle,
renderer: &iced::Renderer,
) -> iced::mouse::Interaction {
self.content.as_widget().mouse_interaction(
&tree.children[0],
layout,
cursor,
viewport,
renderer,
)
}
fn overlay<'b>(
&'b mut self,
tree: &'b mut iced::advanced::widget::Tree,
layout: iced::advanced::Layout<'b>,
renderer: &iced::Renderer,
viewport: &iced::Rectangle,
translation: iced::Vector,
) -> Option<iced::advanced::overlay::Element<'b, Message, iced::Theme, iced::Renderer>> {
self.content.as_widget_mut().overlay(
&mut tree.children[0],
layout,
renderer,
viewport,
translation,
)
}
}
impl<'a, Message: Clone + 'a> From<DismissEscape<'a, Message>> for iced::Element<'a, Message> {
fn from(value: DismissEscape<'a, Message>) -> Self {
Self::new(value)
}
}
pub fn cycle<'a, M: 'a>(
child: iced::Element<'a, M>,
first: Option<iced::widget::Id>,
) -> iced::Element<'a, M> {
Cycle {
content: child,
first,
}
.into()
}
struct Cycle<'a, Message> {
content: iced::Element<'a, Message>,
first: Option<iced::widget::Id>,
}
#[derive(Default)]
struct CycleState {
mounted: bool,
}
impl<'a, Message> iced::advanced::Widget<Message, iced::Theme, iced::Renderer>
for Cycle<'a, Message>
{
fn tag(&self) -> iced::advanced::widget::tree::Tag {
iced::advanced::widget::tree::Tag::of::<CycleState>()
}
fn state(&self) -> iced::advanced::widget::tree::State {
iced::advanced::widget::tree::State::new(CycleState::default())
}
fn children(&self) -> Vec<iced::advanced::widget::Tree> {
vec![iced::advanced::widget::Tree::new(&self.content)]
}
fn diff(&self, tree: &mut iced::advanced::widget::Tree) {
tree.diff_children(std::slice::from_ref(&self.content));
}
fn size(&self) -> iced::Size<iced::Length> {
self.content.as_widget().size()
}
fn layout(
&mut self,
tree: &mut iced::advanced::widget::Tree,
renderer: &iced::Renderer,
limits: &iced::advanced::layout::Limits,
) -> iced::advanced::layout::Node {
self.content
.as_widget_mut()
.layout(&mut tree.children[0], renderer, limits)
}
fn update(
&mut self,
tree: &mut iced::advanced::widget::Tree,
event: &iced::Event,
layout: iced::advanced::Layout<'_>,
cursor: iced::mouse::Cursor,
renderer: &iced::Renderer,
clipboard: &mut dyn iced::advanced::Clipboard,
shell: &mut iced::advanced::Shell<'_, Message>,
viewport: &iced::Rectangle,
) {
let state = tree.state.downcast_mut::<CycleState>();
if !state.mounted {
state.mounted = true;
apply_first_focus(
&mut self.content,
tree,
layout,
renderer,
self.first.as_ref(),
);
}
self.content.as_widget_mut().update(
&mut tree.children[0],
event,
layout,
cursor,
renderer,
clipboard,
shell,
viewport,
);
if shell.is_event_captured() {
return;
}
let iced::Event::Keyboard(iced::keyboard::Event::KeyPressed { key, modifiers, .. }) = event
else {
return;
};
if !matches!(
key,
iced::keyboard::Key::Named(iced::keyboard::key::Named::Tab)
) {
return;
}
if modifiers.control() || modifiers.alt() || modifiers.logo() {
return;
}
cycle_by(
&mut self.content,
tree,
layout,
renderer,
if modifiers.shift() { -1 } else { 1 },
);
shell.capture_event();
shell.request_redraw();
}
fn draw(
&self,
tree: &iced::advanced::widget::Tree,
renderer: &mut iced::Renderer,
theme: &iced::Theme,
style: &iced::advanced::renderer::Style,
layout: iced::advanced::Layout<'_>,
cursor: iced::mouse::Cursor,
viewport: &iced::Rectangle,
) {
self.content.as_widget().draw(
&tree.children[0],
renderer,
theme,
style,
layout,
cursor,
viewport,
);
}
fn operate(
&mut self,
tree: &mut iced::advanced::widget::Tree,
layout: iced::advanced::Layout<'_>,
renderer: &iced::Renderer,
operation: &mut dyn iced::advanced::widget::Operation,
) {
self.content
.as_widget_mut()
.operate(&mut tree.children[0], layout, renderer, operation);
}
fn mouse_interaction(
&self,
tree: &iced::advanced::widget::Tree,
layout: iced::advanced::Layout<'_>,
cursor: iced::mouse::Cursor,
viewport: &iced::Rectangle,
renderer: &iced::Renderer,
) -> iced::mouse::Interaction {
self.content.as_widget().mouse_interaction(
&tree.children[0],
layout,
cursor,
viewport,
renderer,
)
}
fn overlay<'b>(
&'b mut self,
tree: &'b mut iced::advanced::widget::Tree,
layout: iced::advanced::Layout<'b>,
renderer: &iced::Renderer,
viewport: &iced::Rectangle,
translation: iced::Vector,
) -> Option<iced::advanced::overlay::Element<'b, Message, iced::Theme, iced::Renderer>> {
self.content.as_widget_mut().overlay(
&mut tree.children[0],
layout,
renderer,
viewport,
translation,
)
}
}
fn cycle_by<M>(
content: &mut iced::Element<'_, M>,
tree: &mut iced::advanced::widget::Tree,
layout: iced::advanced::Layout<'_>,
renderer: &iced::Renderer,
delta: i32,
) {
use iced::advanced::widget::operation::{focusable::Focusable, Operation};
struct Count {
focused: Option<usize>,
n: usize,
}
impl Operation<()> for Count {
fn focusable(
&mut self,
_id: Option<&iced::widget::Id>,
_bounds: iced::Rectangle,
state: &mut dyn Focusable,
) {
if state.is_focused() {
self.focused = Some(self.n);
}
self.n += 1;
}
fn traverse(&mut self, operate: &mut dyn FnMut(&mut dyn Operation<()>)) {
operate(self);
}
}
let mut count = Count {
focused: None,
n: 0,
};
content
.as_widget_mut()
.operate(&mut tree.children[0], layout, renderer, &mut count);
if count.n == 0 {
return;
}
let from = count
.focused
.unwrap_or(if delta > 0 { count.n - 1 } else { 0 });
let want = rove(from, delta, count.n);
struct Set {
i: usize,
want: usize,
}
impl Operation<()> for Set {
fn focusable(
&mut self,
_id: Option<&iced::widget::Id>,
_bounds: iced::Rectangle,
state: &mut dyn Focusable,
) {
if self.i == self.want {
state.focus();
} else {
state.unfocus();
}
self.i += 1;
}
fn traverse(&mut self, operate: &mut dyn FnMut(&mut dyn Operation<()>)) {
operate(self);
}
}
let mut set = Set { i: 0, want };
content
.as_widget_mut()
.operate(&mut tree.children[0], layout, renderer, &mut set);
}
fn apply_op<M>(
content: &mut iced::Element<'_, M>,
tree: &mut iced::advanced::widget::Tree,
layout: iced::advanced::Layout<'_>,
renderer: &iced::Renderer,
mut op: impl iced::advanced::widget::Operation<()>,
) {
use iced::advanced::widget::operation::{Operation, Outcome};
content
.as_widget_mut()
.operate(&mut tree.children[0], layout, renderer, &mut op);
if let Outcome::Chain(mut next) = Operation::finish(&op) {
content
.as_widget_mut()
.operate(&mut tree.children[0], layout, renderer, next.as_mut());
}
}
fn apply_first_focus<M>(
content: &mut iced::Element<'_, M>,
tree: &mut iced::advanced::widget::Tree,
layout: iced::advanced::Layout<'_>,
renderer: &iced::Renderer,
first: Option<&iced::widget::Id>,
) {
if let Some(id) = first {
apply_op(
content,
tree,
layout,
renderer,
iced::advanced::widget::operation::focusable::focus::<()>(id.clone()),
);
} else {
apply_op(
content,
tree,
layout,
renderer,
iced::advanced::widget::operation::focusable::focus_next::<()>(),
);
}
}
impl<'a, Message: 'a> From<Cycle<'a, Message>> for iced::Element<'a, Message> {
fn from(value: Cycle<'a, Message>) -> Self {
Self::new(value)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::key::Press;
fn must(ok: bool, msg: impl std::fmt::Display) {
if !ok {
panic!("{msg}");
}
}
#[test]
#[should_panic(expected = "cover-must")]
fn must_rejects_a_failed_check() {
must(false, "cover-must");
}
#[test]
fn rove_spatial_and_trap() {
assert_eq!(rove(0, 1, 3), 1);
assert_eq!(rove(2, 1, 3), 0);
assert_eq!(rove(0, -1, 3), 2);
assert_eq!(rove(0, 1, 0), 0);
let boxes = [(0.0, 0.0), (200.0, 0.0), (0.0, 120.0)];
assert_eq!(spatial_next(0, Press::ArrowRight, &boxes), Some(1));
assert_eq!(spatial_next(0, Press::ArrowDown, &boxes), Some(2));
assert_eq!(spatial_next(2, Press::ArrowUp, &boxes), Some(0));
assert_eq!(spatial_next(0, Press::ArrowLeft, &boxes), None);
assert_eq!(spatial_next(9, Press::ArrowRight, &boxes), None);
assert_eq!(spatial_next(0, Press::Enter, &boxes), None);
assert!(trap_escape(&Press::Escape));
assert!(!trap_escape(&Press::Enter));
assert_eq!(Landmark::Main.as_str(), "main");
assert_eq!(Landmark::Banner.as_str(), "banner");
assert_eq!(Landmark::Navigation.as_str(), "navigation");
assert_eq!(Landmark::Complementary.as_str(), "complementary");
assert_eq!(Landmark::ContentInfo.as_str(), "contentinfo");
assert_eq!(Landmark::Search.as_str(), "search");
assert_eq!(Landmark::Status.as_str(), "status");
assert_eq!(Live::Polite, Live::Polite);
assert_ne!(Live::Off, Live::Assertive);
let tok = crate::theme::named("dark").tokens;
let on = ring(tok, true);
assert_eq!(on.border.width, 2.0);
assert_eq!(
on.border.color,
crate::theme::mix(tok.scheme().primary, tok.scheme().surface, 0.45)
);
let off = ring(tok, false);
assert_eq!(off.border.width, 0.0);
}
fn pump_click<M: Clone>(el: &mut iced::Element<'_, M>, can_focus: bool) -> bool {
use iced::advanced::layout::{Layout, Limits};
use iced::advanced::widget::operation::{focusable::Focusable, Operation};
use iced::advanced::widget::Tree;
use iced::{Event, Font, Pixels, Point, Rectangle, Size};
struct Count {
n: usize,
focused: usize,
}
impl Operation<()> for Count {
fn focusable(
&mut self,
_id: Option<&iced::widget::Id>,
_bounds: Rectangle,
state: &mut dyn Focusable,
) {
self.n += 1;
if state.is_focused() {
self.focused += 1;
}
}
fn traverse(&mut self, operate: &mut dyn FnMut(&mut dyn Operation<()>)) {
operate(self);
}
}
let mut tree = Tree::new(el.as_widget());
let renderer = iced::Renderer::Secondary(iced_tiny_skia::Renderer::new(
Font::DEFAULT,
Pixels::from(16u32),
));
let limits = Limits::new(Size::ZERO, Size::new(200.0, 80.0));
let node = el.as_widget_mut().layout(&mut tree, &renderer, &limits);
let layout = Layout::new(&node);
let at = Point::new(8.0, 8.0);
let mut messages = Vec::<M>::new();
{
let mut shell = iced::advanced::Shell::new(&mut messages);
let mut clipboard = iced::advanced::clipboard::Null;
el.as_widget_mut().update(
&mut tree,
&Event::Mouse(iced::mouse::Event::ButtonPressed(iced::mouse::Button::Left)),
layout,
iced::mouse::Cursor::Available(at),
&renderer,
&mut clipboard,
&mut shell,
&Rectangle::new(Point::ORIGIN, Size::new(200.0, 80.0)),
);
}
let mut op = Count { n: 0, focused: 0 };
el.as_widget_mut()
.operate(&mut tree, layout, &renderer, &mut op);
if can_focus && op.focused == 1 {
use iced::advanced::renderer::Style;
use iced::Theme;
let mut renderer = iced::Renderer::Secondary(iced_tiny_skia::Renderer::new(
Font::DEFAULT,
Pixels::from(16u32),
));
el.as_widget().draw(
&tree,
&mut renderer,
&Theme::Dark,
&Style::default(),
layout,
iced::mouse::Cursor::Unavailable,
&iced::Rectangle::new(Point::ORIGIN, Size::new(200.0, 80.0)),
);
el.as_widget().draw(
&tree,
&mut renderer,
&Theme::Dark,
&Style::default(),
layout,
iced::mouse::Cursor::Unavailable,
&iced::Rectangle::new(Point::new(800.0, 800.0), Size::new(10.0, 10.0)),
);
}
if can_focus {
must(
op.n == 1,
format!("enabled target is one focusable, got {}", op.n),
);
op.focused == 1
} else {
must(op.n == 0, "empty or disabled target is not focusable");
false
}
}
#[test]
fn focused_ring_paints_on_a_layer_above_the_child() {
let src = include_str!("focus.rs");
let body = src
.split("for Target<'a, Message>")
.nth(1)
.expect("Target widget")
.split("fn operate(")
.next()
.expect("Target draw");
let child = body
.find("self.content.as_widget().draw")
.expect("target draws the child");
let layer = body
.find("with_layer")
.expect("ring must use with_layer so a clip row cannot cover it");
must(
layer > child,
"ring layer must start after the child so first and last rows stay under the stroke",
);
}
#[test]
fn ring_sits_inside_the_target_bounds() {
use iced::{Point, Rectangle, Size};
let outer = Rectangle::new(Point::new(10.0, 20.0), Size::new(100.0, 50.0));
let inner = ring_bounds(outer, crate::m3::density::GRID as f32);
assert_eq!(inner.x, 14.0);
assert_eq!(inner.y, 24.0);
assert_eq!(inner.width, 92.0);
assert_eq!(inner.height, 42.0);
let tiny = ring_bounds(Rectangle::new(Point::ORIGIN, Size::new(2.0, 2.0)), 2.0);
assert_eq!(tiny.width, 0.0);
assert_eq!(tiny.height, 0.0);
let mark = Rectangle::new(Point::ORIGIN, Size::new(20.0, 20.0));
must(
ring_inset(mark, crate::m3::density::GRID as f32) == 2.0,
"a radio mark uses the stroke, not a grid inset",
);
let face = Rectangle::new(Point::ORIGIN, Size::new(240.0, 36.0));
assert_eq!(
ring_inset(face, crate::m3::density::GRID as f32),
crate::m3::density::GRID as f32
);
}
#[test]
fn group_skips_the_pane_ring() {
let src = include_str!("focus.rs");
let group = src
.split("pub fn group<")
.nth(1)
.expect("group")
.split("pub fn group_keys")
.next()
.expect("group body");
assert!(group.contains("paint_ring: false"));
let keys = src
.split("pub fn group_keys<")
.nth(1)
.expect("group_keys")
.split("pub fn group_keys_open")
.next()
.expect("group_keys body");
assert!(keys.contains("paint_ring: false"));
let open = src
.split("pub fn group_keys_open<")
.nth(1)
.expect("group_keys_open")
.split("pub fn intercept_keys")
.next()
.expect("group_keys_open body");
assert!(open.contains("paint_ring: false"));
}
#[test]
fn start_ring_hugs_the_mark_in_rtl() {
use iced::advanced::layout::{Layout, Limits};
use iced::advanced::widget::Tree;
use iced::{Font, Pixels, Size};
let tok = crate::theme::named("dark")
.tokens
.with_direction(crate::i18n::Direction::Rtl);
let renderer = iced::Renderer::Secondary(iced_tiny_skia::Renderer::new(
Font::DEFAULT,
Pixels::from(16u32),
));
let limits = Limits::new(Size::ZERO, Size::new(280.0, 40.0));
let mut radio: iced::Element<'_, u8> = crate::widget::radio(
"Flagged",
1u8,
Some(0),
|v| v,
tok,
crate::a11y::A11y::new("Flagged", crate::a11y::Role::Radio),
);
let mut tree = Tree::new(radio.as_widget());
let node = radio.as_widget_mut().layout(&mut tree, &renderer, &limits);
let layout = Layout::new(&node);
let row = layout.bounds();
let face = start_child_bounds(layout, tok.direction).expect("radio mark");
must(
face.width < 48.0,
format!("RTL radio ring must hug the mark, got width {}", face.width),
);
must(
face.x + face.width > row.x + row.width * 0.5,
format!(
"RTL radio mark sits on start (right), mark={} row={}",
face.x, row.x
),
);
let mut box_el: iced::Element<'_, crate::widget::CheckState> = crate::widget::checkbox(
"Accept",
crate::widget::CheckState::Unchecked,
|s| s,
tok,
crate::a11y::A11y::new("Accept", crate::a11y::Role::Checkbox),
);
let mut tree = Tree::new(box_el.as_widget());
let node = box_el.as_widget_mut().layout(&mut tree, &renderer, &limits);
let layout = Layout::new(&node);
let row = layout.bounds();
let face = start_child_bounds(layout, tok.direction).expect("checkbox mark");
must(
face.width < 48.0,
format!(
"RTL checkbox ring must hug the mark, got width {}",
face.width
),
);
must(
face.x + face.width > row.x + row.width * 0.5,
format!(
"RTL checkbox mark sits on start (right), mark={} row={}",
face.x, row.x
),
);
let mut tog: iced::Element<'_, bool> = crate::widget::switch(
"Notify",
false,
|v| v,
tok,
crate::widget::SwitchOpts::FORM,
crate::a11y::A11y::new("Notify", crate::a11y::Role::Switch),
);
let mut tree = Tree::new(tog.as_widget());
let node = tog.as_widget_mut().layout(&mut tree, &renderer, &limits);
let layout = Layout::new(&node);
let row = layout.bounds();
let face = start_child_bounds(layout, tok.direction).expect("switch mark");
must(
face.width < 64.0,
format!(
"RTL switch ring must hug the thumb, got width {}",
face.width
),
);
must(
face.x + face.width > row.x + row.width * 0.5,
format!(
"RTL switch thumb sits on start (right), mark={} row={}",
face.x, row.x
),
);
let ltr = crate::theme::named("dark").tokens;
let mut ltr_radio: iced::Element<'_, u8> = crate::widget::radio(
"Flagged",
1u8,
Some(0),
|v| v,
ltr,
crate::a11y::A11y::new("Flagged", crate::a11y::Role::Radio),
);
let mut tree = Tree::new(ltr_radio.as_widget());
let node = ltr_radio
.as_widget_mut()
.layout(&mut tree, &renderer, &limits);
let layout = Layout::new(&node);
let row = layout.bounds();
let face = start_child_bounds(layout, ltr.direction).expect("ltr radio mark");
must(
face.width < 48.0,
format!("LTR radio ring must hug the mark, got width {}", face.width),
);
must(
face.x < row.x + row.width * 0.5,
format!(
"LTR radio mark sits on start (left), mark={} row={}",
face.x, row.x
),
);
}
#[test]
fn start_ring_draws_on_a_radio_and_open_keys_click() {
let tok = crate::theme::named("dark").tokens;
let mut radio: iced::Element<'_, u8> = crate::widget::radio(
"Flagged",
1u8,
Some(0),
|v| v,
tok,
crate::a11y::A11y::new("Flagged", crate::a11y::Role::Radio),
);
assert!(pump_click(&mut radio, true));
let blank: iced::Element<'_, ()> = iced::widget::Row::new()
.push(iced::widget::Space::new().width(12).height(12))
.into();
let mut start = target_keys_start(blank, tok, true, |_| None);
assert!(pump_click(&mut start, true));
let body = crate::widget::label(
"go",
crate::widget::LabelFace::Body,
tok,
crate::a11y::A11y::new("go", crate::a11y::Role::Button),
);
let mut open = target_keys_open(body, tok, true, |_| None);
assert!(pump_click(&mut open, true));
use iced::advanced::layout::{Layout, Limits};
use iced::advanced::widget::Tree;
use iced::keyboard;
use iced::{Event, Font, Pixels, Point, Rectangle, Size};
let mut tree = Tree::new(open.as_widget());
let renderer = iced::Renderer::Secondary(iced_tiny_skia::Renderer::new(
Font::DEFAULT,
Pixels::from(16u32),
));
let limits = Limits::new(Size::ZERO, Size::new(200.0, 80.0));
let node = open.as_widget_mut().layout(&mut tree, &renderer, &limits);
let layout = Layout::new(&node);
let mut messages = Vec::<()>::new();
{
let mut shell = iced::advanced::Shell::new(&mut messages);
let mut clipboard = iced::advanced::clipboard::Null;
open.as_widget_mut().update(
&mut tree,
&Event::Keyboard(keyboard::Event::KeyPressed {
key: keyboard::Key::Named(keyboard::key::Named::Enter),
modified_key: keyboard::Key::Named(keyboard::key::Named::Enter),
physical_key: keyboard::key::Physical::Code(keyboard::key::Code::Enter),
location: keyboard::Location::Standard,
modifiers: keyboard::Modifiers::empty(),
text: None,
repeat: false,
}),
layout,
iced::mouse::Cursor::Unavailable,
&renderer,
&mut clipboard,
&mut shell,
&Rectangle::new(Point::ORIGIN, Size::new(200.0, 80.0)),
);
open.as_widget().draw(
&tree,
&mut iced::Renderer::Secondary(iced_tiny_skia::Renderer::new(
Font::DEFAULT,
Pixels::from(16u32),
)),
&iced::Theme::Dark,
&iced::advanced::renderer::Style::default(),
layout,
iced::mouse::Cursor::Unavailable,
&Rectangle::new(Point::new(800.0, 800.0), Size::new(10.0, 10.0)),
);
}
}
#[test]
fn target_click_focuses_when_enabled() {
let tok = crate::theme::named("dark").tokens;
let body = crate::widget::label(
"rows",
crate::widget::LabelFace::Body,
tok,
crate::a11y::A11y::new("rows", crate::a11y::Role::List),
);
let mut el: iced::Element<'_, ()> = target(body, tok, true);
assert!(pump_click(&mut el, true));
use iced::advanced::layout::{Layout, Limits};
use iced::advanced::widget::Tree;
use iced::{Font, Pixels, Size};
let mut tree = Tree::new(el.as_widget());
let renderer = iced::Renderer::Secondary(iced_tiny_skia::Renderer::new(
Font::DEFAULT,
Pixels::from(16u32),
));
let node = el.as_widget_mut().layout(
&mut tree,
&renderer,
&Limits::new(Size::ZERO, Size::new(200.0, 80.0)),
);
let layout = Layout::new(&node);
let _ = el.as_widget().mouse_interaction(
&tree,
layout,
iced::mouse::Cursor::Unavailable,
&iced::Rectangle::new(iced::Point::ORIGIN, Size::new(200.0, 80.0)),
&renderer,
);
let _ = el.as_widget_mut().overlay(
&mut tree,
layout,
&renderer,
&iced::Rectangle::new(iced::Point::ORIGIN, Size::new(200.0, 80.0)),
iced::Vector::ZERO,
);
use iced::advanced::renderer::Style;
use iced::Theme;
let mut renderer = iced::Renderer::Secondary(iced_tiny_skia::Renderer::new(
Font::DEFAULT,
Pixels::from(16u32),
));
el.as_widget().draw(
&tree,
&mut renderer,
&Theme::Dark,
&Style::default(),
layout,
iced::mouse::Cursor::Unavailable,
&iced::Rectangle::new(iced::Point::ORIGIN, Size::new(200.0, 80.0)),
);
}
#[test]
fn target_click_skips_when_cannot_focus() {
let tok = crate::theme::named("dark").tokens;
let body = crate::widget::label(
"rows",
crate::widget::LabelFace::Body,
tok,
crate::a11y::A11y::new("rows", crate::a11y::Role::List),
);
let mut el: iced::Element<'_, ()> = target(body, tok, false);
assert!(!pump_click(&mut el, false));
}
fn two_targets() -> iced::Element<'static, ()> {
let tok = crate::theme::named("dark").tokens;
let a = target(
crate::widget::label(
"a",
crate::widget::LabelFace::Body,
tok,
crate::a11y::A11y::new("a", crate::a11y::Role::List),
),
tok,
true,
);
let b = target(
crate::widget::label(
"b",
crate::widget::LabelFace::Body,
tok,
crate::a11y::A11y::new("b", crate::a11y::Role::List),
),
tok,
true,
);
iced::widget::column![a, b].into()
}
fn focused_indices(el: &mut iced::Element<'_, ()>, tab_shift: Option<bool>) -> Vec<usize> {
use iced::advanced::layout::{Layout, Limits};
use iced::advanced::widget::operation::{focusable::Focusable, Operation};
use iced::advanced::widget::Tree;
use iced::{Event, Font, Pixels, Point, Rectangle, Size};
let mut tree = Tree::new(el.as_widget());
let renderer = iced::Renderer::Secondary(iced_tiny_skia::Renderer::new(
Font::DEFAULT,
Pixels::from(16u32),
));
let limits = Limits::new(Size::ZERO, Size::new(200.0, 160.0));
let node = el.as_widget_mut().layout(&mut tree, &renderer, &limits);
let layout = Layout::new(&node);
let viewport = Rectangle::new(Point::ORIGIN, Size::new(200.0, 160.0));
let mut messages = Vec::<()>::new();
{
let mut shell = iced::advanced::Shell::new(&mut messages);
let mut clipboard = iced::advanced::clipboard::Null;
el.as_widget_mut().update(
&mut tree,
&Event::Mouse(iced::mouse::Event::CursorMoved {
position: Point::new(1.0, 1.0),
}),
layout,
iced::mouse::Cursor::Unavailable,
&renderer,
&mut clipboard,
&mut shell,
&viewport,
);
}
if let Some(shift) = tab_shift {
let mut shell = iced::advanced::Shell::new(&mut messages);
let mut clipboard = iced::advanced::clipboard::Null;
el.as_widget_mut().update(
&mut tree,
&Event::Keyboard(iced::keyboard::Event::KeyPressed {
key: iced::keyboard::Key::Named(iced::keyboard::key::Named::Tab),
modified_key: iced::keyboard::Key::Named(iced::keyboard::key::Named::Tab),
physical_key: iced::keyboard::key::Physical::Unidentified(
iced::keyboard::key::NativeCode::Unidentified,
),
location: iced::keyboard::Location::Standard,
modifiers: if shift {
iced::keyboard::Modifiers::SHIFT
} else {
iced::keyboard::Modifiers::empty()
},
text: None,
repeat: false,
}),
layout,
iced::mouse::Cursor::Unavailable,
&renderer,
&mut clipboard,
&mut shell,
&viewport,
);
}
struct Hit {
i: usize,
hits: Vec<usize>,
}
impl Operation<()> for Hit {
fn focusable(
&mut self,
_id: Option<&iced::widget::Id>,
_bounds: Rectangle,
state: &mut dyn Focusable,
) {
if state.is_focused() {
self.hits.push(self.i);
}
self.i += 1;
}
fn traverse(&mut self, operate: &mut dyn FnMut(&mut dyn Operation<()>)) {
operate(self);
}
}
let mut op = Hit {
i: 0,
hits: Vec::new(),
};
el.as_widget_mut()
.operate(&mut tree, layout, &renderer, &mut op);
op.hits
}
#[test]
fn cycle_focuses_first_target_on_mount() {
let mut el = cycle(two_targets(), None);
assert_eq!(focused_indices(&mut el, None), vec![0]);
}
#[test]
fn cycle_tab_walks_targets() {
let mut el = cycle(two_targets(), None);
assert_eq!(focused_indices(&mut el, Some(false)), vec![1]);
let mut el = cycle(two_targets(), None);
assert_eq!(focused_indices(&mut el, Some(true)), vec![1]);
}
#[test]
fn cycle_empty_and_named_and_overlay() {
use iced::advanced::layout::{Layout, Limits};
use iced::advanced::widget::Tree;
use iced::{Font, Pixels, Size};
let tok = crate::theme::named("dark").tokens;
let empty = crate::widget::label(
"x",
crate::widget::LabelFace::Body,
tok,
crate::a11y::A11y::new("x", crate::a11y::Role::Status),
);
let mut el = cycle(empty, None);
assert!(focused_indices(&mut el, Some(false)).is_empty());
let id = iced::widget::Id::new("name");
let field = crate::widget::text_input(
"Name",
"Ada",
|_| (),
None,
crate::widget::FieldOpts::NONE,
tok,
crate::a11y::A11y::new("Name", crate::a11y::Role::TextBox),
Some(id.clone()),
);
let mut named = cycle(field, Some(id));
let _ = focused_indices(&mut named, None);
let mut tree = Tree::new(named.as_widget());
let renderer = iced::Renderer::Secondary(iced_tiny_skia::Renderer::new(
Font::DEFAULT,
Pixels::from(16u32),
));
let node = named.as_widget_mut().layout(
&mut tree,
&renderer,
&Limits::new(Size::ZERO, Size::new(200.0, 80.0)),
);
let layout = Layout::new(&node);
let _ = named.as_widget().mouse_interaction(
&tree,
layout,
iced::mouse::Cursor::Unavailable,
&iced::Rectangle::new(iced::Point::ORIGIN, Size::new(200.0, 80.0)),
&renderer,
);
let _ = named.as_widget_mut().overlay(
&mut tree,
layout,
&renderer,
&iced::Rectangle::new(iced::Point::ORIGIN, Size::new(200.0, 80.0)),
iced::Vector::ZERO,
);
named.as_widget_mut().diff(&mut tree);
let _ = focused_indices(&mut named, Some(false));
let mut esc = crate::focus::dismiss_on_escape(
crate::widget::label(
"x",
crate::widget::LabelFace::Body,
tok,
crate::a11y::A11y::new("x", crate::a11y::Role::Status),
),
(),
);
let mut et = Tree::new(esc.as_widget());
let enode = esc.as_widget_mut().layout(
&mut et,
&renderer,
&Limits::new(Size::ZERO, Size::new(200.0, 40.0)),
);
let elayout = Layout::new(&enode);
let _ = esc.as_widget_mut().overlay(
&mut et,
elayout,
&renderer,
&iced::Rectangle::new(iced::Point::ORIGIN, Size::new(200.0, 40.0)),
iced::Vector::ZERO,
);
let _ = esc.as_widget().mouse_interaction(
&et,
elayout,
iced::mouse::Cursor::Unavailable,
&iced::Rectangle::new(iced::Point::ORIGIN, Size::new(200.0, 40.0)),
&renderer,
);
struct Nop;
impl iced::advanced::widget::Operation<()> for Nop {
fn traverse(
&mut self,
operate: &mut dyn FnMut(&mut dyn iced::advanced::widget::Operation<()>),
) {
operate(self);
}
}
esc.as_widget_mut()
.operate(&mut et, elayout, &renderer, &mut Nop);
esc.as_widget_mut().diff(&mut et);
let nested = crate::focus::dismiss_on_escape(esc, ());
let mut nest = cycle(nested, None);
let _ = focused_indices(&mut nest, None);
let mut nt = Tree::new(nest.as_widget());
let nn = nest.as_widget_mut().layout(
&mut nt,
&renderer,
&Limits::new(Size::ZERO, Size::new(200.0, 40.0)),
);
let nl = Layout::new(&nn);
let mut messages = Vec::<()>::new();
{
let mut shell = iced::advanced::Shell::new(&mut messages);
let mut clipboard = iced::advanced::clipboard::Null;
nest.as_widget_mut().update(
&mut nt,
&iced::Event::Keyboard(iced::keyboard::Event::KeyPressed {
key: iced::keyboard::Key::Named(iced::keyboard::key::Named::Escape),
modified_key: iced::keyboard::Key::Named(iced::keyboard::key::Named::Escape),
physical_key: iced::keyboard::key::Physical::Unidentified(
iced::keyboard::key::NativeCode::Unidentified,
),
location: iced::keyboard::Location::Standard,
modifiers: iced::keyboard::Modifiers::empty(),
text: None,
repeat: false,
}),
nl,
iced::mouse::Cursor::Unavailable,
&renderer,
&mut clipboard,
&mut shell,
&iced::Rectangle::new(iced::Point::ORIGIN, Size::new(200.0, 40.0)),
);
}
{
let mut shell = iced::advanced::Shell::new(&mut messages);
let mut clipboard = iced::advanced::clipboard::Null;
nest.as_widget_mut().update(
&mut nt,
&iced::Event::Keyboard(iced::keyboard::Event::KeyPressed {
key: iced::keyboard::Key::Named(iced::keyboard::key::Named::Tab),
modified_key: iced::keyboard::Key::Named(iced::keyboard::key::Named::Tab),
physical_key: iced::keyboard::key::Physical::Unidentified(
iced::keyboard::key::NativeCode::Unidentified,
),
location: iced::keyboard::Location::Standard,
modifiers: iced::keyboard::Modifiers::empty(),
text: None,
repeat: false,
}),
nl,
iced::mouse::Cursor::Unavailable,
&renderer,
&mut clipboard,
&mut shell,
&iced::Rectangle::new(iced::Point::ORIGIN, Size::new(200.0, 40.0)),
);
}
let mut keyed = cycle(two_targets(), None);
let _ = focused_indices(&mut keyed, None);
let mut tree = Tree::new(keyed.as_widget());
let node = keyed.as_widget_mut().layout(
&mut tree,
&renderer,
&Limits::new(Size::ZERO, Size::new(200.0, 160.0)),
);
let layout = Layout::new(&node);
let mut messages = Vec::<()>::new();
for (key, mods) in [
(
iced::keyboard::Key::Named(iced::keyboard::key::Named::Enter),
iced::keyboard::Modifiers::empty(),
),
(
iced::keyboard::Key::Named(iced::keyboard::key::Named::Tab),
iced::keyboard::Modifiers::CTRL,
),
] {
let mut shell = iced::advanced::Shell::new(&mut messages);
let mut clipboard = iced::advanced::clipboard::Null;
keyed.as_widget_mut().update(
&mut tree,
&iced::Event::Keyboard(iced::keyboard::Event::KeyPressed {
key: key.clone(),
modified_key: key,
physical_key: iced::keyboard::key::Physical::Unidentified(
iced::keyboard::key::NativeCode::Unidentified,
),
location: iced::keyboard::Location::Standard,
modifiers: mods,
text: None,
repeat: false,
}),
layout,
iced::mouse::Cursor::Unavailable,
&renderer,
&mut clipboard,
&mut shell,
&iced::Rectangle::new(iced::Point::ORIGIN, Size::new(200.0, 160.0)),
);
}
}
#[test]
fn intercept_keys_focuses_without_a_ring() {
let tok = crate::theme::named("dark").tokens;
let body = crate::widget::label(
"hits",
crate::widget::LabelFace::Body,
tok,
crate::a11y::A11y::new("hits", crate::a11y::Role::List),
);
let mut el: iced::Element<'_, ()> = intercept_keys(body, tok, true, |_| None);
assert!(pump_click(&mut el, true));
}
}