VectorCraft: An open-source, vector art tool written by scratch in pure Rust
Type: route font wheel input before scroll smoothing
dotCooCoo13ede29a5e00
diff --git a/crates/ui-egui/src/app/frame.rs b/crates/ui-egui/src/app/frame.rsindex 5fd9dd8d0..0b87eb16b 100644--- a/crates/ui-egui/src/app/frame.rs+++ b/crates/ui-egui/src/app/frame.rs@@ -63,7 +63,7 @@ impl VectorcraftApp {/// Identify the document, modal dialog and focused widget that the current accepted input batch/// belongs to.- pub(super) fn input_generation(&self) -> InputGeneration {+ pub(crate) fn input_generation(&self) -> InputGeneration {InputGeneration {document: self.session.active().map_or(0, |document| document.uid),dialog: self.ui.dialog.as_ref().map(|dialog| egui::Id::unique(&dialog.kind)),diff --git a/crates/ui-egui/src/app/input.rs b/crates/ui-egui/src/app/input.rsindex 6bcfdfd3f..2854e11d6 100644--- a/crates/ui-egui/src/app/input.rs+++ b/crates/ui-egui/src/app/input.rs@@ -175,6 +175,12 @@ impl VectorcraftApp {/// injected until the batch was actually applied, so a burst of hidden ticks cannot queue/// several steps of a drag or replay them together later.pub fn raw_input_hook(&mut self, ctx: &egui::Context, raw: &mut egui::RawInput) {+ self.fill_raw_input(ctx, raw);+ crate::font_menu::sync_wheel_target(self, ctx, raw.viewport_id);+ crate::font_menu::take_raw_wheel(ctx, raw);+ }++ fn fill_raw_input(&mut self, ctx: &egui::Context, raw: &mut egui::RawInput) {// Both hosts call this hook once per host iteration, before deciding whether a UI pass// follows; it is the iteration boundary, not a UI-phase marker.self.begin_host_iteration();diff --git a/crates/ui-egui/src/font_menu.rs b/crates/ui-egui/src/font_menu.rsindex 540951d58..f686b84c9 100644--- a/crates/ui-egui/src/font_menu.rs+++ b/crates/ui-egui/src/font_menu.rs@@ -249,6 +249,7 @@ struct MenuState {/// kept while the pointer stays on it: each step makes its family a recent one, which would/// otherwise move it in the order.wheel_order: Option<Arc<[String]>>,+ wheel_target: Option<crate::state::InputGeneration>,}/// The font family menu showing `current`, `width` points wide, rows sampling `sample` (the@@ -263,6 +264,12 @@ pub fn font_menu() -> Option<FontPick> {let state_id = ui.scope_id().with(&id).with("font-menu");let mut st: MenuState = ui.data(|d| d.get_temp(state_id)).unwrap_or_default();+ let target = ui.data(|d| d.get_temp(wheel_fields_id(ui.ctx().viewport_id()).with("target")));+ let target_changed = st.wheel_target != target;+ if target_changed {+ st.wheel_order = None;+ st.wheel_target = target;+ }let height = st.header + LIST_HEIGHT;let state = &mut st;// The search field and filters stay in place over the rows, which scroll. The rows are all@@ -277,35 +284,53 @@ pub fn font_menu()});let drawn = shown.is_some();+ if target_changed {+ ui.data_mut(|d| d.remove::<f32>(field.id.with("wheel")));+ }let mut out = shown.flatten();if !drawn && out.is_none() && st.previewed.take().is_some() {// Closed (Escape, a click outside) with a preview showing.out = Some(FontPick::EndPreview);}- if !look.wheel || drawn || !field.contains_pointer() {+ let turns = remember_wheel_field(ui, &field, look.wheel && !drawn && field.enabled());+ if !look.wheel || !field.enabled() {st.wheel_order = None;ui.data_mut(|d| d.remove::<f32>(field.id.with("wheel")));- } else if out.is_none() {- let notches = wheel_notches(ui, &field);- if !notches.is_empty() {+ } else if out.is_none() || drawn {+ if !turns.is_empty() {let mut own = vectorcraft_text::FontDb::global().canonical(current, "").0;- if st.wheel_order.is_none() {- st.wheel_order = Some(wheel_order(&st, look).into());- }let mut steps = Vec::new();- if let Some(order) = st.wheel_order.as_deref() {- for notch in notches {- let next = wheel_steps(order, &own, notch);- if let Some(last) = next.last() {- own.clone_from(last);+ for turn in turns {+ match turn {+ WheelInput::Leave => st.wheel_order = None,+ WheelInput::Notches(notches) => {+ if st.wheel_order.is_none() {+ st.wheel_order = Some(wheel_order(&st, look).into());+ }+ if let Some(order) = st.wheel_order.as_deref() {+ let next = wheel_steps(order, &own, notches);+ if let Some(last) = next.last() {+ own.clone_from(last);+ }+ steps.extend(next);+ }}- steps.extend(next);}}if !steps.is_empty() {+ if drawn {+ // These turns preceded the opener. The popup cancels back to the newly+ // applied family, and any preview drawn this pass has not been applied.+ st.current.clone_from(&own);+ st.previewed = None;+ }out = Some(FontPick::Wheel(steps));}}+ if drawn || !field.contains_pointer() {+ st.wheel_order = None;+ ui.data_mut(|d| d.remove::<f32>(field.id.with("wheel")));+ }}if matches!(out, Some(FontPick::Chosen(..))) {st.previewed = None;@@ -355,40 +380,158 @@ fn wheel_steps(order: &[String], current: &str, notches: i32) -> Vec<String> {if to >= at { order.iter().skip(at + 1).take(to - at).cloned().collect() } else { order.iter().take(at).skip(to).rev().cloned().collect() }}-/// Whole notches of the mouse wheel turned over closed field `resp` this frame, positive when it-/// turns down (towards the user). A wheel notch is a line, or `line_scroll_speed` points of a-/// trackpad or fine wheel; what is left of a notch carries over to the next turn. The wheel over-/// the field is the field's: the panel under it does not scroll. A turn with a modifier key is-/// left to the panel and the canvas.-fn wheel_notches(ui: &Ui, resp: &egui::Response) -> Vec<i32> {- let (line, id) = (ui.ctx().options(|o| o.input_options.line_scroll_speed), resp.id.with("wheel"));- let mut notches: f32 = ui.data(|d| d.get_temp(id)).unwrap_or(0.0);- let mut completed = Vec::new();- let mut turned = false;- ui.input_mut(|i| {- i.events.retain(|e| match e {- egui::Event::MouseWheel { unit, delta, modifiers, .. } if modifiers.is_none() => {- notches -= match unit {- egui::MouseWheelUnit::Point => delta.y / line.max(1.0),- egui::MouseWheelUnit::Line | egui::MouseWheelUnit::Page => delta.y,- };- let whole = notches.trunc();- if whole != 0.0 {- completed.push(whole as i32);- notches -= whole;+#[derive(Clone)]+enum WheelInput {+ Leave,+ Notches(i32),+}++#[derive(Clone, Copy)]+struct WheelField {+ id: egui::Id,+ rect: egui::Rect,+ layer: egui::LayerId,+}++#[derive(Clone, Default)]+struct WheelFields {+ pass: u64,+ pending_frame: u64,+ activation_pass: u64,+ activating: Vec<egui::Id>,+ pointer: Option<egui::Pos2>,+ fields: Vec<WheelField>,+ pending: HashMap<egui::Id, Vec<WheelInput>>,+}++fn wheel_fields_id(viewport: egui::ViewportId) -> egui::Id {+ egui::Id::unique("font-wheel-fields").with(viewport)+}++/// Pending turns belong to the document, dialog and focus that received their input batch.+pub(crate) fn sync_wheel_target(app: &VectorcraftApp, ctx: &egui::Context, viewport: egui::ViewportId) {+ let target = app.input_generation();+ let key = wheel_fields_id(viewport);+ ctx.data_mut(|d| {+ if d.get_temp::<crate::state::InputGeneration>(key.with("target")).is_some_and(|old| old != target) {+ d.remove::<WheelFields>(key);+ }+ d.insert_temp(key.with("target"), target);+ });+}++/// Remember the visible closed fields for the next input batch and take this field's turns.+fn remember_wheel_field(ui: &Ui, resp: &egui::Response, enabled: bool) -> Vec<WheelInput> {+ let key = wheel_fields_id(ui.ctx().viewport_id());+ let pass = ui.ctx().cumulative_pass_nr();+ ui.data_mut(|d| {+ let mut fields: WheelFields = d.get_temp(key).unwrap_or_default();+ if fields.pass != pass {+ fields.pass = pass;+ fields.fields.clear();+ }+ fields.fields.retain(|f| f.id != resp.id);+ if enabled {+ fields.fields.push(WheelField { id: resp.id, rect: resp.interact_rect, layer: resp.layer_id });+ }+ let turns = fields.pending.remove(&resp.id).unwrap_or_default();+ d.insert_temp(key, fields);+ turns+ })+}++/// Take the closed font fields' wheel events before egui smooths and combines them. Other+/// events stay in the input, so scrolling elsewhere keeps its own delta and event order.+pub(crate) fn take_raw_wheel(ctx: &egui::Context, raw: &mut egui::RawInput) {+ let key = wheel_fields_id(raw.viewport_id);+ let Some(mut fields) = ctx.data(|d| d.get_temp::<WheelFields>(key)) else { return };+ if !ctx.input(|i| i.raw.viewports.contains_key(&raw.viewport_id)) {+ ctx.data_mut(|d| d.remove::<WheelFields>(key));+ return;+ }+ let frame = ctx.cumulative_frame_nr_for(raw.viewport_id);+ let pass = ctx.cumulative_pass_nr_for(raw.viewport_id);+ if pass < fields.pass || pass.saturating_sub(fields.pass) > 1 {+ fields.fields.clear();+ fields.pointer = None;+ }+ if fields.pending_frame != frame {+ fields.pending_frame = frame;+ fields.pending.clear();+ }+ let line = ctx.options(|o| o.input_options.line_scroll_speed).max(1.0);+ let mut pointer = fields.pointer.or_else(|| ctx.input(|i| i.pointer.latest_pos()));+ let over =+ |field: &WheelField, point: Option<egui::Pos2>| point.is_some_and(|p| field.rect.contains(p) && ctx.layer_id_at(p) == Some(field.layer));+ // An activation batch belongs to the popup, including a release after a prior press.+ if fields.activation_pass != pass {+ fields.activation_pass = pass;+ fields.activating.clear();+ let pressed = ctx.input(|i| if i.pointer.button_down(egui::PointerButton::Primary) { i.pointer.press_origin() } else { None });+ if let Some(field) = fields.fields.iter().find(|f| over(f, pressed)) {+ fields.activating.push(field.id);+ }+ }+ let focused = ctx.memory(|m| m.focused());+ let mut captured = false;+ raw.events.retain(|event| {+ let opening = match event {+ egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: true, .. } => {+ fields.fields.iter().rev().find(|f| over(f, Some(*pos))).map(|f| f.id)+ }+ egui::Event::Key { key: egui::Key::Enter | egui::Key::Space, pressed: true, .. } if raw.focused => {+ focused.filter(|id| fields.fields.iter().any(|f| f.id == *id))+ }+ _ => None,+ };+ if let Some(id) = opening+ && !fields.activating.contains(&id)+ {+ fields.activating.push(id);+ }+ match event {+ egui::Event::PointerMoved(p) | egui::Event::PointerButton { pos: p, .. } => {+ for field in &fields.fields {+ if over(field, pointer) && !over(field, Some(*p)) {+ ctx.data_mut(|d| d.remove::<f32>(field.id.with("wheel")));+ fields.pending.entry(field.id).or_default().push(WheelInput::Leave);+ }+ }+ pointer = Some(*p);+ }+ egui::Event::PointerGone => {+ pointer = None;+ for field in &fields.fields {+ ctx.data_mut(|d| d.remove::<f32>(field.id.with("wheel")));+ fields.pending.entry(field.id).or_default().push(WheelInput::Leave);+ }+ }+ egui::Event::MouseWheel { unit, delta, modifiers, .. } if modifiers.is_none() && delta.y != 0.0 => {+ if let Some(field) = fields.fields.iter().rev().find(|f| !fields.activating.contains(&f.id) && over(f, pointer)).copied() {+ let id = field.id.with("wheel");+ let mut notches: f32 = ctx.data(|d| d.get_temp(id)).unwrap_or(0.0);+ notches -= match unit {+ egui::MouseWheelUnit::Point => delta.y / line,+ egui::MouseWheelUnit::Line | egui::MouseWheelUnit::Page => delta.y,+ };+ let whole = notches.trunc();+ ctx.data_mut(|d| d.insert_temp(id, notches - whole));+ if whole != 0.0 {+ fields.pending.entry(field.id).or_default().push(WheelInput::Notches(whole as i32));+ }+ captured = true;+ return false;}- turned = true;- false}- _ => true,- });- if turned || i.modifiers.is_none() {- // The rest of a turn egui spreads over the next frames scrolls nothing either.- i.smooth_scroll_delta = egui::Vec2::ZERO;+ _ => {}}+ true});- ui.data_mut(|d| d.insert_temp(id, notches));- completed+ fields.pointer = pointer;+ ctx.data_mut(|d| d.insert_temp(key, fields));+ if captured {+ ctx.request_repaint();+ }}/// What the menu's header hands its rows.diff --git a/crates/ui-egui/src/font_menu/tests.rs b/crates/ui-egui/src/font_menu/tests.rsindex 3643c54d2..73db46de3 100644--- a/crates/ui-egui/src/font_menu/tests.rs+++ b/crates/ui-egui/src/font_menu/tests.rs@@ -262,6 +262,99 @@ fn the_wheel_follows_the_menus_order_and_filters() {assert_eq!(order, favorites, "the favourites filter");}+/// A field removed by a later layout pass must not intercept the next wheel event.+#[test]+fn a_family_field_omitted_from_the_last_pass_leaves_the_wheel_to_its_owner() {+ let ctx = egui::Context::default();+ let mut point = egui::Pos2::ZERO;+ for _ in 0..3 {+ let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {+ let resp = ui.button("Family");+ point = resp.rect.center();+ super::remember_wheel_field(ui, &resp, true);+ });+ out.textures_delta.clear();+ }+ let mut pass = 0;+ let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {+ if pass == 0 {+ let resp = ui.button("Family");+ point = resp.rect.center();+ super::remember_wheel_field(ui, &resp, true);+ ui.ctx().request_discard("the next pass removes the field");+ }+ pass += 1;+ });+ out.textures_delta.clear();+ assert!(pass > 1);+ let mut raw = egui::RawInput {+ events: vec![+ egui::Event::PointerMoved(point),+ egui::Event::MouseWheel {+ unit: egui::MouseWheelUnit::Line,+ delta: egui::vec2(0.0, -1.0),+ phase: egui::TouchPhase::Move,+ modifiers: Default::default(),+ source: egui::MouseWheelSource::Unknown,+ },+ ],+ ..Default::default()+ };+ super::take_raw_wheel(&ctx, &mut raw);+ assert!(raw.events.iter().any(|e| matches!(e, egui::Event::MouseWheel { .. })));+}++/// Activation leaves later wheel input to the popup; an earlier turn still belongs to the field.+#[test]+fn activating_the_family_popup_leaves_its_wheel_input_available() {+ let activations = [None, Some((egui::Key::Enter, egui::Modifiers::NONE)), Some((egui::Key::Space, egui::Modifiers::SHIFT))];+ for activation in activations {+ let ctx = egui::Context::default();+ let frame = |events| {+ let mut raw = egui::RawInput { events, ..Default::default() };+ super::take_raw_wheel(&ctx, &mut raw);+ let mut point = egui::Pos2::ZERO;+ let mut out = ctx.run_ui(raw, |ui| {+ let resp = ui.button("Family");+ point = resp.rect.center();+ if activation.is_some() {+ resp.request_focus();+ }+ super::remember_wheel_field(ui, &resp, true);+ });+ out.textures_delta.clear();+ point+ };+ let mut point = egui::Pos2::ZERO;+ for _ in 0..3 {+ point = frame(vec![]);+ }+ let button =+ |pressed| egui::Event::PointerButton { pos: point, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };+ let opener = if let Some((key, modifiers)) = activation {+ egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers }+ } else {+ frame(vec![egui::Event::PointerMoved(point), button(true)]);+ button(false)+ };+ let turn = || egui::Event::MouseWheel {+ unit: egui::MouseWheelUnit::Line,+ delta: egui::vec2(0.0, -1.0),+ phase: egui::TouchPhase::Move,+ modifiers: Default::default(),+ source: egui::MouseWheelSource::Unknown,+ };+ let mut events = vec![egui::Event::PointerMoved(point)];+ if activation.is_some() {+ events.push(turn());+ }+ events.extend([opener, turn()]);+ let mut raw = egui::RawInput { events, ..Default::default() };+ super::take_raw_wheel(&ctx, &mut raw);+ assert_eq!(raw.events.iter().filter(|e| matches!(e, egui::Event::MouseWheel { .. })).count(), 1);+ }+}+/// The Font Technology filter's Variable is the font adjective, not the Variables panel's noun.#[test]fn the_variable_filter_is_named_as_fonts_are() {diff --git a/crates/ui-egui/src/panels/character.rs b/crates/ui-egui/src/panels/character.rsindex b81ed8cd2..be3daf2d4 100644--- a/crates/ui-egui/src/panels/character.rs+++ b/crates/ui-egui/src/panels/character.rs@@ -804,6 +804,7 @@ fn font_height_reference(app: &mut VectorcraftApp, ui: &mut Ui, width: f32) {/// Control bar), with their `ids` and `widths`. The mouse wheel over the closed family field steps/// the text through the families.pub(crate) fn font_pickers(app: &mut VectorcraftApp, ui: &mut Ui, s: &CharStyle, ids: (&str, &str), widths: (f32, f32)) {+ crate::font_menu::sync_wheel_target(app, ui.ctx(), ui.ctx().viewport_id());let sample = crate::font_menu::sample_text(app);let look = crate::font_menu::MenuLook { wheel: true, ..crate::font_menu::MenuLook::of(app) };if let Some(pick) = crate::font_menu::font_menu(ui, ids.0, &s.font_family, widths.0, sample.as_deref(), look) {diff --git a/crates/ui-egui/src/tests/font_menu.rs b/crates/ui-egui/src/tests/font_menu.rsindex 42548244d..078286133 100644--- a/crates/ui-egui/src/tests/font_menu.rs+++ b/crates/ui-egui/src/tests/font_menu.rs@@ -232,8 +232,9 @@ fn panel_frame(family: &str,draw: &dyn Fn(&mut VectorcraftApp, &mut egui::Ui),) -> (Option<egui::Pos2>, bool) {- let input =+ let mut input =egui::RawInput { events, screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(600.0, 800.0))), ..Default::default() };+ app.raw_input_hook(ctx, &mut input);let mut out = ctx.run_ui(input, |ui| {crate::font_menu::end_stale_preview(app, ui.ctx());draw(app, ui);@@ -336,6 +337,119 @@ fn opposite_wheel_notches_in_one_frame_keep_their_undo_steps() {assert_eq!(first_style(&app, id).font_family, "Inter");}+/// A turn before opening applies once; the popup keeps the later wheel and cancels to that font.+#[test]+fn a_wheel_before_opening_the_family_popup_keeps_its_committed_change() {+ let ctx = egui::Context::default();+ crate::theme::install_fonts(&ctx);+ let mut app = VectorcraftApp::new(Session::new(), Default::default());+ let id = selected_inter(&mut app);+ let draw = |app: &mut VectorcraftApp, ui: &mut egui::Ui| crate::panels::character::show(app, ui);+ let mut field = None;+ for _ in 0..3 {+ field = panel_frame(&ctx, &mut app, vec![], "Inter", &draw).0;+ }+ let field = field.unwrap();+ let before = app.session.active().unwrap().history.undo.len();+ let button = |pressed| egui::Event::PointerButton { pos: field, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };+ let turn = || wheel(egui::MouseWheelUnit::Line, -1.0, Default::default());+ panel_frame(&ctx, &mut app, vec![egui::Event::PointerMoved(field), turn(), button(true), button(false), turn()], "Inter", &draw);+ let applied = first_style(&app, id).font_family;+ assert_ne!(applied, "Inter");+ assert_eq!(app.session.active().unwrap().history.undo.len(), before + 1);+ for _ in 0..3 {+ panel_frame(&ctx, &mut app, vec![], &applied, &draw);+ }+ panel_frame(&ctx, &mut app, key(egui::Key::Escape), &applied, &draw);+ assert_eq!(first_style(&app, id).font_family, applied);+ assert_eq!(app.session.active().unwrap().history.undo.len(), before + 1);+ app.run("edit.undo", json!({})).unwrap();+ assert_eq!(first_style(&app, id).font_family, "Inter");+}++/// A later pointer move must not change which field owns an earlier wheel event.+#[test]+fn wheel_events_use_the_pointer_position_when_they_occurred() {+ let ctx = egui::Context::default();+ crate::theme::install_fonts(&ctx);+ let mut app = VectorcraftApp::new(Session::new(), Default::default());+ let id = selected_inter(&mut app);+ let draw = |app: &mut VectorcraftApp, ui: &mut egui::Ui| crate::panels::character::show(app, ui);+ let mut field = None;+ for _ in 0..3 {+ field = panel_frame(&ctx, &mut app, vec![], "Inter", &draw).0;+ }+ let field = field.expect("the Character panel shows the family field");+ let outside = egui::pos2(580.0, 780.0);+ panel_frame(&ctx, &mut app, vec![egui::Event::PointerMoved(outside)], "Inter", &draw);+ let before = app.session.active().unwrap().history.undo.len();+ let line = egui::MouseWheelUnit::Line;+ panel_frame(&ctx, &mut app, vec![wheel(line, -1.0, Default::default()), egui::Event::PointerMoved(field)], "Inter", &draw);+ assert_eq!(first_style(&app, id).font_family, "Inter", "the wheel was outside the field");+ assert_eq!(app.session.active().unwrap().history.undo.len(), before);+ assert!(ctx.input(|i| i.events.iter().any(|e| matches!(e, egui::Event::MouseWheel { .. }))), "outside wheel input is left for its owner");+ panel_frame(&ctx, &mut app, vec![wheel(line, -1.0, Default::default()), egui::Event::PointerMoved(outside)], "Inter", &draw);+ assert_ne!(first_style(&app, id).font_family, "Inter", "the wheel was over the field before the pointer left");+ assert_eq!(app.session.active().unwrap().history.undo.len(), before + 1);+ app.run("edit.undo", json!({})).unwrap();+ assert_eq!(first_style(&app, id).font_family, "Inter");+ let button = |pos| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() };+ panel_frame(&ctx, &mut app, vec![button(field), wheel(line, -1.0, Default::default()), button(outside)], "Inter", &draw);+ assert_ne!(first_style(&app, id).font_family, "Inter", "button events also carry the pointer's position");+ assert_eq!(app.session.active().unwrap().history.undo.len(), before + 1);+ app.run("edit.undo", json!({})).unwrap();+ let end = egui::Event::MouseWheel {+ unit: egui::MouseWheelUnit::Point,+ delta: egui::Vec2::ZERO,+ modifiers: Default::default(),+ phase: egui::TouchPhase::End,+ source: egui::MouseWheelSource::Unknown,+ };+ panel_frame(&ctx, &mut app, vec![end], "Inter", &draw);+ panel_frame(+ &ctx,+ &mut app,+ vec![+ wheel(egui::MouseWheelUnit::Point, -2.0, Default::default()),+ egui::Event::PointerMoved(field),+ wheel(line, -1.0, Default::default()),+ egui::Event::PointerMoved(outside),+ ],+ "Inter",+ &draw,+ );+ assert_eq!(app.session.active().unwrap().history.undo.len(), before + 1);+ assert_eq!(ctx.input(|i| i.smooth_scroll_delta.y), -2.0, "only the outside wheel contributes to panel scrolling");+}++/// A turn queued for one document cannot restyle another document opened before its UI pass.+#[test]+fn a_wheel_queued_for_another_document_is_discarded() {+ let ctx = egui::Context::default();+ crate::theme::install_fonts(&ctx);+ let mut app = VectorcraftApp::new(Session::new(), Default::default());+ selected_inter(&mut app);+ let draw = |app: &mut VectorcraftApp, ui: &mut egui::Ui| crate::panels::character::show(app, ui);+ let mut field = None;+ for _ in 0..3 {+ field = panel_frame(&ctx, &mut app, vec![], "Inter", &draw).0;+ }+ let field = field.expect("the Character panel shows the family field");+ let mut raw = egui::RawInput {+ events: vec![egui::Event::PointerMoved(field), wheel(egui::MouseWheelUnit::Line, -1.0, Default::default())],+ screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(600.0, 800.0))),+ ..Default::default()+ };+ app.raw_input_hook(&ctx, &mut raw);+ assert!(!raw.events.iter().any(|e| matches!(e, egui::Event::MouseWheel { .. })));+ let id = selected_inter(&mut app);+ let before = app.session.active().unwrap().history.undo.len();+ let mut out = ctx.run_ui(raw, |ui| draw(&mut app, ui));+ out.textures_delta.clear();+ assert_eq!(first_style(&app, id).font_family, "Inter");+ assert_eq!(app.session.active().unwrap().history.undo.len(), before);+}+/// #5253: the Properties panel and the Control bar have the same family field, and the wheel steps/// the families over it too.#[test]