Sliders: keep the parent material clear beneath the track (#10375)
This commit is contained in:
1 parent
bec762fb2b
commit
9060abc83e
2 files changed
+352
-43
No files matched your search
@@ -1247,7 +1247,7 @@ impl Default for Slider {
|
||||
|
||||
/// The only slider element, including stepped preferences and editor-free timeline controls.
|
||||
/// Native input, keyboard routing, enabled state and accessibility; one token-painted track/thumb.
|
||||
/// Tokens: control_height, space_24/8/4/2, dialog_body/rule, control_fill, form_primary.
|
||||
/// Tokens: control_height, space_24/8/4/2, dialog_rule, control_fill, form_primary.
|
||||
pub(crate) fn slider<T: egui::emath::Numeric>(ui: &mut Ui, value: &mut T, range: std::ops::RangeInclusive<T>, options: Slider) -> Response {
|
||||
if crate::prefs_search::suppress_chrome(ui) {
|
||||
return crate::prefs_search::hidden_response(ui);
|
||||
@@ -1272,7 +1272,8 @@ pub(crate) fn slider<T: egui::emath::Numeric>(ui: &mut Ui, value: &mut T, range:
|
||||
t.space_4
|
||||
};
|
||||
ui.spacing_mut().slider_width = dimension(ui.available_width() - reserved);
|
||||
let mut widget = egui::Slider::new(value, range).show_value(options.show_value).handle_shape(egui::style::HandleShape::Circle);
|
||||
let mut widget =
|
||||
egui::Slider::new(value, range).show_value(options.show_value).handle_shape(egui::style::HandleShape::Circle).trailing_fill(false);
|
||||
if options.off_endpoint {
|
||||
// Blur's step is an editing affordance, not a persisted/API quantisation rule.
|
||||
widget = widget.clamping(egui::SliderClamping::Edits);
|
||||
@@ -1286,20 +1287,59 @@ pub(crate) fn slider<T: egui::emath::Numeric>(ui: &mut Ui, value: &mut T, range:
|
||||
if options.integer {
|
||||
widget = widget.integer();
|
||||
}
|
||||
let layer = ui.layer_id();
|
||||
let paint_start = ui.ctx().graphics(|graphics| graphics.get(layer).map_or(egui::layers::ShapeIdx(0), |list| list.next_idx()));
|
||||
let response = ui.add(widget);
|
||||
let slider = egui::Rect::from_min_size(response.rect.min, vec2(ui.spacing().slider_width, response.rect.height()));
|
||||
// egui 0.36.2 paints the rail, then the circular handle, then the value editor.
|
||||
// Suppress only a positively identified pair added by this widget. A backing
|
||||
// rectangle would flatten translucent/blurred parents. Unexpected painting
|
||||
// (including an invisible or clipped widget) keeps the native shapes intact.
|
||||
ui.ctx().graphics_mut(|graphics| {
|
||||
let Some(list) = graphics.get_mut(layer) else { return };
|
||||
let paint_end = list.next_idx();
|
||||
if paint_end.0.saturating_sub(paint_start.0) < 2 {
|
||||
return;
|
||||
}
|
||||
let handle_idx = egui::layers::ShapeIdx(paint_start.0 + 1);
|
||||
let rail_height = ui.spacing().slider_rail_height.max(0.0);
|
||||
let native_radius = slider.height() / 2.5;
|
||||
let native_range = slider.x_range().shrink(native_radius);
|
||||
let mut rail_matches = false;
|
||||
let mut handle_matches = false;
|
||||
// Indexed reads via mutate_shape are bounded and allocate nothing; do not
|
||||
// scan the layer's earlier parent/sibling paints looking for a match.
|
||||
list.mutate_shape(paint_start, |entry| {
|
||||
if let egui::Shape::Rect(rail) = &entry.shape {
|
||||
let expected = egui::Rect::from_center_size(slider.center(), vec2(slider.width(), rail_height));
|
||||
rail_matches = entry.clip_rect == ui.clip_rect()
|
||||
&& (rail.rect.min - expected.min).length_sq() < 0.0001
|
||||
&& (rail.rect.max - expected.max).length_sq() < 0.0001
|
||||
&& rail.stroke == egui::Stroke::NONE;
|
||||
}
|
||||
});
|
||||
list.mutate_shape(handle_idx, |entry| {
|
||||
if let egui::Shape::Circle(handle) = &entry.shape {
|
||||
handle_matches = entry.clip_rect == ui.clip_rect()
|
||||
&& (handle.center.y - slider.center().y).abs() < 0.01
|
||||
// egui's handle range reverses when the control is narrower
|
||||
// than its diameter; either endpoint still belongs to it.
|
||||
&& handle.center.x >= native_range.min.min(native_range.max) - 0.01
|
||||
&& handle.center.x <= native_range.min.max(native_range.max) + 0.01
|
||||
&& (handle.radius - native_radius).abs() < 0.01;
|
||||
}
|
||||
});
|
||||
if rail_matches && handle_matches {
|
||||
list.mutate_shape(paint_start, |entry| entry.shape = egui::Shape::Noop);
|
||||
list.mutate_shape(handle_idx, |entry| entry.shape = egui::Shape::Noop);
|
||||
}
|
||||
});
|
||||
if ui.ctx().memory(|memory| memory.focused()).is_some_and(|id| {
|
||||
ui.ctx().read_response(id).is_some_and(|focused| response.rect.contains(focused.rect.center()))
|
||||
|| egui::TextEdit::load_state(ui.ctx(), id).is_some()
|
||||
}) {
|
||||
crate::prefs_search::note_key_sink(ui.ctx());
|
||||
}
|
||||
let slider = egui::Rect::from_min_size(response.rect.min, vec2(ui.spacing().slider_width, response.rect.height()));
|
||||
let mut background = ui.painter().clone();
|
||||
background.set_opacity(if ui.is_visible() { 1.0 } else { 0.0 });
|
||||
// At the top of the range egui's own handle reaches `slider.right()` exactly, and a fill
|
||||
// that stops there leaves its last column showing beside the editor (#5708). The gap
|
||||
// before the editor is `item_spacing.x`, so a pixel past the edge covers nothing else.
|
||||
background.rect_filled(slider.with_max_x(slider.right() + 1.0), 0.0, t.dialog_body);
|
||||
// Match egui's native input range (handle_radius = thickness / 2.5), so the
|
||||
// painted thumb stays under the pointer even at the two ends of the range.
|
||||
let input_radius = ui.text_style_height(&egui::TextStyle::Body).max(ui.spacing().interact_size.y) / 2.5;
|
||||
|
||||
@@ -112,7 +112,7 @@ fn blur_meter_boundaries_and_off_thumb() {
|
||||
}
|
||||
for dark in [false, true] {
|
||||
crate::theme::set_dark(dark);
|
||||
for radius in [0.0, 18.25] {
|
||||
for radius in [0.0, 18.25, 40.0] {
|
||||
let ctx = crate::fonts::test_context();
|
||||
let t = Tokens::get();
|
||||
let mut value = radius;
|
||||
@@ -122,6 +122,13 @@ fn blur_meter_boundaries_and_off_thumb() {
|
||||
});
|
||||
});
|
||||
assert_eq!(value, radius, "drawing cannot round persisted fractional values");
|
||||
assert_eq!(out.shapes.iter().filter(|s| matches!(s.shape, egui::Shape::Circle(_))).count(), 1, "off/solid thumb has no native duplicate");
|
||||
let hit = scenario::rect_of("dialog:slider_track:").expect("blur slider track");
|
||||
assert_eq!(
|
||||
out.shapes.iter().filter(|s| matches!(&s.shape, egui::Shape::Rect(r) if r.rect.left() < hit.right())).count(),
|
||||
2,
|
||||
"off/solid track has no native rail or backing rectangle"
|
||||
);
|
||||
let thumb = out
|
||||
.shapes
|
||||
.iter()
|
||||
@@ -291,41 +298,303 @@ fn a_sliders_value_box_takes_typed_numbers_and_clamps_them_to_its_range() {
|
||||
}
|
||||
}
|
||||
|
||||
/// At the top of its range egui's own handle reaches the right edge of the rectangle the kit
|
||||
/// paints over it, so the mask has to pass that edge; flush with it, the handle's last column
|
||||
/// survives as a light sliver beside the value box (#5708).
|
||||
/// At either endpoint there must be just the token thumb and track: a native handle's
|
||||
/// last column used to survive beside the value box at the maximum (#5708).
|
||||
#[test]
|
||||
fn the_mask_passes_the_edge_of_egui_s_own_handle_at_the_top_of_the_range() {
|
||||
let ctx = crate::fonts::test_context();
|
||||
let t = Tokens::get();
|
||||
let mut value: f64 = 2.0;
|
||||
let mut output =
|
||||
ctx.run_ui(egui::RawInput { screen_rect: Some(Rect::from_min_size(egui::Pos2::ZERO, vec2(400.0, 200.0))), ..Default::default() }, |ui| {
|
||||
scope(ui, |ui| {
|
||||
slider(ui, &mut value, 0.0..=2.0, Slider { step: Some(0.05), ..Default::default() });
|
||||
});
|
||||
});
|
||||
output.textures_delta.clear();
|
||||
let handle = output
|
||||
.shapes
|
||||
fn slider_endpoints_have_no_duplicate_native_handle_or_rail_and_keep_the_editor() {
|
||||
let previous = crate::theme::is_dark();
|
||||
for dark in [false, true] {
|
||||
crate::theme::set_dark(dark);
|
||||
for show_value in [false, true] {
|
||||
for endpoint in [0.0, 2.0] {
|
||||
let ctx = crate::fonts::test_context();
|
||||
let mut value = endpoint;
|
||||
let output = slider_test_frame(&ctx, vec![], |ui| {
|
||||
slider(ui, &mut value, 0.0..=2.0, Slider { step: Some(0.05), show_value, ..Default::default() });
|
||||
});
|
||||
let hit = scenario::rect_of("dialog:slider_track:").expect("slider track");
|
||||
assert_slider_paint(&output.shapes, hit, Tokens::get(), endpoint, show_value, 1.0);
|
||||
assert_eq!(value, endpoint);
|
||||
}
|
||||
}
|
||||
}
|
||||
crate::theme::set_dark(previous);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn narrow_sliders_do_not_retain_native_chrome_when_the_handle_range_reverses() {
|
||||
let previous = crate::theme::is_dark();
|
||||
for dark in [false, true] {
|
||||
crate::theme::set_dark(dark);
|
||||
for width in [24.0, 28.0] {
|
||||
for saved in [0.0, 0.73123456789, 2.0] {
|
||||
let ctx = crate::fonts::test_context();
|
||||
let mut value = saved;
|
||||
let output = slider_test_frame(&ctx, vec![], |ui| {
|
||||
ui.set_width(width);
|
||||
slider(ui, &mut value, 0.0..=2.0, Slider { show_value: false, ..Default::default() });
|
||||
});
|
||||
let hit = scenario::rect_of("dialog:slider_track:").expect("narrow slider track");
|
||||
assert!(hit.width() < 28.0, "the fixture must constrain the native track");
|
||||
assert_slider_paint(&output.shapes, hit, Tokens::get(), saved, false, 1.0);
|
||||
assert_eq!(value, saved);
|
||||
}
|
||||
}
|
||||
}
|
||||
crate::theme::set_dark(previous);
|
||||
}
|
||||
|
||||
fn slider_test_frame(ctx: &egui::Context, events: Vec<egui::Event>, mut add: impl FnMut(&mut Ui)) -> egui::FullOutput {
|
||||
scenario::clear_handles();
|
||||
crate::test_support::frame(
|
||||
ctx,
|
||||
egui::RawInput { screen_rect: Some(Rect::from_min_size(egui::Pos2::ZERO, vec2(400.0, 200.0))), events, focused: true, ..Default::default() },
|
||||
|ui| {
|
||||
ui.set_width(280.0);
|
||||
scope(ui, &mut add);
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
/// Assert observable paint geometry, including absence of a surface-coloured backing.
|
||||
/// `shapes` is only the slider's paint span; parent/sibling paints are checked separately.
|
||||
fn assert_slider_paint(shapes: &[egui::epaint::ClippedShape], hit: Rect, t: Tokens, value: f64, show_value: bool, opacity: f32) {
|
||||
let track = Rect::from_center_size(hit.center(), vec2((hit.width() - 2.0 * hit.height() / 2.5).max(0.0), t.space_4));
|
||||
let center = pos2(egui::lerp(track.x_range(), (value / 2.0) as f32), track.center().y);
|
||||
let circles: Vec<_> = shapes.iter().filter_map(|s| if let egui::Shape::Circle(c) = &s.shape { Some(c) } else { None }).collect();
|
||||
assert_eq!(circles.len(), 1, "no duplicate native handle, even at the very edge");
|
||||
let thumb = circles[0];
|
||||
assert_eq!(thumb.center, center, "the custom thumb reaches the native input endpoints");
|
||||
assert_eq!(thumb.radius, t.space_8);
|
||||
assert_eq!(thumb.fill, t.control_fill.gamma_multiply(opacity));
|
||||
assert_eq!(thumb.stroke, egui::Stroke::new(t.space_2, t.form_primary.gamma_multiply(opacity)));
|
||||
let rails: Vec<_> = shapes
|
||||
.iter()
|
||||
.find_map(|s| match &s.shape {
|
||||
egui::Shape::Circle(c) if c.stroke.color != t.form_primary => Some(*c),
|
||||
.filter_map(|s| match &s.shape {
|
||||
egui::Shape::Rect(r) if r.rect.left() < hit.right() => Some(r),
|
||||
_ => None,
|
||||
})
|
||||
.expect("egui's own slider handle");
|
||||
let mask = output
|
||||
.shapes
|
||||
.iter()
|
||||
.find_map(|s| match &s.shape {
|
||||
egui::Shape::Rect(r) if r.fill == t.dialog_body => Some(r.rect),
|
||||
_ => None,
|
||||
})
|
||||
.expect("the rectangle the kit paints over egui's slider");
|
||||
assert!(
|
||||
mask.right() > handle.center.x + handle.radius,
|
||||
"the mask ends at {} and egui's handle at {}: its last column would show",
|
||||
mask.right(),
|
||||
handle.center.x + handle.radius
|
||||
);
|
||||
.collect();
|
||||
assert_eq!(rails.len(), 2, "only the token track and filled portion; no native rail or backing rectangle");
|
||||
assert_eq!(rails[0].rect, track);
|
||||
assert_eq!(rails[0].fill, t.dialog_rule.gamma_multiply(opacity));
|
||||
assert_eq!(rails[1].rect, Rect::from_min_max(track.min, pos2(center.x, track.bottom())));
|
||||
assert_eq!(rails[1].fill, t.form_primary.gamma_multiply(opacity));
|
||||
let editor: Vec<_> = shapes.iter().filter_map(|s| if let egui::Shape::Text(text) = &s.shape { Some(text) } else { None }).collect();
|
||||
if show_value {
|
||||
assert!(
|
||||
editor.iter().any(|text| text.galley.text() == format!("{value:.2}")),
|
||||
"the native value editor must remain painted: {:?}",
|
||||
editor.iter().map(|text| text.galley.text()).collect::<Vec<_>>()
|
||||
);
|
||||
assert!(editor.iter().all(|text| text.pos.x > hit.right()), "the editor must remain beside the track");
|
||||
assert!(shapes.iter().any(|s| matches!(&s.shape, egui::Shape::Rect(r) if r.rect.left() > hit.right())), "native editor chrome survives");
|
||||
} else {
|
||||
assert!(editor.is_empty(), "show_value(false) still hides the editor");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn slider_preserves_translucent_parent_paints_and_inherited_opacity_without_a_backing_rectangle() {
|
||||
let previous = crate::theme::is_dark();
|
||||
for dark in [false, true] {
|
||||
crate::theme::set_dark(dark);
|
||||
for translucent in [false, true] {
|
||||
let mut t = Tokens::get();
|
||||
if translucent {
|
||||
t.apply_panel_opacity(40.0);
|
||||
assert!(t.dialog_body.a() < 255);
|
||||
}
|
||||
let _tokens = crate::theme::scoped_tokens(t);
|
||||
for opacity in [1.0, 0.45] {
|
||||
for show_value in [false, true] {
|
||||
for saved in [0.0, 0.73123456789, 2.0] {
|
||||
let ctx = crate::fonts::test_context();
|
||||
let mut value = saved;
|
||||
slider_test_frame(&ctx, vec![], |ui| {
|
||||
slider(ui, &mut value, 0.0..=2.0, Slider { show_value, ..Default::default() });
|
||||
});
|
||||
let hit = scenario::rect_of("dialog:slider_track:").expect("slider track");
|
||||
slider_test_frame(&ctx, vec![], |ui| {
|
||||
ui.multiply_opacity(opacity);
|
||||
// A synthetic parent callback stands in for background effects;
|
||||
// this test observes paint retention, without invoking a GPU.
|
||||
ui.painter().add(egui::Shape::Vec(vec![
|
||||
egui::Shape::rect_filled(hit.expand(12.0), t.control_radius, t.dialog_body),
|
||||
egui::Shape::Callback(egui::PaintCallback { rect: hit, callback: std::sync::Arc::new(()) }),
|
||||
]));
|
||||
// Earlier sibling paints deliberately have the native signature.
|
||||
ui.painter().rect_filled(
|
||||
Rect::from_center_size(hit.center(), vec2(hit.width(), ui.spacing().slider_rail_height)),
|
||||
t.control_radius,
|
||||
t.control_fill,
|
||||
);
|
||||
ui.painter().circle_filled(hit.center(), hit.height() / 2.5, t.control_fill);
|
||||
let layer = ui.layer_id();
|
||||
let parent = ui.ctx().graphics(|g| g.get(layer).expect("parent paints").all_entries().cloned().collect::<Vec<_>>());
|
||||
slider(ui, &mut value, 0.0..=2.0, Slider { show_value, ..Default::default() });
|
||||
assert_eq!(ui.opacity(), opacity, "slider must retain the parent's painter opacity");
|
||||
ui.ctx().graphics(|g| {
|
||||
let shapes: Vec<_> = g.get(layer).expect("slider paints").all_entries().cloned().collect();
|
||||
assert_eq!(&shapes[..parent.len()], &parent, "parent callback/fill and earlier siblings must survive unchanged");
|
||||
assert_slider_paint(&shapes[parent.len()..], hit, t, saved, show_value, opacity);
|
||||
});
|
||||
ui.painter().circle_filled(hit.right_center(), t.space_2, t.form_dim);
|
||||
assert_eq!(ui.opacity(), opacity, "following siblings inherit the same opacity");
|
||||
});
|
||||
assert_eq!(value, saved, "painting preserves fractional saved values");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
crate::theme::set_dark(previous);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clipping_out_the_native_track_preserves_the_editor_when_the_paint_signature_differs() {
|
||||
let previous = crate::theme::is_dark();
|
||||
for dark in [false, true] {
|
||||
crate::theme::set_dark(dark);
|
||||
let ctx = crate::fonts::test_context();
|
||||
let mut value = 1.0;
|
||||
slider_test_frame(&ctx, vec![], |ui| {
|
||||
slider(ui, &mut value, 0.0..=2.0, Default::default());
|
||||
});
|
||||
let hit = scenario::rect_of("dialog:slider_track:").expect("slider track");
|
||||
let output = slider_test_frame(&ctx, vec![], |ui| {
|
||||
// egui omits its rail/handle when only the editor intersects the clip.
|
||||
// The first native shapes are now editor paints and must survive.
|
||||
ui.set_clip_rect(ui.clip_rect().with_min_x(hit.right() + 1.0));
|
||||
slider(ui, &mut value, 0.0..=2.0, Default::default());
|
||||
});
|
||||
assert!(output.shapes.iter().any(|s| matches!(&s.shape, egui::Shape::Rect(r) if r.rect.left() > hit.right())));
|
||||
assert!(output.shapes.iter().any(|s| matches!(&s.shape, egui::Shape::Text(text) if text.galley.text() == "1.00")));
|
||||
assert_eq!(output.shapes.iter().filter(|s| matches!(s.shape, egui::Shape::Circle(_))).count(), 1, "only the clipped custom thumb is added");
|
||||
assert_eq!(value, 1.0);
|
||||
}
|
||||
crate::theme::set_dark(previous);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn slider_keyboard_focus_and_accessibility_keep_native_steps_and_editor_focus() {
|
||||
let previous = crate::theme::is_dark();
|
||||
for dark in [false, true] {
|
||||
crate::theme::set_dark(dark);
|
||||
for translucent in [false, true] {
|
||||
let mut t = Tokens::get();
|
||||
if translucent {
|
||||
t.apply_panel_opacity(40.0);
|
||||
}
|
||||
let _tokens = crate::theme::scoped_tokens(t);
|
||||
for show_value in [false, true] {
|
||||
let ctx = crate::fonts::test_context();
|
||||
ctx.enable_accesskit();
|
||||
let value = std::cell::Cell::new(1.0_f64);
|
||||
let draw = |events| {
|
||||
slider_test_frame(&ctx, events, |ui| {
|
||||
let mut next = value.get();
|
||||
slider(ui, &mut next, 0.0..=2.0, Slider { step: Some(0.05), show_value, ..Default::default() });
|
||||
value.set(next);
|
||||
})
|
||||
};
|
||||
draw(vec![]);
|
||||
let idle = draw(vec![]);
|
||||
let tree = idle.platform_output.accesskit_update.as_ref().expect("native accessibility tree");
|
||||
let nodes: Vec<_> = tree.nodes.iter().filter(|(_, n)| n.role() == egui::accesskit::Role::Slider).collect();
|
||||
assert_eq!(nodes.len(), 1);
|
||||
let node = &nodes[0].1;
|
||||
assert_eq!(node.numeric_value(), Some(1.0));
|
||||
assert_eq!(node.min_numeric_value(), Some(0.0));
|
||||
assert_eq!(node.max_numeric_value(), Some(2.0));
|
||||
assert_eq!(node.numeric_value_step(), Some(0.05));
|
||||
assert!(!node.is_disabled());
|
||||
draw(test_support::key(egui::Key::Tab));
|
||||
draw(vec![]);
|
||||
let focus = ctx.memory(|m| m.focused()).expect("Tab focuses the slider");
|
||||
let focused = ctx.read_response(focus).expect("focused slider response");
|
||||
assert!(focused.has_focus());
|
||||
let hit = scenario::rect_of("dialog:slider_track:").expect("slider track");
|
||||
assert!(hit.contains(focused.rect.center()));
|
||||
let changed = draw(test_support::key(egui::Key::ArrowRight));
|
||||
assert!((value.get() - 1.05).abs() < 1e-8);
|
||||
assert_eq!(ctx.memory(|m| m.focused()), Some(focus));
|
||||
assert_slider_paint(&changed.shapes, hit, Tokens::get(), value.get(), show_value, 1.0);
|
||||
draw(test_support::key(egui::Key::ArrowLeft));
|
||||
assert!((value.get() - 1.0).abs() < 1e-8);
|
||||
if show_value {
|
||||
draw(test_support::key(egui::Key::Tab));
|
||||
let editing = draw(vec![]);
|
||||
let editor_id = ctx.memory(|m| m.focused()).expect("Tab reaches the native editor");
|
||||
assert_ne!(editor_id, focus);
|
||||
assert!(egui::TextEdit::load_state(&ctx, editor_id).is_some());
|
||||
assert!(editing.shapes.iter().any(|s| matches!(&s.shape, egui::Shape::Text(text) if text.pos.x > hit.right())));
|
||||
draw(vec![egui::Event::Text("1.75".into())]);
|
||||
draw(test_support::key(egui::Key::Enter));
|
||||
draw(vec![]);
|
||||
assert!((value.get() - 1.75).abs() < 1e-8);
|
||||
}
|
||||
// The same native hit range still accepts pointer input after keyboard/editing.
|
||||
for (at, expected) in [(hit.left_center(), 0.0), (hit.center(), 1.0), (hit.right_center(), 2.0)] {
|
||||
draw(test_support::pointer(at, true));
|
||||
let released = draw(test_support::pointer(at, false));
|
||||
assert!((value.get() - expected).abs() < 1e-8);
|
||||
assert_slider_paint(&released.shapes, hit, Tokens::get(), expected, show_value, 1.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
crate::theme::set_dark(previous);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn disabled_and_invisible_sliders_keep_native_input_and_paint_suppression() {
|
||||
let previous = crate::theme::is_dark();
|
||||
for dark in [false, true] {
|
||||
crate::theme::set_dark(dark);
|
||||
for show_value in [false, true] {
|
||||
for visible in [false, true] {
|
||||
let ctx = crate::fonts::test_context();
|
||||
ctx.enable_accesskit();
|
||||
let value = std::cell::Cell::new(0.73123456789);
|
||||
let draw = |events| {
|
||||
slider_test_frame(&ctx, events, |ui| {
|
||||
ui.add_enabled_ui(false, |ui| {
|
||||
if !visible {
|
||||
ui.set_invisible();
|
||||
}
|
||||
let mut next = value.get();
|
||||
let response = slider(ui, &mut next, 0.0..=2.0, Slider { show_value, ..Default::default() });
|
||||
assert!(!response.enabled());
|
||||
assert!(!response.changed());
|
||||
value.set(next);
|
||||
});
|
||||
})
|
||||
};
|
||||
draw(vec![]);
|
||||
let idle = draw(vec![]);
|
||||
let hit = scenario::rect_of("dialog:slider_track:").expect("hidden slider still allocates its track");
|
||||
if visible {
|
||||
let tree = idle.platform_output.accesskit_update.as_ref().expect("disabled accessibility tree");
|
||||
assert!(tree.nodes.iter().any(|(_, n)| n.role() == egui::accesskit::Role::Slider && n.is_disabled()));
|
||||
let circles: Vec<_> =
|
||||
idle.shapes.iter().filter_map(|s| if let egui::Shape::Circle(c) = &s.shape { Some(c) } else { None }).collect();
|
||||
assert_eq!(circles.len(), 1, "disabled slider still has only the token thumb");
|
||||
assert_eq!(circles[0].radius, Tokens::get().space_8);
|
||||
assert_ne!(circles[0].fill, Tokens::get().control_fill, "native disabled fade remains active");
|
||||
} else {
|
||||
assert!(idle.shapes.iter().all(|s| matches!(s.shape, egui::Shape::Noop)), "invisible slider paints no chrome or editor");
|
||||
}
|
||||
draw(test_support::pointer(hit.right_center(), true));
|
||||
draw(test_support::pointer(hit.right_center(), false));
|
||||
draw(test_support::key(egui::Key::Tab));
|
||||
draw(test_support::key(egui::Key::ArrowRight));
|
||||
draw(vec![egui::Event::Text("2".into())]);
|
||||
draw(test_support::key(egui::Key::Enter));
|
||||
assert_eq!(value.get(), 0.73123456789);
|
||||
assert!(ctx.memory(|m| m.focused()).is_none(), "disabled/invisible slider cannot take focus");
|
||||
}
|
||||
}
|
||||
}
|
||||
crate::theme::set_dark(previous);
|
||||
}
|
||||
Reference in new issue
Block a user