Merge rundown preview and corrections with row filters

This commit is contained in:
Dandaedre 2026-11-03 14:39:48 +01:00
parent 9443b7e789
commit 3132dc50e5
4 changed files with 424 additions and 415 deletions

View File

@ -6,7 +6,7 @@ use crate::{
time::display,
};
use eframe::egui::{self, Color32, RichText};
use review::ReviewView;
use review::{ReviewView, RowFilter};
use std::{
path::PathBuf,
sync::{
@ -52,9 +52,11 @@ struct App {
review_view: ReviewView,
dirty: bool,
issue_index: usize,
issues_only: bool,
row_filter: RowFilter,
show_issue_details: bool,
selected_row: Option<usize>,
jump_row: Option<usize>,
review_scroll: Option<f32>,
row_details: bool,
resolutions_open: bool,
profile_path: Option<PathBuf>,
@ -83,9 +85,11 @@ impl Default for App {
review_view: ReviewView::Rows,
dirty: false,
issue_index: 0,
issues_only: true,
row_filter: RowFilter::Included,
show_issue_details: false,
selected_row: None,
jump_row: None,
review_scroll: None,
row_details: false,
resolutions_open: false,
profile_path: None,
@ -101,6 +105,9 @@ impl App {
self.issue_index = 0;
self.selected_row = None;
self.jump_row = None;
self.review_scroll = None;
self.row_filter = RowFilter::Included;
self.show_issue_details = false;
self.completed = None;
self.error = None;
}
@ -224,11 +231,7 @@ impl App {
self.issue_index = 0;
self.selected_row = a.diagnostics.first().and_then(review::diagnostic_row);
self.jump_row = self.selected_row;
self.review_view = if a.diagnostics.is_empty() {
ReviewView::Preview
} else {
ReviewView::Rows
};
self.review_view = ReviewView::Rows;
self.analysis = Some(*a);
}
Update::Exported(p) => {

View File

@ -6,10 +6,17 @@ use std::collections::BTreeSet;
pub(super) enum ReviewView {
#[default]
Rows,
Preview,
Columns,
}
#[derive(Default, PartialEq, Clone, Copy)]
pub(super) enum RowFilter {
All,
#[default]
Included,
Attention,
}
pub(super) fn diagnostic_row(d: &Diagnostic) -> Option<usize> {
let (_, location) = d.location.rsplit_once('!')?;
let row = if let Some(row) = location.strip_prefix("row ") {
@ -54,6 +61,7 @@ struct PreviewRow {
source_only: bool,
issues: Vec<usize>,
decisions: String,
kind: String,
}
/// Combine timed draft entries and omitted problem rows without changing the IR.
@ -62,8 +70,9 @@ fn preview_rows(a: &Analysis, table: Option<&Table>) -> Vec<PreviewRow> {
let mut represented = BTreeSet::new();
if let Some(r) = &a.rundown {
for e in &r.entries {
let sources: BTreeSet<_> = e.source_rows.iter().map(|s| s.row).collect();
represented.extend(&sources);
if let Some(first) = e.source_rows.first() {
represented.insert(first.row);
}
rows.push(PreviewRow {
row: e.source_rows.first().map_or(0, |s| s.row),
start: format!(
@ -83,18 +92,31 @@ fn preview_rows(a: &Analysis, table: Option<&Table>) -> Vec<PreviewRow> {
.diagnostics
.iter()
.enumerate()
.filter(|(_, d)| diagnostic_row(d).is_some_and(|r| sources.contains(&r)))
.filter(|(_, d)| diagnostic_row(d) == e.source_rows.first().map(|s| s.row))
.map(|(i, _)| i)
.collect(),
decisions: e.decisions.join("\n"),
kind: e.kind.clone(),
});
}
}
if let Some(table) = table {
for d in &a.diagnostics {
let Some(row) = diagnostic_row(d).filter(|r| *r <= table.rows.len()) else {
let header = a
.mapping
.as_ref()
.map(|m| m.header_row)
.or_else(|| {
detect::inspect(table, &Profile::default())
.1
.first()
.and_then(|s| s.strip_prefix("Header row "))
.and_then(|s| s.parse().ok())
})
.unwrap_or(1);
for row in header + 1..=table.rows.len() {
if table.rows[row - 1].iter().all(|c| c.text.trim().is_empty()) {
continue;
};
}
if !represented.insert(row) {
continue;
}
@ -132,13 +154,57 @@ fn preview_rows(a: &Analysis, table: Option<&Table>) -> Vec<PreviewRow> {
.map(|(i, _)| i)
.collect(),
decisions: String::new(),
kind: a
.rundown
.as_ref()
.and_then(|r| {
if r.gaps
.iter()
.any(|g| g.source_rows.iter().any(|s| s.row == row))
{
return Some("Gap · no timer".into());
}
r.entries
.iter()
.find(|e| e.source_rows.iter().skip(1).any(|s| s.row == row))
.map(|e| format!("Note for row {}", e.source_rows[0].row))
})
.unwrap_or_else(|| "Source row · not a timer".into()),
});
}
}
if let Some(rundown) = &a.rundown {
for row in &mut rows {
if let Some(gap) = rundown
.gaps
.iter()
.find(|g| g.source_rows.iter().any(|s| s.row == row.row))
{
row.start = gap.start_ms.map(display).unwrap_or_else(|| "?".into());
row.end = gap.end_ms.map(display).unwrap_or_else(|| "?".into());
row.duration = "—".into();
}
}
}
rows.sort_by_key(|r| r.row);
rows
}
fn ignored_row(row: usize, table: Option<&Table>, profile: &Profile) -> bool {
profile.row_kinds.get(&row).is_some_and(|k| k == "ignore")
|| table.is_some_and(|t| {
row > 0 && row <= t.rows.len() && !detect::has_content(t, row - 1, profile)
})
}
fn show_row(row: &PreviewRow, filter: RowFilter, table: Option<&Table>, profile: &Profile) -> bool {
match filter {
RowFilter::All => true,
RowFilter::Included => !ignored_row(row.row, table, profile),
RowFilter::Attention => !row.issues.is_empty(),
}
}
impl App {
pub(super) fn decisions_changed(&mut self) {
self.dirty = true;
@ -147,13 +213,6 @@ impl App {
self.status = "Decisions changed; apply and recheck".into();
}
fn issue_rows(&self) -> BTreeSet<usize> {
self.analysis
.as_ref()
.map(|a| a.diagnostics.iter().filter_map(diagnostic_row).collect())
.unwrap_or_default()
}
fn choose_issue(&mut self, index: usize) {
self.issue_index = index;
let row = self
@ -163,6 +222,13 @@ impl App {
.and_then(diagnostic_row);
self.selected_row = row;
self.jump_row = row;
if let Some(row) = row {
let profile: Profile = serde_json::from_str(&self.profile).unwrap_or_default();
let table = self.tables.iter().find(|t| t.name == self.sheet);
if self.row_filter == RowFilter::Included && ignored_row(row, table, &profile) {
self.row_filter = RowFilter::All;
}
}
}
pub(super) fn review(&mut self, ui: &mut egui::Ui) {
@ -191,11 +257,10 @@ impl App {
});
}
ui.horizontal_wrapped(|ui| {
ui.selectable_value(&mut self.review_view, ReviewView::Rows, "Resolve rows");
ui.selectable_value(
&mut self.review_view,
ReviewView::Preview,
"Schedule preview",
ReviewView::Rows,
"Schedule & corrections",
);
ui.selectable_value(&mut self.review_view, ReviewView::Columns, "Columns");
if ui.button("Resolutions…").clicked() {
@ -204,27 +269,7 @@ impl App {
});
ui.separator();
match self.review_view {
ReviewView::Rows => {
self.issue_navigator(ui);
self.resolution_rows(ui);
}
ReviewView::Preview => {
if self.dirty {
ui.label(
"Previous analysis. Apply & recheck to see your changes in this schedule.",
);
} else if self
.analysis
.as_ref()
.is_some_and(|a| !a.diagnostics.is_empty())
{
ui.label("Draft schedule: highlighted rows need attention before export.");
}
egui::ScrollArea::both()
.id_salt("schedule_preview_scroll")
.auto_shrink([false, false])
.show(ui, |ui| self.schedule_preview(ui));
}
ReviewView::Rows => self.schedule_preview(ui),
ReviewView::Columns => {
egui::ScrollArea::vertical()
.id_salt("columns_scroll")
@ -324,198 +369,6 @@ impl App {
ui.add_space(4.0);
}
fn resolution_rows(&mut self, ui: &mut egui::Ui) {
ui.spacing_mut().item_spacing.y = 4.0;
let Some(table) = self.tables.iter().find(|t| t.name == self.sheet) else {
return;
};
let Ok(mut profile) = serde_json::from_str::<Profile>(&self.profile) else {
ui.label(
"The profile is not valid JSON. Open Columns to correct it or load a resolution.",
);
return;
};
let before = serde_json::to_string(&profile).unwrap();
let (mapping, evidence) = detect::inspect(table, &profile);
let header = profile
.header_row
.or_else(|| {
evidence
.first()
.and_then(|s| s.strip_prefix("Header row "))
.and_then(|s| s.parse().ok())
})
.unwrap_or(1)
.clamp(1, table.rows.len().max(1));
let title_col = mapping.as_ref().ok().map(|m| m.title).or_else(|| {
self.analysis
.as_ref()
.and_then(|a| a.mapping.as_ref().map(|m| m.title))
});
let issue_rows: BTreeSet<_> = self
.issue_rows()
.into_iter()
.filter(|r| *r > header && *r <= table.rows.len())
.collect();
let filter = self.issues_only && !issue_rows.is_empty();
let rows: Vec<_> = (header + 1..=table.rows.len())
.filter(|r| !filter || issue_rows.contains(r))
.collect();
ui.horizontal(|ui| {
ui.selectable_value(&mut self.issues_only, false, "All rows");
ui.add_enabled_ui(!issue_rows.is_empty(), |ui| {
ui.selectable_value(
&mut self.issues_only,
true,
format!("Needs attention ({})", issue_rows.len()),
);
});
ui.label(format!("{} shown", rows.len()));
});
let spacing = ui.spacing().item_spacing.x;
let summary_width =
(ui.available_width() - 40.0 - 100.0 - 105.0 - spacing * 3.0 - 14.0).max(90.0);
ui.horizontal(|ui| {
for (label, width) in [
("Row", 40.0),
("Source contents", summary_width),
("Meaning", 100.0),
("Duration", 105.0),
] {
ui.allocate_ui_with_layout(
egui::vec2(width, 22.0),
egui::Layout::left_to_right(egui::Align::Center),
|ui| {
ui.set_min_width(width);
ui.strong(label);
},
);
}
});
let row_height = 36.0;
let mut scroll = egui::ScrollArea::vertical()
.id_salt("resolve_rows")
.auto_shrink([false, false]);
if let Some(row) = self.jump_row.take()
&& let Some(index) = rows.iter().position(|r| *r == row)
{
scroll = scroll
.vertical_scroll_offset(index as f32 * (row_height + ui.spacing().item_spacing.y));
}
scroll.show_rows(ui, row_height, rows.len(), |ui, range| {
for index in range {
let number = rows[index];
ui.push_id(number, |ui| {
let selected = self.selected_row == Some(number);
let (rect, _) = ui.allocate_exact_size(
egui::vec2(ui.available_width(), row_height),
egui::Sense::hover(),
);
let fill = if selected {
Color32::from_rgb(51, 44, 80)
} else if index % 2 == 0 {
Color32::from_rgb(30, 32, 37)
} else {
Color32::TRANSPARENT
};
ui.painter().rect_filled(rect, 3.0, fill);
ui.scope_builder(
egui::UiBuilder::new()
.max_rect(rect)
.layout(egui::Layout::left_to_right(egui::Align::Center)),
|ui| {
let label = if issue_rows.contains(&number) {
format!("{number} •")
} else {
number.to_string()
};
if ui
.add_sized(
[40.0, row_height],
egui::Button::new(label).frame(false),
)
.clicked()
{
self.selected_row = Some(number);
self.row_details = true;
}
let title = title_col
.map(|c| table.cell(number - 1, c).text)
.filter(|t| !t.trim().is_empty());
let contents = table.rows[number - 1]
.iter()
.enumerate()
.filter(|(_, c)| !c.text.trim().is_empty())
.map(|(i, c)| format!("{}: {}", column_name(i), c.text))
.collect::<Vec<_>>()
.join(" · ");
ui.allocate_ui_with_layout(
egui::vec2(summary_width, row_height),
egui::Layout::top_down(egui::Align::Min),
|ui| {
ui.set_min_width(summary_width);
ui.spacing_mut().item_spacing.y = 3.0;
if ui
.add(
egui::Label::new(title.as_deref().unwrap_or(&contents))
.truncate()
.sense(egui::Sense::click()),
)
.on_hover_text(&contents)
.clicked()
{
self.selected_row = Some(number);
self.row_details = true;
}
if title.is_some() {
ui.add(
egui::Label::new(
RichText::new(&contents).size(12.0).weak(),
)
.truncate(),
);
}
},
);
ui.allocate_ui_with_layout(
egui::vec2(100.0, row_height),
egui::Layout::left_to_right(egui::Align::Center),
|ui| {
ui.set_min_width(100.0);
Self::row_kind_control(ui, &mut profile, number);
},
);
let mut duration =
profile.durations.get(&number).cloned().unwrap_or_default();
if ui
.add(
egui::TextEdit::singleline(&mut duration)
.id_salt(("duration", number))
.desired_width(95.0)
.hint_text("e.g. 2 min"),
)
.on_hover_text(
"Explicit duration correction. Leave blank to use the source.",
)
.changed()
{
if duration.trim().is_empty() {
profile.durations.remove(&number);
} else {
profile.durations.insert(number, duration);
}
}
},
);
});
}
});
if before != serde_json::to_string(&profile).unwrap() {
self.profile = serde_json::to_string_pretty(&profile).unwrap();
self.decisions_changed();
}
}
fn row_kind_control(ui: &mut egui::Ui, profile: &mut Profile, number: usize) {
let mut kind = profile.row_kinds.get(&number).cloned().unwrap_or_default();
egui::ComboBox::from_id_salt(("kind", number))
@ -570,7 +423,7 @@ impl App {
.vscroll(true)
.show(ctx, |ui| {
ui.label(
"Original source values. Edit the row's meaning and duration in Resolve rows.",
"Original source values. Edit the row's meaning and duration in Schedule & corrections.",
);
for (c, cell) in cells
.iter()
@ -693,192 +546,278 @@ impl App {
}
fn schedule_preview(&mut self, ui: &mut egui::Ui) {
let Some(a) = &self.analysis else {
ui.label("Apply & recheck to update the schedule. Export is blocked until these decisions pass validation.");
ui.horizontal_wrapped(|ui| {
ui.selectable_value(&mut self.row_filter, RowFilter::All, "All rows");
ui.selectable_value(&mut self.row_filter, RowFilter::Included, "Included rows")
.on_hover_text("Includes events, notes, markers and breaks. Excludes ignored rows and rows containing only ignored columns.");
ui.selectable_value(&mut self.row_filter, RowFilter::Attention, "Needs attention");
let count = self.analysis.as_ref().map_or(0, |a| a.diagnostics.len());
ui.toggle_value(&mut self.show_issue_details, format!("Issues ({count})"));
});
if self.show_issue_details {
self.issue_navigator(ui);
}
let Ok(mut profile) = serde_json::from_str::<Profile>(&self.profile) else {
ui.label("Correct the profile JSON in Columns before editing rows.");
return;
};
let before = serde_json::to_string(&profile).unwrap();
let Some(a) = &self.analysis else {
ui.label("Analyze the sheet to see the schedule and edit its rows.");
return;
};
ui.heading(format!("Schedule preview · {}", a.sheet));
ui.horizontal_wrapped(|ui| {
ui.colored_label(PREVIEW_AMBER, "Unresolved: missing information");
ui.colored_label(PREVIEW_RED, "Error: inconsistent or invalid data");
ui.colored_label(PREVIEW_AMBER, "Unresolved");
ui.colored_label(PREVIEW_RED, "Error");
ui.weak("Ignored");
ui.small("? unknown · * inferred · edits require recheck");
});
ui.label("Click a highlighted status to resolve it. ? means unknown; source-only rows are not timers.");
let table = self.tables.iter().find(|t| t.name == a.sheet);
let rows = preview_rows(a, table);
let all_rows = preview_rows(a, table);
let rows: Vec<_> = all_rows
.iter()
.filter(|r| show_row(r, self.row_filter, table, &profile))
.collect();
if rows.is_empty() {
ui.label(if self.row_filter == RowFilter::Attention {
"No source rows need attention. Sheet or gap issues, if any, are available under Issues."
} else { "No rows match this filter. Choose All rows to review exclusions." });
}
let compact = ui.available_width() < 760.0;
let title_width = if compact {
(ui.available_width() - 300.0).clamp(180.0, 320.0)
} else {
(ui.available_width() - 370.0).clamp(240.0, 450.0)
};
let jump = self.jump_row;
let mut jump_visible = !rows.iter().any(|r| Some(r.row) == jump);
let mut jump_offset = None;
let mut resolve = None;
let mut details = None;
let backgrounds: Vec<_> = std::iter::once(None)
.chain(rows.iter().map(|row| {
if row
if ignored_row(row.row, table, &profile) {
Some(Color32::from_rgb(34, 35, 39))
} else if row
.issues
.iter()
.any(|i| !needs_information(&a.diagnostics[*i]))
{
Some(Color32::from_rgb(58, 30, 33))
} else if row.source_only || !row.issues.is_empty() {
} else if !row.issues.is_empty() {
Some(Color32::from_rgb(52, 43, 27))
} else {
None
}
}))
.collect();
egui::Grid::new("schedule")
.with_row_color(move |row, style| {
backgrounds
.get(row)
.copied()
.flatten()
.or_else(|| (row > 0 && row % 2 == 0).then_some(style.visuals.faint_bg_color))
})
.show(ui, |ui| {
for label in [
"Row",
"Start",
"End",
"Duration",
"Title / source contents",
"Status",
] {
ui.strong(label);
}
ui.end_row();
for row in &rows {
let error = row
.issues
.iter()
.any(|i| !needs_information(&a.diagnostics[*i]));
let color = if error {
PREVIEW_RED
} else if row.source_only || !row.issues.is_empty() {
PREVIEW_AMBER
let mut scroll = egui::ScrollArea::both()
.id_salt("merged_schedule")
.auto_shrink([false, false]);
if let Some(offset) = self.review_scroll.take() {
scroll = scroll.vertical_scroll_offset(offset);
}
scroll.show(ui, |ui| {
let content_top = ui.min_rect().top();
egui::Grid::new("schedule")
.spacing(egui::vec2(10.0, 12.0))
.with_row_color(move |row, style| {
backgrounds.get(row).copied().flatten().or_else(|| {
(row > 0 && row % 2 == 0).then_some(style.visuals.faint_bg_color)
})
})
.show(ui, |ui| {
ui.strong("Row");
if compact {
ui.strong("Timing");
} else {
ui.visuals().text_color()
};
for text in [
row.row.to_string(),
row.start.clone(),
row.end.clone(),
row.duration.clone(),
] {
ui.colored_label(color, text);
for label in ["Start", "End", "Duration"] {
ui.strong(label);
}
}
ui.vertical(|ui| {
ui.set_width(260.0);
if ui
.add(
egui::Label::new(RichText::new(short(&row.title, 80)).color(color))
.wrap()
.sense(egui::Sense::click()),
)
.on_hover_text(&row.title)
.clicked()
{
ui.strong("Title, source contents & issues");
ui.strong("Corrections");
ui.end_row();
for row in &rows {
let ignored = ignored_row(row.row, table, &profile);
let error = row
.issues
.iter()
.any(|i| !needs_information(&a.diagnostics[*i]));
let color = if ignored {
ui.visuals().weak_text_color()
} else if error {
PREVIEW_RED
} else if !row.issues.is_empty() {
PREVIEW_AMBER
} else {
ui.visuals().text_color()
};
let response = ui.add(
egui::Label::new(RichText::new(row.row.to_string()).color(color))
.sense(egui::Sense::click()),
);
if response.clicked() {
details = Some(row.row);
}
if row.source_only {
ui.small("Source row · not a timer");
if jump == Some(row.row) {
jump_visible = ui.clip_rect().contains_rect(response.rect);
jump_offset = Some(
(response.rect.center().y
- content_top
- ui.clip_rect().height() / 2.0)
.max(0.0),
);
}
if let Some(index) = row.issues.first() {
let message = a.diagnostics[*index]
.message
.split("\nRow preview:")
.next()
.unwrap_or_default();
ui.label(RichText::new(short(message, 95)).small().color(color))
.on_hover_text(message);
if compact {
ui.vertical(|ui| {
ui.set_width(105.0);
for (label, value) in [
("Start", &row.start),
("End", &row.end),
("Dur.", &row.duration),
] {
ui.colored_label(color, format!("{label} {value}"));
}
});
} else {
for value in [&row.start, &row.end, &row.duration] {
ui.colored_label(color, value);
}
}
});
if row.issues.is_empty() {
ui.label(if row.source_only {
"Unresolved"
} else if row.duration == "Marker" {
"Marker"
} else {
"Timed"
})
.on_hover_text(&row.decisions);
} else {
let index = row
.issues
.iter()
.find(|i| !needs_information(&a.diagnostics[**i]))
.unwrap_or(&row.issues[0]);
let label = if error {
"Error · resolve"
} else {
"Unresolved · resolve"
};
let explanation = row
.issues
.iter()
.map(|i| {
format!(
"{} — {}\n{}",
a.diagnostics[*i].code,
a.diagnostics[*i].location,
a.diagnostics[*i].message
ui.vertical(|ui| {
ui.set_width(title_width);
if ui
.add(
egui::Label::new(RichText::new(&row.title).color(color))
.wrap()
.sense(egui::Sense::click()),
)
})
.collect::<Vec<_>>()
.join("\n\n");
if ui
.button(RichText::new(label).color(color))
.on_hover_text(explanation)
.clicked()
{
resolve = Some(*index);
}
.on_hover_text("Open all original cells")
.clicked()
{
details = Some(row.row);
}
let status = if ignored {
"Ignored"
} else if row.source_only {
&row.kind
} else if row.kind == "marker" {
"Marker"
} else {
"Timed"
};
ui.small(RichText::new(status).color(color))
.on_hover_text(&row.decisions);
if let Some(table) = table {
let contents = table
.rows
.get(row.row.saturating_sub(1))
.map(|cells| {
cells
.iter()
.enumerate()
.filter(|(_, c)| {
!c.text.trim().is_empty() && c.text != row.title
})
.map(|(col, c)| {
format!("{}: {}", column_name(col), c.text)
})
.collect::<Vec<_>>()
.join(" · ")
})
.unwrap_or_default();
if !contents.is_empty() {
ui.label(
RichText::new(short(&contents, 220))
.size(12.0)
.color(color),
)
.on_hover_text(contents);
}
}
if !row.issues.is_empty() {
let index = row
.issues
.iter()
.find(|i| !needs_information(&a.diagnostics[**i]))
.unwrap_or(&row.issues[0]);
let d = &a.diagnostics[*index];
let message =
d.message.split("\nRow preview:").next().unwrap_or_default();
ui.label(RichText::new(short(message, 140)).small().color(color))
.on_hover_text(message);
if ui
.small_button(
RichText::new(if error {
"Error · details"
} else {
"Unresolved · details"
})
.color(color),
)
.clicked()
{
resolve = Some(*index);
}
}
});
ui.vertical(|ui| {
ui.set_width(105.0);
ui.push_id(("schedule_kind", row.row), |ui| {
Self::row_kind_control(ui, &mut profile, row.row)
});
let mut duration =
profile.durations.get(&row.row).cloned().unwrap_or_default();
if ui
.add(
egui::TextEdit::singleline(&mut duration)
.id_salt(("schedule_duration", row.row))
.desired_width(95.0)
.hint_text("e.g. 2 min"),
)
.on_hover_text("Duration correction; blank uses the source value")
.changed()
{
if duration.trim().is_empty() {
profile.durations.remove(&row.row);
} else {
profile.durations.insert(row.row, duration);
}
}
});
ui.end_row();
}
ui.end_row();
});
if let Some(r) = &a.rundown {
for g in &r.gaps {
ui.label(format!(
"Gap: {} → {} · {} (no timer)",
g.start_ms.map(display).unwrap_or("?".into()),
g.end_ms.map(display).unwrap_or("?".into()),
g.title
));
}
});
ui.small("* Inferred start. Hover Timed for timing decisions. Highlighted rows retain their original position.");
// Sheet-level and gap diagnostics must remain reachable even without a source-row address.
for (i, d) in a
.diagnostics
.iter()
.enumerate()
.filter(|(i, _)| !rows.iter().any(|r| r.issues.contains(i)))
{
let color = if needs_information(d) {
PREVIEW_AMBER
} else {
PREVIEW_RED
};
if ui
.button(
RichText::new(format!("{} · {} · resolve", d.code, d.location)).color(color),
)
.on_hover_text(&d.message)
.clicked()
{
resolve = Some(i);
}
}
if let Some(r) = &a.rundown {
for g in &r.gaps {
ui.label(format!(
"Gap: {} → {} · {} (no timer)",
g.start_ms.map(display).unwrap_or("?".into()),
g.end_ms.map(display).unwrap_or("?".into()),
g.title
));
}
});
if jump_visible {
self.jump_row = None;
} else {
self.review_scroll = jump_offset;
ui.ctx().request_repaint();
}
if let Some(index) = resolve {
let stage = a.diagnostics[index].stage;
let header = a.mapping.as_ref().map_or(1, |m| m.header_row);
self.choose_issue(index);
self.review_view = if stage == 1 && self.selected_row.is_none_or(|r| r <= header) {
ReviewView::Columns
} else {
ReviewView::Rows
};
self.show_issue_details = true;
}
if let Some(row) = details {
self.selected_row = Some(row);
self.row_details = true;
}
if before != serde_json::to_string(&profile).unwrap() {
self.profile = serde_json::to_string_pretty(&profile).unwrap();
self.decisions_changed();
}
}
}
@ -997,15 +936,13 @@ mod tests {
#[test]
fn compact_review_keeps_corrections_visible_and_clickable() {
let mut app = sample();
app.row_filter = RowFilter::Attention;
let ctx = egui::Context::default();
configure_style(&ctx);
render(&mut app, &ctx, [560.0, 400.0], vec![]);
let labels = render(&mut app, &ctx, [560.0, 400.0], vec![]);
let visible_rows = labels.iter().filter(|(s, _)| s.ends_with(" •")).count();
assert!(
visible_rows >= 4,
"Only {visible_rows} source rows visible in compact review"
);
assert!(labels.iter().any(|(s, _)| s == "Stage direction 0"));
assert!(labels.iter().any(|(s, _)| s == "Start ?"));
assert!(labels.iter().any(|(s, _)| s == "Apply & recheck"));
let auto = labels.iter().find(|(s, _)| s == "Auto").unwrap().1.center();
click(&mut app, &ctx, auto);
@ -1030,7 +967,7 @@ mod tests {
render(&mut app, &ctx, [560.0, 400.0], vec![]);
let labels = render(&mut app, &ctx, [560.0, 400.0], vec![]);
assert!(
labels.iter().any(|(s, _)| s == "11 •"),
labels.iter().any(|(s, _)| s == "11"),
"Issue navigation should reveal its row"
);
app.row_details = true;
@ -1038,7 +975,7 @@ mod tests {
app.row_details = false;
app.review_view = ReviewView::Columns;
render(&mut app, &ctx, [560.0, 400.0], vec![]);
app.review_view = ReviewView::Preview;
app.review_view = ReviewView::Rows;
render(&mut app, &ctx, [560.0, 400.0], vec![]);
}
@ -1056,6 +993,7 @@ mod tests {
);
}
let mut app = sample();
app.show_issue_details = true;
app.analysis.as_mut().unwrap().diagnostics = vec![Diagnostic::new(
1,
"AMBIGUOUS_COLUMN",
@ -1131,14 +1069,14 @@ mod tests {
2,
"Preview must not invent IR events"
);
app.review_view = ReviewView::Preview;
app.review_view = ReviewView::Rows;
let ctx = egui::Context::default();
configure_style(&ctx);
render(&mut app, &ctx, [860.0, 900.0], vec![]);
let labels = render(&mut app, &ctx, [860.0, 900.0], vec![]);
let resolve = labels
.iter()
.find(|(s, _)| s == "Unresolved · resolve")
.find(|(s, _)| s == "Unresolved · details")
.unwrap()
.1
.center();
@ -1158,21 +1096,24 @@ mod tests {
};
let a = pipeline::analyze(table, &profile, &AtomicBool::new(false), |_, _| {});
let rows = preview_rows(&a, Some(table));
assert_eq!(rows.len(), 2);
assert!(!rows[1].source_only);
assert_eq!(rows.iter().filter(|r| !r.source_only).count(), 2);
assert_eq!(rows.len(), 14);
assert!(!rows.last().unwrap().source_only);
assert!(
rows[1]
rows.last()
.unwrap()
.issues
.iter()
.any(|i| !needs_information(&a.diagnostics[*i]))
);
app.analysis = Some(a);
app.review_view = ReviewView::Preview;
app.row_filter = RowFilter::Attention;
app.review_view = ReviewView::Rows;
let ctx = egui::Context::default();
configure_style(&ctx);
render(&mut app, &ctx, [860.0, 900.0], vec![]);
let labels = render(&mut app, &ctx, [860.0, 900.0], vec![]);
assert!(labels.iter().any(|(s, _)| s == "Error · resolve"));
assert!(labels.iter().any(|(s, _)| s == "Error · details"));
app.tables[0].rows[1][0].text = "invalid clock".into();
let a = pipeline::analyze(&app.tables[0], &profile, &AtomicBool::new(false), |_, _| {});
assert!(a.rundown.is_none());
@ -1182,4 +1123,65 @@ mod tests {
assert_eq!(rows[0].start, "?");
assert!(!needs_information(&a.diagnostics[rows[0].issues[0]]));
}
#[test]
fn filters_keep_notes_and_restore_ignored_rows_after_recheck() {
let mut app = sample();
let profile = Profile {
row_kinds: [(3, "ignore".into()), (4, "note".into())]
.into_iter()
.collect(),
..Default::default()
};
let a = pipeline::analyze(&app.tables[0], &profile, &AtomicBool::new(false), |_, _| {});
let rows = preview_rows(&a, Some(&app.tables[0]));
let numbers = |filter| {
rows.iter()
.filter(|r| show_row(r, filter, Some(&app.tables[0]), &profile))
.map(|r| r.row)
.collect::<Vec<_>>()
};
assert_eq!(numbers(RowFilter::All), (2..=15).collect::<Vec<_>>());
assert!(!numbers(RowFilter::Included).contains(&3));
assert!(numbers(RowFilter::Included).contains(&4));
assert!(!numbers(RowFilter::Attention).contains(&4));
assert!(numbers(RowFilter::Attention).contains(&5));
assert_eq!(
rows.iter().find(|r| r.row == 4).unwrap().kind,
"Note for row 2"
);
app.profile = serde_json::to_string(&profile).unwrap();
app.analysis = Some(a);
app.row_filter = RowFilter::All;
let ctx = egui::Context::default();
configure_style(&ctx);
render(&mut app, &ctx, [860.0, 900.0], vec![]);
let labels = render(&mut app, &ctx, [860.0, 900.0], vec![]);
assert!(labels.iter().any(|(s, _)| s == "Stage direction 0"));
let ignore = labels
.iter()
.find(|(s, _)| s == "ignore")
.unwrap()
.1
.center();
click_size(&mut app, &ctx, ignore, [860.0, 900.0]);
let menu = render(&mut app, &ctx, [860.0, 900.0], vec![]);
let auto = menu
.iter()
.rev()
.find(|(s, _)| s == "Auto")
.unwrap()
.1
.center();
click_size(&mut app, &ctx, auto, [860.0, 900.0]);
let restored: Profile = serde_json::from_str(&app.profile).unwrap();
assert!(!restored.row_kinds.contains_key(&3));
assert!(!ignored_row(3, Some(&app.tables[0]), &restored));
assert!(app.dirty);
let mut columns_ignored = Profile::default();
columns_ignored
.column_usage
.insert("C".into(), "ignore".into());
assert!(ignored_row(3, Some(&app.tables[0]), &columns_ignored));
assert!(!ignored_row(2, Some(&app.tables[0]), &columns_ignored));
}
}

View File

@ -256,6 +256,9 @@ errors must remain visible with direct corrective actions.
issue at a time, row navigation/filtering, a full-height correction table and
separate saved-resolution controls. Preserve pending edits and previous results
until recheck; verify compact layout and dropdown interaction.
- [x] Merge schedule preview and row corrections with All rows / Included rows /
Needs attention filters, preserving ignored rows for restoration and displaying
attached notes individually without duplicating their timers.
- [ ] Add recent-file persistence, direct start/end/title editing and
comprehensive native GUI interaction checks.
- [ ] Inventory supplied examples by format/layout; record intended interpretations

View File

@ -33,21 +33,22 @@ directories must already exist. Exit codes: 0 success, 1 read/profile/write fail
CLI logs are plain text on stderr; JSON results go to stdout.
In the desktop app, choose or drop one file, read its sheets, select a sheet and
click **Analyze rundown**. Review has three focused views:
click **Analyze rundown**. Review has two views:
- **Resolve rows** shows one issue at a time with previous/next buttons and an
issue picker. **Needs attention** filters to affected source rows; **All rows**
restores the full list. Selecting an issue brings its row into view. The table
fills the available space and keeps its column headings visible while scrolling.
Choose a row meaning or enter a duration with units, such as `2 min`. Click a
row number/title or **Full row…** to read all original cells with their headers.
- **Schedule preview** combines timed entries and unresolved source rows in their
original order. Amber rows need clarification; red rows contain invalid or
inconsistent data. Text status labels accompany the colors. Source-only rows
are explicitly not timers, and unknown values show `?`. Hover an issue for its
full explanation or click its status to resolve it. Click a title for original
cells. Sheet-level and gap issues remain listed beneath the table. Draft and
out-of-date schedules are labeled; they cannot be exported.
- **Schedule & corrections** combines the schedule preview and row editing in one
table. Start/end/duration, source contents, colored issues, row meaning and
duration corrections are visible together. **All rows** includes ignored rows;
**Included rows** hides ignored rows and rows containing only ignored columns,
while keeping notes, markers and breaks; **Needs attention** shows rows with
diagnostics from the last analysis. Ignored rows can be restored using All rows.
Notes attached to another event keep their own source row and identify their
parent timer instead of duplicating it. Amber means unresolved, red means an
error, and gray means ignored. Unknown values show `?`.
Click a row number/title to read all original cells. **Issues** opens the issue
navigator, including sheet-level and gap errors; row issue buttons open the
relevant explanation. The table fills the remaining space. On narrow windows,
timing values stack so corrections remain accessible. Changes require recheck;
the timing preview and diagnostics continue to show the previous analysis.
- **Columns** shows inference evidence, per-column role dropdowns, and sample
values. Selecting one duration column explicitly resolves duplicate TIMER
headers. **Metadata** keeps a column as Ontime notes without treating its values