diff --git a/linux/changelog.d/4131.added.md b/linux/changelog.d/4131.added.md new file mode 100644 index 0000000000..1ddb1e1b3c --- /dev/null +++ b/linux/changelog.d/4131.added.md @@ -0,0 +1 @@ +Row Details marks foreign key fields and announces their key roles to screen readers. diff --git a/linux/crates/app/src/ui/data_grid/references/mod.rs b/linux/crates/app/src/ui/data_grid/references/mod.rs index a5203f1b90..8b8cb14a99 100644 --- a/linux/crates/app/src/ui/data_grid/references/mod.rs +++ b/linux/crates/app/src/ui/data_grid/references/mod.rs @@ -90,10 +90,9 @@ pub fn refresh_actions(grid: &DataGrid, target: Option<&Resolved>) { } impl DataGrid { - /// The table's foreign keys were read: Ctrl+J follows what they - /// offer now. pub(crate) fn keys_changed(&self) { self.refresh_actions(); + self.imp().detail_pane.redraw_fields(); } /// Fill the cell menu's key items for `cell` as the menu opens; a row @@ -201,6 +200,19 @@ fn add_choice(grid: &DataGrid, name: &str, act: impl Fn(&DataGrid, usize) + 'sta grid.actions().add_action(&action); } +impl DataGrid { + pub(crate) fn is_foreign_key_column(&self, name: &str) -> bool { + self.config() + .and_then(|config| config.references.as_ref()) + .map(KeysHandle::get) + .is_some_and(|keys| { + keys.outbound + .iter() + .any(|outbound| outbound.key.columns.iter().any(|column| column == name)) + }) + } +} + /// What `row` offers from `column`, under the keys read so far. A grid /// that was given no keys offers nothing. fn offers(grid: &DataGrid, row: &GridRow, column: usize) -> Offers { diff --git a/linux/crates/app/src/ui/data_grid/row_detail/fields.rs b/linux/crates/app/src/ui/data_grid/row_detail/fields.rs index ce300f2e15..d112d56f8c 100644 --- a/linux/crates/app/src/ui/data_grid/row_detail/fields.rs +++ b/linux/crates/app/src/ui/data_grid/row_detail/fields.rs @@ -68,8 +68,8 @@ fn is_primary_key(column: &GridColumn) -> bool { column.catalog.as_ref().is_some_and(|catalog| catalog.primary_key) } -// The key has no role of its own, so the label is where a screen reader hears it. -pub(super) fn field_label(column: &GridColumn) -> String { +// Markers have no role of their own, so the label names both key roles. +pub(super) fn field_label(column: &GridColumn, foreign: bool) -> String { let mut parts = vec![column.name.clone()]; let type_name = &column.value_type().name; if !type_name.is_empty() { @@ -78,6 +78,9 @@ pub(super) fn field_label(column: &GridColumn) -> String { if is_primary_key(column) { parts.push(gettext("primary key")); } + if foreign { + parts.push(gettext("foreign key")); + } parts.join(", ") } @@ -281,7 +284,7 @@ impl RowDetailPane { factory } - pub(super) fn redraw_fields(&self) { + pub(in crate::ui::data_grid) fn redraw_fields(&self) { self.refilter_fields(); let bound: Vec = self.imp().bound.borrow().clone(); for item in &bound { @@ -328,7 +331,11 @@ impl RowDetailPane { if wanted.is_empty() || column.name.to_lowercase().contains(&wanted) { return true; } - let value = field_value(&grid.tracked(), &row, &column); + let Some(config) = grid.config() else { + return false; + }; + let preferences = config.settings.grid_preferences().snapshot(); + let value = field_value(&grid.tracked(), &row, &column, &preferences.null_display); !value.null && value.text.to_lowercase().contains(&wanted) } @@ -352,10 +359,20 @@ impl RowDetailPane { else { return; }; - key.set_visible(is_primary_key(&column)); + let primary = is_primary_key(&column); + let foreign = grid.is_foreign_key_column(&column.name); + key.set_visible(primary || foreign); + key.set_icon_name(Some(if primary { icons::PRIMARY_KEY } else { icons::GO_UP })); + let key_tip = match (primary, foreign) { + (true, true) => Some(gettext("Primary and foreign key")), + (true, false) => Some(gettext("Primary key")), + (false, true) => Some(gettext("Foreign key")), + (false, false) => None, + }; + key.set_tooltip_text(key_tip.as_deref()); name.set_label(&column.name); kind.set_label(&column.value_type().name); - item.set_accessible_label(&field_label(&column)); + item.set_accessible_label(&field_label(&column, foreign)); let Some(row) = self.current_row() else { edited.set_visible(false); shown.set_text(None); diff --git a/linux/crates/app/src/ui/data_grid/row_detail/tests.rs b/linux/crates/app/src/ui/data_grid/row_detail/tests.rs index a2db47283c..cbecb66443 100644 --- a/linux/crates/app/src/ui/data_grid/row_detail/tests.rs +++ b/linux/crates/app/src/ui/data_grid/row_detail/tests.rs @@ -1642,7 +1642,139 @@ fn a_field_names_its_type_and_its_key_to_a_screen_reader() { catalog: None, ..column_of(named("id", "integer", true)) }; - assert_eq!(field_label(&result_column), "id, integer"); + assert_eq!(field_label(&result_column, false), "id, integer"); +} + +fn composite_foreign_keys() -> crate::ui::data_grid::TableKeys { + use tablepro_core::ForeignKeyInfo; + use tablepro_core::ddl::OutboundForeignKey; + use tablepro_core::meta::TableRef; + + crate::ui::data_grid::TableKeys { + table: TableRef::unqualified("orders"), + outbound: vec![OutboundForeignKey { + key: ForeignKeyInfo { + name: "customer_fkey".to_owned(), + columns: vec!["id".to_owned(), "tenant_id".to_owned(), "customer_id".to_owned()], + ref_schema: None, + ref_table: "customers".to_owned(), + ref_columns: vec!["id".to_owned(), "tenant_id".to_owned(), "customer_id".to_owned()], + on_delete: None, + on_update: None, + }, + parent_compares_alike: true, + }], + inbound: Vec::new(), + } +} + +fn foreign_key_grid(keys: crate::ui::data_grid::TableKeys) -> (Grid, RowDetailPane, crate::ui::data_grid::KeysHandle) { + let handle = crate::ui::data_grid::KeysHandle::new(keys.table.clone()); + handle.set(keys); + let grid = Grid::build( + GridSpec { + references: Some(handle.clone()), + ..GridSpec::table(vec![ + named("id", "integer", true), + named("tenant_id", "integer", false), + named("customer_id", "integer", false), + named("note", "text", false), + ]) + }, + persisted(&[vec![ + Value::Int(1), + Value::Int(7), + Value::Int(42), + Value::Text("x".into()), + ]]), + ); + grid.activate("show-details"); + let pane = pane_of(&grid); + grid.focus(0, 1); + drain_main_context(); + (grid, pane, handle) +} + +#[gtk4::test] +fn foreign_key_fields_announce_each_role_and_keep_the_primary_key_icon() { + let (_grid, pane, _handle) = foreign_key_grid(composite_foreign_keys()); + let primary = crate::ui::icons::PRIMARY_KEY; + let foreign = crate::ui::icons::GO_UP; + assert!(marks(&pane, 0, primary)); + assert!(!marks(&pane, 0, foreign)); + assert_eq!( + drawn_field(&pane, 0).accessible_label().as_str(), + "id, integer, primary key, foreign key" + ); + for (column, label) in [ + (1, "tenant_id, integer, foreign key"), + (2, "customer_id, integer, foreign key"), + ] { + assert!(marks(&pane, column, foreign)); + assert!(!marks(&pane, column, primary)); + assert_eq!(drawn_field(&pane, column).accessible_label().as_str(), label); + } + assert!(!marks(&pane, 3, primary)); + assert!(!marks(&pane, 3, foreign)); + assert_eq!(drawn_field(&pane, 3).accessible_label().as_str(), "note, text"); + for column in 0..4 { + assert!(marks(&pane, column, crate::ui::icons::TEXT_X_GENERIC)); + } +} + +#[gtk4::test] +fn foreign_key_markers_follow_metadata_changes_without_disturbing_an_edit() { + let keys = composite_foreign_keys(); + let empty = crate::ui::data_grid::TableKeys::none(keys.table.clone()); + let (grid, pane, handle) = foreign_key_grid(empty.clone()); + let primary = crate::ui::icons::PRIMARY_KEY; + let foreign = crate::ui::icons::GO_UP; + assert!(!marks(&pane, 1, foreign)); + assert!(!marks(&pane, 2, foreign)); + edit_field(&grid, &pane, 0, 3); + type_value(&pane, "still typing"); + let focused = gtk::prelude::GtkWindowExt::focus(&grid.window); + let pending_before = grid.tracker.pending_count(); + + handle.set(keys); + grid.grid.keys_changed(); + drain_main_context(); + + assert!(marks(&pane, 1, foreign)); + assert!(marks(&pane, 2, foreign)); + assert!(marks(&pane, 0, primary)); + assert_eq!( + drawn_field(&pane, 0).accessible_label().as_str(), + "id, integer, primary key, foreign key" + ); + assert_eq!( + drawn_field(&pane, 2).accessible_label().as_str(), + "customer_id, integer, foreign key" + ); + assert_eq!(selected_field(&pane), Some(3)); + assert_eq!(pane.typed_text(), "still typing"); + assert_eq!(gtk::prelude::GtkWindowExt::focus(&grid.window), focused); + assert_eq!(grid.tracker.pending_count(), pending_before); + + handle.set(empty); + grid.grid.keys_changed(); + drain_main_context(); + + assert!(!marks(&pane, 1, foreign)); + assert!(!marks(&pane, 2, foreign)); + assert!(marks(&pane, 0, primary)); + assert_eq!( + drawn_field(&pane, 0).accessible_label().as_str(), + "id, integer, primary key" + ); + assert_eq!( + drawn_field(&pane, 2).accessible_label().as_str(), + "customer_id, integer" + ); + assert_eq!(selected_field(&pane), Some(3)); + assert_eq!(pane.typed_text(), "still typing"); + assert_eq!(gtk::prelude::GtkWindowExt::focus(&grid.window), focused); + assert_eq!(grid.tracker.pending_count(), pending_before); } #[gtk4::test]