mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-17 18:04:48 +00:00
Remove the press-routing DIAG prints: the colour-well click reaches its member and the routing tests of rounds I-K pass
This commit is contained in:
@@ -992,15 +992,6 @@ fn run_in_host(p: &mut Pass<'_, '_, '_>, ui: &mut Ui, host_at: Option<ShowAt>, h
|
||||
// A key or AccessKit activation of a member reaches its arena root, which names the member.
|
||||
let keyed = member.is_some_and(|arena| keys::activated_member(&ctx, arena.0) == Some(id));
|
||||
core.activation = activation_of(&ctx, ui, hit, resolved, keyed, root_sense, activation);
|
||||
if activation && let Some(test) = crate::runtime::pointer::diag_test() {
|
||||
eprintln!(
|
||||
"DIAG {test}: {} activation {:?} takes {} member {}",
|
||||
crate::runtime::pointer::diag_id(id),
|
||||
core.activation,
|
||||
steps::takes_activation(resolved),
|
||||
member.is_some(),
|
||||
);
|
||||
}
|
||||
core.activated_member = activated_member.or_else(|| arena.then(|| keys::activated_member(&ctx, id)).flatten());
|
||||
// A session member with no focused part takes the canvas's and the window's Enter, Escape and arrows first.
|
||||
if let Some(arena) = session.filter(|_| !inert && !core.focus.focused) {
|
||||
|
||||
@@ -779,18 +779,6 @@ pub(crate) fn sense_members(ui: &Ui, arena: ArenaId, specs: &[MemberSpec<'_>]) -
|
||||
.zip(joined)
|
||||
.map(|(spec, (local, known))| {
|
||||
let view = member_view(&outcome, spec.id, local, pointer_pos);
|
||||
if let Some(test) = pointer::diag_test()
|
||||
&& outcome.activated.is_some_and(|hit| hit.owner == spec.id)
|
||||
{
|
||||
eprintln!(
|
||||
"DIAG {test}: member {} of {} reads the activation: clicked {} enabled {} pass {pass_nr} outcome pass {}",
|
||||
pointer::diag_id(spec.id),
|
||||
pointer::diag_id(arena.0),
|
||||
view.press.clicked,
|
||||
spec.enabled,
|
||||
outcome.pass,
|
||||
);
|
||||
}
|
||||
MemberResult {
|
||||
response: response::member(ui, spec.id, spec.rect, spec.enabled, view),
|
||||
parts: part_results_in(&outcome, &known, (mods, sample, pointer_pos), spec.id, spec.parts),
|
||||
@@ -875,7 +863,6 @@ fn outcome_in(ctx: &Context, read: &PassRead, arena: ArenaId, layer: Layer, enab
|
||||
let hover_layer_ok = top.is_some_and(|top| top == layer || Some(top) == body_layer);
|
||||
let members = !pointer::members_withheld(ctx, read.viewport, pass_nr, arena.0);
|
||||
let (mut cancelled, mut release_held) = (false, false);
|
||||
let measuring = crate::runtime::measure::active(ctx);
|
||||
let outcome = with_arena(ctx, arena, pass_nr, |state| {
|
||||
let pos = pos.unwrap_or(Pos2::ZERO);
|
||||
let input = PassInput::new(
|
||||
@@ -904,17 +891,6 @@ fn outcome_in(ctx: &Context, read: &PassRead, arena: ArenaId, layer: Layer, enab
|
||||
};
|
||||
let won_kinds = root.map_or(Sense::empty(), |own| pointer::press_winners(ctx, at, targets).senses_of(own));
|
||||
let allowed = crate::runtime::sampler::root_takes_press(ctx, root, layer, at, untargeted) && !won_kinds.is_empty();
|
||||
if let Some(test) = pointer::diag_test()
|
||||
&& state.root.is_some_and(|own| own.rect.contains(at))
|
||||
{
|
||||
eprintln!(
|
||||
"DIAG {test}: start root {:?} enabled {enabled} allowed {allowed} won {won_kinds:?} untargeted {untargeted} takes {} layer {layer:?} rect {:?} clip {:?}",
|
||||
root.map(pointer::diag_id),
|
||||
crate::runtime::sampler::root_takes_press(ctx, root, layer, at, untargeted),
|
||||
state.root.map(|own| own.rect),
|
||||
state.root.map(|own| own.clip),
|
||||
);
|
||||
}
|
||||
if !enabled || !allowed {
|
||||
return None;
|
||||
}
|
||||
@@ -922,15 +898,6 @@ fn outcome_in(ctx: &Context, read: &PassRead, arena: ArenaId, layer: Layer, enab
|
||||
// window's edge): a root under a raw egui one keeps its click there, but a drag is that widget's.
|
||||
let drag_elsewhere = targets.click.is_none() && targets.drag.is_some_and(|id| pointer::foreign_target(ctx, id));
|
||||
let won = resolve_press_in(state, members, xf, at, target);
|
||||
if let Some(test) = pointer::diag_test() {
|
||||
eprintln!(
|
||||
"DIAG {test}: start resolve root {:?} members {members} previous {} xf {} won {:?}",
|
||||
root.map(pointer::diag_id),
|
||||
state.previous.len(),
|
||||
xf.is_some(),
|
||||
won.map(|hit| (pointer::diag_id(hit.owner), hit.part.is_some(), hit.sense)),
|
||||
);
|
||||
}
|
||||
// The kinds of press another root won are not this one's.
|
||||
let lost = (Sense::CLICK | Sense::DRAG).difference(won_kinds);
|
||||
won.map(|hit| {
|
||||
@@ -938,20 +905,6 @@ fn outcome_in(ctx: &Context, read: &PassRead, arena: ArenaId, layer: Layer, enab
|
||||
(hit, if drag_elsewhere { sense.difference(Sense::DRAG) } else { sense })
|
||||
})
|
||||
});
|
||||
if let Some(test) = pointer::diag_test()
|
||||
&& (step.target.is_some() || step.activated.is_some())
|
||||
{
|
||||
eprintln!(
|
||||
"DIAG {test}: step root {:?} pass {pass_nr} measuring {measuring} events {} held {} cancel {cancel:?} phase {:?} target {:?} activated {:?} open {}",
|
||||
state.root.map(|root| pointer::diag_id(root.id)),
|
||||
pass_pointer.events.len(),
|
||||
pass_pointer.primary_down,
|
||||
step.phase,
|
||||
step.target.map(|hit| pointer::diag_id(hit.owner)),
|
||||
step.activated.map(|hit| pointer::diag_id(hit.owner)),
|
||||
machine.target().is_some(),
|
||||
);
|
||||
}
|
||||
cancelled = matches!(step.phase, Some(PressPhase::Cancel { .. }));
|
||||
release_held = machine.release_held();
|
||||
let open = machine.target();
|
||||
@@ -992,15 +945,6 @@ fn sweep_undrawn(ctx: &Context) {
|
||||
})
|
||||
};
|
||||
if orphaned(state) {
|
||||
if let Some(test) = pointer::diag_test() {
|
||||
eprintln!(
|
||||
"DIAG {test}: sweep ends the press of root {:?} target {:?} root ran {} members {}",
|
||||
state.root.map(|root| pointer::diag_id(root.id)),
|
||||
state.machine.target().map(|target| pointer::diag_id(target.owner)),
|
||||
state.pass == pass_nr,
|
||||
state.members.len(),
|
||||
);
|
||||
}
|
||||
state.machine = PressMachine::default();
|
||||
state.host_cancel = false;
|
||||
gone = true;
|
||||
|
||||
@@ -580,19 +580,13 @@ pub(crate) fn press_winner(ctx: &Context, at: Pos2, targets: PressTargets) -> Op
|
||||
|
||||
fn find_press_winners(ctx: &Context, viewport: ViewportId, at: Pos2, targets: PressTargets) -> PressWinners {
|
||||
let Some(layer) = areas::layer_at(ctx, at).or_else(|| layer_past_window(ctx, viewport, at)) else {
|
||||
if let Some(test) = diag_test() {
|
||||
eprintln!("DIAG {test}: press_winner at {at:?}: no layer");
|
||||
}
|
||||
return PressWinners::default();
|
||||
};
|
||||
if let Some(test) = diag_test().filter(|test| ["liquify", "half_plane", "crop_drag"].iter().any(|name| test.contains(name))) {
|
||||
diag_layers(ctx, viewport, at, layer, test);
|
||||
}
|
||||
let to_layer = |layer: Layer| areas::layer_map(ctx, layer).map_or(at, |map| map.to_layer(at));
|
||||
let body = PerViewport::<Shapes>::with(ctx, viewport, |record| record.last_bodies.get(&layer).copied());
|
||||
let beneath = body.map(|(root, parent)| (root, parent, to_layer(parent)));
|
||||
let on_layer = to_layer(layer);
|
||||
let found = PerViewport::<Shapes>::with(ctx, viewport, |record| {
|
||||
PerViewport::<Shapes>::with(ctx, viewport, |record| {
|
||||
// Bottom to top: the body layer's root on its own layer, then the roots on the layer in paint order.
|
||||
let mut stack: Vec<(u8, Id, &RootRecord, Pos2)> = Vec::new();
|
||||
if let Some((root, parent, point)) = beneath
|
||||
@@ -604,33 +598,6 @@ fn find_press_winners(ctx: &Context, viewport: ViewportId, at: Pos2, targets: Pr
|
||||
stack.extend(roots.iter().map(|(root, entry)| (1, *root, entry, on_layer)));
|
||||
}
|
||||
let shown = stack.iter().any(|(_, _, entry, point)| entry.placed.iter().any(|placed| placed.clip.contains(*point)));
|
||||
if let Some(test) = diag_test() {
|
||||
let hits: Vec<String> = stack
|
||||
.iter()
|
||||
.flat_map(|(tier, root, entry, point)| {
|
||||
entry.shapes.iter().zip(&entry.placed).filter(|(shape, _)| shape.hits(*point)).map(move |(shape, placed)| {
|
||||
format!(
|
||||
"[tier {tier} root {} owner {} part {:?} sense {:?} level {:?} pos {} order {} clip_in {}]",
|
||||
diag_id(*root),
|
||||
diag_id(shape.owner),
|
||||
shape.part,
|
||||
shape.sense,
|
||||
shape.priority.level,
|
||||
shape.position,
|
||||
placed.order,
|
||||
placed.clip.contains(*point)
|
||||
)
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
let foreign = |widget: Option<Id>| widget.map(|widget| (diag_id(widget), !registered_in(&record.last, widget)));
|
||||
eprintln!(
|
||||
"DIAG {test}: press_winner at {at:?} layer {layer:?} body {:?} click {:?} drag {:?} shown {shown} hits {hits:?}",
|
||||
beneath.map(|(root, parent, _)| (diag_id(root), parent)),
|
||||
foreign(targets.click),
|
||||
foreign(targets.drag)
|
||||
);
|
||||
}
|
||||
if targets.click.is_some_and(|widget| !registered_in(&record.last, widget)) {
|
||||
return PressWinners::default();
|
||||
}
|
||||
@@ -685,12 +652,7 @@ fn find_press_winners(ctx: &Context, viewport: ViewportId, at: Pos2, targets: Pr
|
||||
}
|
||||
}
|
||||
winners
|
||||
});
|
||||
if let Some(test) = diag_test() {
|
||||
let show = |found: Option<(Winner<Id>, Id)>| found.map(|(winner, root)| (diag_id(root), diag_id(winner.owner), winner.part, winner.sense));
|
||||
eprintln!("DIAG {test}: press_winner at {at:?} -> click {:?} drag {:?}", show(found.click), show(found.drag));
|
||||
}
|
||||
found
|
||||
})
|
||||
}
|
||||
|
||||
/// The layer a press past the window goes to, where egui has none (only automation names such a point: a document
|
||||
@@ -715,65 +677,6 @@ fn layer_past_window(ctx: &Context, viewport: ViewportId, at: Pos2) -> Option<La
|
||||
})
|
||||
}
|
||||
|
||||
/// DIAG: every layer of last pass's shape record at `at`, top first: its place in egui's order, whether it is the
|
||||
/// press's layer, the body it shows, and each root's shapes under the point (sensing or not).
|
||||
fn diag_layers(ctx: &Context, viewport: ViewportId, at: Pos2, chosen: Layer, test: &str) {
|
||||
let mut layers: Vec<Layer> = PerViewport::<Shapes>::with(ctx, viewport, |record| record.last.keys().copied().collect());
|
||||
layers.sort_by_key(|layer| std::cmp::Reverse(areas::layer_position(ctx, *layer)));
|
||||
for layer in layers {
|
||||
let point = areas::layer_map(ctx, layer).map_or(at, |map| map.to_layer(at));
|
||||
let position = areas::layer_position(ctx, layer);
|
||||
let interactable = egui::AreaState::load(ctx, layer.id).map(|state| (state.interactable, state.rect()));
|
||||
let line = PerViewport::<Shapes>::with(ctx, viewport, |record| {
|
||||
let body = record.last_bodies.get(&layer).map(|(root, parent)| (diag_id(*root), *parent));
|
||||
let roots: Vec<String> = record
|
||||
.last
|
||||
.get(&layer)
|
||||
.into_iter()
|
||||
.flat_map(|roots| roots.iter())
|
||||
.map(|(root, entry)| {
|
||||
let under: Vec<String> = entry
|
||||
.shapes
|
||||
.iter()
|
||||
.zip(&entry.placed)
|
||||
.filter(|(shape, _)| shape.hits(point))
|
||||
.map(|(shape, placed)| {
|
||||
format!("{} {:?} {:?} clip_in {}", diag_id(shape.owner), shape.part, shape.sense, placed.clip.contains(point))
|
||||
})
|
||||
.collect();
|
||||
format!("root {} shapes {} under {under:?}", diag_id(*root), entry.shapes.len())
|
||||
})
|
||||
.collect();
|
||||
format!("layer {layer:?} at {position} area {interactable:?} chosen {} body {body:?} point {point:?} roots {roots:?}", layer == chosen)
|
||||
});
|
||||
eprintln!("DIAG {test}: layers at {at:?}: {line}");
|
||||
}
|
||||
}
|
||||
|
||||
/// DIAG: the test under study this thread runs, if any.
|
||||
pub(crate) fn diag_test() -> Option<&'static str> {
|
||||
const TESTS: [&str; 8] = [
|
||||
"delete_removes_the_plane_and_escape_drops_a_half_plane_first",
|
||||
"a_window_mounts_edges_resize_the_window_and_the_childs_press_keeps_its_click",
|
||||
"gradient_map_stop_picker_closed_without_a_colour_changes_nothing",
|
||||
"photo_filter_colour_picker_previews_live_cancel_restores_and_ok_is_one_step",
|
||||
"every_paragraph_box_handle_resizes_the_box_with_snapping_on",
|
||||
"click_inside_the_paragraph_box_off_the_glyphs_moves_the_caret",
|
||||
"a_crop_drag_begun_before_the_dialog_still_ends_under_it",
|
||||
"move_pointer_still_reaches_the_liquify_workspace",
|
||||
];
|
||||
// Trials run on unnamed pool threads: there the run names its trial in `CRAFT_DIAG_TEST`.
|
||||
let thread = std::thread::current();
|
||||
let name = std::env::var("CRAFT_DIAG_TEST").ok().or_else(|| thread.name().map(str::to_owned))?;
|
||||
TESTS.into_iter().find(|test| name.ends_with(test))
|
||||
}
|
||||
|
||||
/// DIAG: the tail of an id's path.
|
||||
pub(crate) fn diag_id(id: Id) -> String {
|
||||
let text = format!("{id:?}");
|
||||
text.char_indices().rev().nth(90).map_or(text.clone(), |(at, _)| text[at..].to_owned())
|
||||
}
|
||||
|
||||
/// Whether some root registered the egui widget `widget` in `layers`.
|
||||
fn registered_in(layers: &LayerRecord, widget: Id) -> bool {
|
||||
layers.values().any(|roots| roots.values().any(|root| root.widgets.contains(&widget)))
|
||||
|
||||
Reference in New Issue
Block a user