From 93c87da195cd8cbb5c353f22366a2837c2677287 Mon Sep 17 00:00:00 2001 From: Oleksandr Kholiavko <43780952+HalavicH@users.noreply.github.com> Date: Mon, 28 Sep 2026 12:57:01 +0000 Subject: [PATCH] tabular_data_preview: Extract table component from the preview pane (#63752) ## TL;DR `TabularDataPreviewPane` did rendering, focus, engine, and settings all in one component. Extracted the table-rendering half into `TableView` (new `table_view.rs`), so the pane now owns tab/item concerns and just embeds `self.table: Entity` which allows the table to be reusable in other contexts (i.e. multiple tables per pane or rendering data from other sources like DB client). > NOTE: No behavior changes. Only refactoring ## Testing - `cargo check -p tabular_data_preview`, `./script/clippy` clean. - Tested manually: no UI/UX/performance regressions ## Self-Review Checklist: - [x] I've reviewed my own diff for quality, security, and reliability - [ ] Unsafe blocks (if any) have justifying comments - [x] UI standards followed - [ ] Tests cover the new/changed behavior - [x] Performance impact considered, acceptable Release Notes: - N/A --- crates/tabular_data_preview/src/parser.rs | 22 +- .../renderer/performance_metrics_overlay.rs | 6 +- .../src/renderer/preview_view.rs | 38 +-- .../src/renderer/render_table.rs | 36 +- .../src/renderer/row_identifiers.rs | 31 +- .../src/renderer/settings.rs | 16 +- .../src/renderer/table_cell.rs | 8 +- .../src/renderer/table_header.rs | 20 +- crates/tabular_data_preview/src/settings.rs | 4 +- crates/tabular_data_preview/src/table_view.rs | 214 ++++++++++++ .../src/tabular_data_preview.rs | 315 ++++++------------ 11 files changed, 388 insertions(+), 322 deletions(-) create mode 100644 crates/tabular_data_preview/src/table_view.rs diff --git a/crates/tabular_data_preview/src/parser.rs b/crates/tabular_data_preview/src/parser.rs index 9c691d03b36..d272d088c49 100644 --- a/crates/tabular_data_preview/src/parser.rs +++ b/crates/tabular_data_preview/src/parser.rs @@ -78,6 +78,8 @@ impl TabularDataPreviewPane { ) { let editor = self.active_editor_state.editor.clone(); self.is_parsing = true; + self.table + .update(cx, |table, cx| table.set_loading(true, cx)); self.parsing_task = Some(self.parse_in_background(wait_for_debounce, editor, cx)); } @@ -148,17 +150,14 @@ impl TabularDataPreviewPane { let parse_end_time: Instant = Instant::now(); log::debug!("Parsed data in {}ms", parse_duration.as_millis()); view.update(cx, move |view, cx| { - view.performance_metrics - .timings - .insert("Parsing", (parse_duration, Instant::now())); - view.last_parse_end_time = Some(parse_end_time); view.is_parsing = false; let parsed_contents = match parsed_contents { Ok(contents) => contents, Err(error) => { view.parse_error = Some(format!("{error:#}").into()); - view.filter_sort_task = None; + view.table + .update(cx, |table, cx| table.set_loading(false, cx)); cx.notify(); return; } @@ -166,11 +165,14 @@ impl TabularDataPreviewPane { log::debug!("Parsed {} rows", parsed_contents.rows.len()); view.parse_error = None; - view.engine.set_contents(parsed_contents); - view.list_state - .reset_with_uniform_height(0, view.row_height); - view.sync_column_widths(cx); - view.apply_filter_sort(cx); + view.table.update(cx, |table, cx| { + table + .performance_metrics + .timings + .insert("Parsing", (parse_duration, Instant::now())); + // `set_contents` recomputes filters/widths/mapping and clears the loading state. + table.set_contents(parsed_contents, cx); + }); cx.notify(); }) }) diff --git a/crates/tabular_data_preview/src/renderer/performance_metrics_overlay.rs b/crates/tabular_data_preview/src/renderer/performance_metrics_overlay.rs index 4d0b5bf4139..7e4af61a274 100644 --- a/crates/tabular_data_preview/src/renderer/performance_metrics_overlay.rs +++ b/crates/tabular_data_preview/src/renderer/performance_metrics_overlay.rs @@ -5,13 +5,11 @@ use ui::{ActiveTheme, Context, IntoElement, ParentElement, Styled, StyledTypography, div}; -use crate::{PerformanceMetrics, TabularDataPreviewPane}; +use crate::{PerformanceMetrics, TableView}; -impl TabularDataPreviewPane { +impl TableView { /// Renders a semi-transparent performance metrics overlay in the bottom-right corner. - /// /// Shows parsing duration for debugging and performance monitoring. - /// The overlay is positioned absolutely and styled with reduced opacity. pub(crate) fn render_performance_metrics_overlay( &mut self, cx: &mut Context, diff --git a/crates/tabular_data_preview/src/renderer/preview_view.rs b/crates/tabular_data_preview/src/renderer/preview_view.rs index 505b18aea6b..e60a4e36e00 100644 --- a/crates/tabular_data_preview/src/renderer/preview_view.rs +++ b/crates/tabular_data_preview/src/renderer/preview_view.rs @@ -1,20 +1,10 @@ -use std::time::Instant; - use ui::{SpinnerLabel, div, prelude::*}; -use crate::TabularDataPreviewPane; +use crate::TableView; use super::settings::settings_popover_menu; -impl TabularDataPreviewPane { - fn is_ready_to_render_content(&self) -> bool { - !self.is_parsing - && self.parse_error.is_none() - && (self.engine.contents.number_of_cols > 0 || !self.engine.contents.rows.is_empty()) - } -} - -impl Render for TabularDataPreviewPane { +impl Render for TableView { fn render(&mut self, window: &mut Window, cx: &mut Context) -> impl IntoElement { let theme = cx.theme(); let row_height = window.pixel_snap(window.line_height()); @@ -26,14 +16,14 @@ impl Render for TabularDataPreviewPane { // item's prior size as a hint rather than dropping straight to a fresh guess. self.list_state.remeasure(); } - let render_prep_start = Instant::now(); + let render_prep_start = std::time::Instant::now(); let table_with_settings = v_flex() .size_full() .bg(theme.colors().editor_background) .track_focus(&self.focus_handle) .child({ - let is_parsing = self.is_parsing; - if !self.is_ready_to_render_content() { + let is_loading = self.is_loading; + if is_loading || self.engine.contents.number_of_cols == 0 { v_flex() .size_full() .child( @@ -54,7 +44,7 @@ impl Render for TabularDataPreviewPane { .text_ui(cx) .font_buffer(cx) .text_color(cx.theme().colors().text_muted) - .when(is_parsing, |div| { + .when(is_loading, |div| { div.child( h_flex() .gap_2() @@ -62,26 +52,16 @@ impl Render for TabularDataPreviewPane { .child("Loading…"), ) }) - .when(!is_parsing, |div| { - if let Some(error) = &self.parse_error { - div.p_4() - .text_color(cx.theme().status().error) - .child(error.clone()) - } else { - div.child("No data to display") - } - }), + .when(!is_loading, |div| div.child("No data to display")), ) .into_any_element() } else { - self.create_table(&self.column_widths.widths, cx) + self.create_table(&self.column_widths, cx) } }); - - let render_prep_duration = render_prep_start.elapsed(); self.performance_metrics.timings.insert( "render_prep", - (render_prep_duration, std::time::Instant::now()), + (render_prep_start.elapsed(), std::time::Instant::now()), ); let div = div() diff --git a/crates/tabular_data_preview/src/renderer/render_table.rs b/crates/tabular_data_preview/src/renderer/render_table.rs index 7ed0841f4bc..f2a2ea2ad67 100644 --- a/crates/tabular_data_preview/src/renderer/render_table.rs +++ b/crates/tabular_data_preview/src/renderer/render_table.rs @@ -4,39 +4,23 @@ use std::ops::Range; use ui::{ColumnWidthConfig, ResizableColumnsState, Table, UncheckedTableRow, div, prelude::*}; use crate::{ - TabularDataPreviewPane, + TableView, settings::RowRenderMechanism, types::{AnyColumn, DisplayCellId, DisplayRow}, }; -impl TabularDataPreviewPane { - /// Creates a new table. - /// Column number is derived from the `ResizableColumnsState` entity. +impl TableView { pub(crate) fn create_table( &self, current_widths: &Entity, cx: &mut Context, ) -> AnyElement { - self.create_table_inner( - self.engine.d2d_mapping().visible_row_count(), - current_widths, - cx, - ) - } - - fn create_table_inner( - &self, - row_count: usize, - current_widths: &Entity, - cx: &mut Context, - ) -> AnyElement { + let row_count = self.engine.d2d_mapping().visible_row_count(); let cols = current_widths.read(cx).cols(); - // Create headers array with interactive elements let mut headers = Vec::with_capacity(cols); headers.push(self.create_row_identifier_header(cx)); - // Add the actual data headers with sort buttons for i in 0..(cols - 1) { let header_text = self .engine @@ -66,24 +50,22 @@ impl TabularDataPreviewPane { table.variable_row_height_list(row_count, self.list_state.clone(), { cx.processor(move |this, display_row: usize, _window, cx| { this.performance_metrics.rendered_indices.push(display_row); - - let display_row = DisplayRow(display_row); + // The mapping may be transiently stale while a filter/sort task is in-flight. Return an empty row rather than panicking Self::render_single_table_row( this, cols, - display_row, + DisplayRow(display_row), row_identifier_text_color, this.row_height, cx, ) - .unwrap_or_else(|| panic!("Expected to render a table row")) + .unwrap_or_default() }) }) } RowRenderMechanism::UniformList => { table.uniform_list("tabular-data-table", row_count, { cx.processor(move |this, range: Range, _window, cx| { - // Record all display indices in the range for performance metrics this.performance_metrics .rendered_indices .extend(range.clone()); @@ -113,12 +95,12 @@ impl TabularDataPreviewPane { /// /// Used both by UniformList and VariableRowHeightList fn render_single_table_row( - this: &TabularDataPreviewPane, + this: &TableView, cols: usize, display_row: DisplayRow, row_identifier_text_color: gpui::Hsla, row_height: Pixels, - cx: &Context, + cx: &Context, ) -> Option> { // Get the actual row index from our sorted indices let data_row = this.engine.d2d_mapping().get_data_row(display_row)?; @@ -147,7 +129,7 @@ impl TabularDataPreviewPane { .overflow_hidden() }, ) - .child(TabularDataPreviewPane::create_selectable_cell( + .child(TableView::create_selectable_cell( display_cell_id, cell_content, this.settings.vertical_alignment, diff --git a/crates/tabular_data_preview/src/renderer/row_identifiers.rs b/crates/tabular_data_preview/src/renderer/row_identifiers.rs index bf1c69c6655..27bce1d9bde 100644 --- a/crates/tabular_data_preview/src/renderer/row_identifiers.rs +++ b/crates/tabular_data_preview/src/renderer/row_identifiers.rs @@ -1,5 +1,5 @@ use crate::{ - TabularDataPreviewPane, + TableView, settings::RowIdentifiers, types::{DataRow, DisplayRow, LineNumber}, }; @@ -46,7 +46,7 @@ impl LineNumber { } } -impl TabularDataPreviewPane { +impl TableView { /// Calculate the optimal width for the row identifier column (line numbers or row numbers). /// /// This ensures the column is wide enough to display the largest identifier comfortably, @@ -105,7 +105,7 @@ impl TabularDataPreviewPane { pub(crate) fn create_row_identifier_header( &self, - cx: &mut Context<'_, TabularDataPreviewPane>, + cx: &mut Context<'_, TableView>, ) -> AnyElement { let has_line_numbers = !self.engine.contents.line_numbers.is_empty(); @@ -156,20 +156,21 @@ impl TabularDataPreviewPane { &self, display_row: DisplayRow, data_row: DataRow, - cx: &Context<'_, TabularDataPreviewPane>, + cx: &Context<'_, TableView>, ) -> Option { let row_identifier: SharedString = match self.settings.numbering_type { - RowIdentifiers::SrcLines => self - .engine - .contents - .line_numbers - .get(*data_row)? - .display_string(if self.settings.multiline_cells_effectively_enabled() { - RowIdentDisplayMode::Vertical - } else { - RowIdentDisplayMode::Horizontal - }) - .into(), + // Fall back to a sequential row number when there is no source line for this row (e.g. + // content that did not originate from a text buffer, such as a database result set). + RowIdentifiers::SrcLines => match self.engine.contents.line_numbers.get(*data_row) { + Some(line) => line + .display_string(if self.settings.multiline_cells_effectively_enabled() { + RowIdentDisplayMode::Vertical + } else { + RowIdentDisplayMode::Horizontal + }) + .into(), + None => (*display_row + 1).to_string().into(), + }, RowIdentifiers::RowNum => (*display_row + 1).to_string().into(), }; diff --git a/crates/tabular_data_preview/src/renderer/settings.rs b/crates/tabular_data_preview/src/renderer/settings.rs index 81b20d080fb..1e09735c15c 100644 --- a/crates/tabular_data_preview/src/renderer/settings.rs +++ b/crates/tabular_data_preview/src/renderer/settings.rs @@ -5,8 +5,8 @@ use ui::{ }; use crate::{ - TabularDataPreviewPane, - settings::{FilterSortOrder, TabularDataPreviewSettings, VerticalAlignment}, + TableView, + settings::{FilterSortOrder, TableViewSettings, VerticalAlignment}, }; ///// Settings related ///// @@ -18,8 +18,8 @@ fn toggle_entry( label: &'static str, description: Option<&'static str>, selected: bool, - view_entity: &Entity, - set: impl Fn(&mut TabularDataPreviewSettings) + 'static, + view_entity: &Entity, + set: impl Fn(&mut TableViewSettings) + 'static, ) -> ContextMenu { let view_entity = view_entity.clone(); let entry = ContextMenuEntry::new(label) @@ -40,9 +40,7 @@ fn toggle_entry( menu.item(entry) } -pub(crate) fn settings_popover_menu( - view_entity: Entity, -) -> PopoverMenu { +pub(crate) fn settings_popover_menu(view_entity: Entity) -> PopoverMenu { PopoverMenu::new("table-settings-menu") .trigger_with_tooltip( IconButton::new("table-settings-trigger", IconName::Filter) @@ -118,8 +116,8 @@ pub(crate) fn settings_popover_menu( #[cfg(feature = "dev-tools")] fn append_dev_only_entries( menu: ContextMenu, - view_entity: &Entity, - settings: &TabularDataPreviewSettings, + view_entity: &Entity, + settings: &TableViewSettings, ) -> ContextMenu { use crate::settings::RowRenderMechanism; diff --git a/crates/tabular_data_preview/src/renderer/table_cell.rs b/crates/tabular_data_preview/src/renderer/table_cell.rs index 1150f079cb8..4cb59d898ee 100644 --- a/crates/tabular_data_preview/src/renderer/table_cell.rs +++ b/crates/tabular_data_preview/src/renderer/table_cell.rs @@ -3,7 +3,7 @@ use gpui::{AnyElement, ClipboardItem, ElementId, MouseButton, StatefulInteractiveElement}; use ui::{Color, Divider, Label, LabelSize, SharedString, Tooltip, div, prelude::*}; -use crate::{TabularDataPreviewPane, settings::VerticalAlignment, types::DisplayCellId}; +use crate::{TableView, settings::VerticalAlignment, types::DisplayCellId}; /// Adds a right-click-to-copy handler and a tooltip showing `text` plus `hint` /// (e.g. "Right click to copy content") to a `Stateful` element. @@ -30,13 +30,13 @@ pub(crate) fn with_copy_on_right_click( })) } -impl TabularDataPreviewPane { +impl TableView { /// Create selectable table cell with mouse event handlers. pub fn create_selectable_cell( display_cell_id: DisplayCellId, cell_content: SharedString, vertical_alignment: VerticalAlignment, - cx: &Context, + cx: &Context, ) -> AnyElement { create_table_cell(display_cell_id, cell_content, vertical_alignment, cx) // Mouse events handlers will be here @@ -49,7 +49,7 @@ fn create_table_cell( display_cell_id: DisplayCellId, cell_content: SharedString, vertical_alignment: VerticalAlignment, - cx: &Context<'_, TabularDataPreviewPane>, + cx: &Context<'_, TableView>, ) -> gpui::Stateful
{ let cell = div() .id(ElementId::NamedInteger( diff --git a/crates/tabular_data_preview/src/renderer/table_header.rs b/crates/tabular_data_preview/src/renderer/table_header.rs index 172a290c97a..1636f584433 100644 --- a/crates/tabular_data_preview/src/renderer/table_header.rs +++ b/crates/tabular_data_preview/src/renderer/table_header.rs @@ -18,7 +18,7 @@ use ui::{ }; use crate::{ - TabularDataPreviewPane, + TableView, renderer::table_cell::with_copy_on_right_click, settings::FilterSortOrder, table_data_engine::{ @@ -46,7 +46,7 @@ enum ColumnFilterListEntry { struct ColumnFilterDelegate { col: AnyColumn, - view: Entity, + view: Entity, /// Row order frozen at open time (available entries sorted per the /// column's `FilterSortOrder`, then entries hidden by other columns' /// filters). Kept stable so toggling a value doesn't reshuffle the list @@ -67,7 +67,7 @@ struct ColumnFilterDelegate { impl ColumnFilterDelegate { fn new( col: AnyColumn, - view: Entity, + view: Entity, sort_order: FilterSortOrder, column_filters: Arc>, cx: &mut Context>, @@ -519,12 +519,12 @@ impl PickerDelegate for ColumnFilterDelegate { } } -impl TabularDataPreviewPane { +impl TableView { /// Create header for data, which is orderable with text on the left and sort button on the right pub(crate) fn create_header_element_with_sort_button( &self, header_text: SharedString, - cx: &mut Context<'_, TabularDataPreviewPane>, + cx: &mut Context<'_, TableView>, col_idx: AnyColumn, ) -> AnyElement { let has_active_filter = self.engine.has_active_filters(col_idx); @@ -600,11 +600,7 @@ impl TabularDataPreviewPane { .into_any_element() } - fn create_sort_button( - &self, - cx: &mut Context<'_, TabularDataPreviewPane>, - col_idx: AnyColumn, - ) -> Button { + fn create_sort_button(&self, cx: &mut Context<'_, TableView>, col_idx: AnyColumn) -> Button { Button::new( ElementId::NamedInteger("sort-button".into(), col_idx.get() as u64), match self.engine.applied_sorting { @@ -649,14 +645,14 @@ impl TabularDataPreviewPane { }), }; this.engine.applied_sorting = new_sorting; - this.apply_sort(cx); + this.apply_filter_sort(cx); cx.notify(); })) } fn create_filter_button( &self, - cx: &mut Context<'_, TabularDataPreviewPane>, + cx: &mut Context<'_, TableView>, col: AnyColumn, ) -> PopoverMenu> { let has_active_filters = self.engine.has_active_filters(col); diff --git a/crates/tabular_data_preview/src/settings.rs b/crates/tabular_data_preview/src/settings.rs index 652e9c271f2..418332eb114 100644 --- a/crates/tabular_data_preview/src/settings.rs +++ b/crates/tabular_data_preview/src/settings.rs @@ -36,7 +36,7 @@ pub enum FilterSortOrder { } #[derive(Clone, Default)] -pub(crate) struct TabularDataPreviewSettings { +pub(crate) struct TableViewSettings { pub(crate) rendering_with: RowRenderMechanism, pub(crate) vertical_alignment: VerticalAlignment, pub(crate) numbering_type: RowIdentifiers, @@ -47,7 +47,7 @@ pub(crate) struct TabularDataPreviewSettings { pub(crate) multiline_cells_enabled: bool, } -impl TabularDataPreviewSettings { +impl TableViewSettings { /// `multiline_cells_enabled` only makes sense with `VariableList`, which /// supports per-row heights; `UniformList` requires every row to share one /// height, so multiline is never honored there regardless of the setting. diff --git a/crates/tabular_data_preview/src/table_view.rs b/crates/tabular_data_preview/src/table_view.rs new file mode 100644 index 00000000000..f6ae9d94f3f --- /dev/null +++ b/crates/tabular_data_preview/src/table_view.rs @@ -0,0 +1,214 @@ +//! The reusable tabular-data viewer component. +//! +//! `TableView` owns the [`TableDataEngine`] (client-side filter/sort + display-to-data mapping) +//! and all of the grid rendering over `ui::Table`. +//! +//! It is deliberately source-agnostic: it renders whatever [`TableLikeContent`] it is handed +//! via [`TableView::set_contents`], whether that content comes from the CSV parser or from some +//! other producer (e.g. a database result set). + +use std::{ + collections::HashMap, + time::{Duration, Instant}, +}; + +use gpui::{App, AppContext, Entity, FocusHandle, Focusable, ListAlignment, Task}; +use ui::{ + AbsoluteLength, ResizableColumnsState, SharedString, TableInteractionState, + TableResizeBehavior, prelude::*, +}; + +use crate::{ + settings::TableViewSettings, + table_data_engine::{DisplayToDataMapping, TableDataEngine}, + types::{AnyColumn, TableLikeContent}, +}; + +#[derive(Debug, Default)] +pub struct PerformanceMetrics { + /// Map of timing metrics with their duration and measurement time. + pub timings: HashMap<&'static str, (Duration, Instant)>, + /// List of display indices that were rendered in the current frame. + pub rendered_indices: Vec, +} + +impl PerformanceMetrics { + pub fn record(&mut self, name: &'static str, mut f: F) -> R + where + F: FnMut() -> R, + { + let start_time = Instant::now(); + let ret = f(); + let duration = start_time.elapsed(); + self.timings.insert(name, (duration, Instant::now())); + ret + } + + /// Displays all metrics sorted A-Z in format: `{name}: {took}ms {ago}s ago` + pub fn display(&self) -> String { + let mut metrics = self.timings.iter().collect::>(); + metrics.sort_by_key(|&(name, _)| *name); + metrics + .iter() + .map(|(name, (duration, time))| { + let took = duration.as_secs_f32() * 1000.; + let ago = time.elapsed().as_secs(); + format!("{name}: {took:.3}ms {ago}s ago") + }) + .collect::>() + .join("\n") + } + + /// Get timing for a specific metric + pub fn get_timing(&self, name: &str) -> Option { + self.timings.get(name).map(|(duration, _)| *duration) + } +} + +pub struct TableView { + pub(crate) engine: TableDataEngine, + pub(crate) focus_handle: FocusHandle, + pub(crate) table_interaction_state: Entity, + pub(crate) column_widths: Entity, + /// Background task computing the display-to-data mapping after a filter/sort change. + /// Stored here so that a new change cancels the previous in-flight computation. + pub(crate) filter_sort_task: Option>, + pub(crate) settings: TableViewSettings, + /// Performance metrics for debugging and monitoring grid operations. + pub(crate) performance_metrics: PerformanceMetrics, + pub(crate) list_state: gpui::ListState, + /// Cached row height, refreshed from the actual text line height on every render. + /// Used to size not-yet-rendered rows for the scrollbar without a full `.measure_all()` + /// pass, so it tracks the real row height instead of a hardcoded guess. + pub(crate) row_height: Pixels, + /// Whether the producer feeding this view is currently computing content. While set, the grid + /// shows a loading indicator instead of the (stale or empty) table. + pub(crate) is_loading: bool, +} + +impl TableView { + pub fn new(window: &Window, cx: &mut Context) -> Self { + let contents = TableLikeContent::default(); + let table_interaction_state = cx.new(|cx| { + TableInteractionState::new(cx).with_custom_scrollbar(ui::Scrollbars::for_settings::< + editor::EditorSettingsScrollbarProxy, + >()) + }); + let row_height = window.pixel_snap(window.line_height()); + + Self { + engine: TableDataEngine::default(), + focus_handle: cx.focus_handle(), + table_interaction_state, + column_widths: cx.new(|_cx| { + ResizableColumnsState::new( + 1, + vec![AbsoluteLength::Pixels(px(150.))], + vec![TableResizeBehavior::Resizable], + ) + }), + filter_sort_task: None, + settings: TableViewSettings::default(), + performance_metrics: PerformanceMetrics::default(), + list_state: gpui::ListState::new(contents.rows.len(), ListAlignment::Top, px(1.)) + .with_uniform_item_height(row_height), + row_height, + is_loading: false, + } + } + + /// Replace the data shown by the grid. Recomputes filter menus and column widths, kicks off the + /// display-to-data recomputation, and clears the loading state. + pub fn set_contents(&mut self, contents: TableLikeContent, cx: &mut Context) { + self.engine.set_contents(contents); + // The old mapping may reference rows removed by this change. Clear it immediately + // rather than leaving the list showing stale rows until the background task below + // recomputes the mapping. + self.list_state + .reset_with_uniform_height(0, self.row_height); + self.sync_column_widths(cx); + self.is_loading = false; + self.apply_filter_sort(cx); + } + + /// Toggle the loading indicator (shown while a producer computes new content). + pub fn set_loading(&mut self, is_loading: bool, cx: &mut Context) { + self.is_loading = is_loading; + cx.notify(); + } + + pub(crate) fn sync_column_widths(&self, cx: &mut Context) { + // plus 1 for the row identifier column + let cols = self.engine.contents.headers.cols() + 1; + let line_number_width = self.calculate_row_identifier_column_width(); + + let mut widths: Vec = vec![AbsoluteLength::Pixels(px(150.)); cols]; + widths[0] = AbsoluteLength::Pixels(px(line_number_width)); + + let mut resize_behaviors = vec![TableResizeBehavior::Resizable; cols]; + resize_behaviors[0] = TableResizeBehavior::None; + + self.column_widths.update(cx, |state, _cx| { + if state.cols() != cols { + *state = ResizableColumnsState::new(cols, widths, resize_behaviors); + } else { + state.set_column_configuration( + 0, + AbsoluteLength::Pixels(px(line_number_width)), + TableResizeBehavior::None, + ); + } + }); + } + + pub fn clear_filters(&mut self, col: AnyColumn, cx: &mut Context) { + self.engine.clear_filters_for_col(col); + self.apply_filter_sort(cx); + } + + pub fn toggle_filter( + &mut self, + col: AnyColumn, + value: Option, + cx: &mut Context, + ) { + if let Err(err) = self.engine.toggle_filter(col, value) { + log::error!("Failed to toggle filter: {err}"); + return; + } + self.apply_filter_sort(cx); + } + + /// Spawns a background task to recompute the display-to-data mapping after a filter or sort + /// change. Storing the task cancels any previous in-flight computation automatically. + pub(crate) fn apply_filter_sort(&mut self, cx: &mut Context) { + let contents = self.engine.contents.clone(); + let filter_stack = self.engine.filter_stack.clone(); + let sorting = self.engine.applied_sorting; + + self.filter_sort_task = Some(cx.spawn(async move |this, cx| { + let mapping = cx + .background_spawn(async move { + DisplayToDataMapping::compute(&contents, &filter_stack, sorting) + }) + .await; + + this.update(cx, |view, cx| { + view.engine.set_d2d_mapping(mapping); + let visible_rows = view.engine.d2d_mapping().visible_row_count(); + // Uses the row height measured on the last render. Cheaper than a full + // `.measure_all()` pass; exact row heights are re-measured on scrolling. + view.list_state + .reset_with_uniform_height(visible_rows, view.row_height); + cx.notify(); + }) + .ok(); + })); + } +} + +impl Focusable for TableView { + fn focus_handle(&self, _cx: &App) -> FocusHandle { + self.focus_handle.clone() + } +} diff --git a/crates/tabular_data_preview/src/tabular_data_preview.rs b/crates/tabular_data_preview/src/tabular_data_preview.rs index 9b72d6f15aa..be05244dfea 100644 --- a/crates/tabular_data_preview/src/tabular_data_preview.rs +++ b/crates/tabular_data_preview/src/tabular_data_preview.rs @@ -1,52 +1,36 @@ use editor::{Editor, EditorEvent}; -use gpui::{ - AppContext, Entity, EventEmitter, FocusHandle, Focusable, ListAlignment, Task, actions, -}; -use std::{ - collections::HashMap, - time::{Duration, Instant}, -}; +use gpui::{AppContext, Entity, EventEmitter, FocusHandle, Focusable, Task, actions}; -use crate::table_data_engine::{DisplayToDataMapping, TableDataEngine}; -use ui::{ - AbsoluteLength, ResizableColumnsState, SharedString, TableInteractionState, - TableResizeBehavior, prelude::*, -}; +use ui::{SharedString, prelude::*}; use workspace::{Item, Pane, Workspace}; -use crate::{parser::EditorState, settings::TabularDataPreviewSettings, types::TableLikeContent}; +use crate::parser::EditorState; + +pub use crate::table_view::{PerformanceMetrics, TableView}; mod parser; mod renderer; mod settings; mod table_data_engine; -mod types; +mod table_view; +pub mod types; actions!(tabular_data, [OpenPreview, OpenPreviewToTheSide]); +/// Editor-backed adapter: watches an [`Editor`], parses its buffer into a [`crate::types::TableLikeContent`], +/// and feeds the result to an embedded [`TableView`] that owns all grid rendering. pub struct TabularDataPreviewPane { - pub(crate) engine: TableDataEngine, - - pub(crate) focus_handle: FocusHandle, + /// The reusable tabular viewer this adapter drives. + pub(crate) table: Entity, active_editor_state: EditorState, - pub(crate) table_interaction_state: Entity, - pub(crate) column_widths: ColumnWidths, pub(crate) parsing_task: Option>>, pub(crate) is_parsing: bool, pub(crate) parse_error: Option, - /// Background task computing the display-to-data mapping after a filter/sort change. - /// Stored here so that a new change cancels the previous in-flight computation. - pub(crate) filter_sort_task: Option>, - pub(crate) settings: TabularDataPreviewSettings, - /// Performance metrics for debugging and monitoring tabular data operations. - pub(crate) performance_metrics: PerformanceMetrics, - pub(crate) list_state: gpui::ListState, - /// Cached row height, refreshed from the actual text line height on every render. - /// Used to size not-yet-rendered rows for the scrollbar without a full `.measure_all()` - /// pass, so it tracks the real row height instead of a hardcoded guess. - pub(crate) row_height: Pixels, /// Time when the last parsing operation ended, used for smart debouncing pub(crate) last_parse_end_time: Option, + /// Forwards the table's notifications so observers of this pane (e.g. `cx.condition` in + /// tests, or anything watching for the mapping/list-state to settle) see them too. + _table_subscription: gpui::Subscription, } pub fn init(cx: &mut App) { @@ -57,30 +41,6 @@ pub fn init(cx: &mut App) { } impl TabularDataPreviewPane { - pub(crate) fn sync_column_widths(&self, cx: &mut Context) { - // plus 1 for the row identifier column - let cols = self.engine.contents.headers.cols() + 1; - let line_number_width = self.calculate_row_identifier_column_width(); - - let mut widths: Vec = vec![AbsoluteLength::Pixels(px(150.)); cols]; - widths[0] = AbsoluteLength::Pixels(px(line_number_width)); - - let mut resize_behaviors = vec![TableResizeBehavior::Resizable; cols]; - resize_behaviors[0] = TableResizeBehavior::None; - - self.column_widths.widths.update(cx, |state, _cx| { - if state.cols() != cols { - *state = ResizableColumnsState::new(cols, widths, resize_behaviors); - } else { - state.set_column_configuration( - 0, - AbsoluteLength::Pixels(px(line_number_width)), - TableResizeBehavior::None, - ); - } - }); - } - pub fn register(workspace: &mut Workspace) { workspace.register_action_renderer(|div, _, _, cx| { div.on_action(cx.listener(|workspace, _: &OpenPreview, window, cx| { @@ -157,13 +117,6 @@ impl TabularDataPreviewPane { } fn new(editor: &Entity, window: &Window, cx: &mut Context) -> Entity { - let contents = TableLikeContent::default(); - let table_interaction_state = cx.new(|cx| { - TableInteractionState::new(cx).with_custom_scrollbar(ui::Scrollbars::for_settings::< - editor::EditorSettingsScrollbarProxy, - >()) - }); - cx.new(|cx| { let subscription = cx.subscribe( editor, @@ -177,26 +130,20 @@ impl TabularDataPreviewPane { }, ); - let row_height = window.pixel_snap(window.line_height()); + let table = cx.new(|cx| TableView::new(window, cx)); + let table_subscription = cx.observe(&table, |_, _, cx| cx.notify()); + let mut view = TabularDataPreviewPane { - focus_handle: cx.focus_handle(), active_editor_state: EditorState { editor: editor.clone(), _subscription: subscription, }, - table_interaction_state, - column_widths: ColumnWidths::new(cx, 1), + table, parsing_task: None, is_parsing: false, parse_error: None, - filter_sort_task: None, - performance_metrics: PerformanceMetrics::default(), - list_state: gpui::ListState::new(contents.rows.len(), ListAlignment::Top, px(1.)) - .with_uniform_item_height(row_height), - row_height, - settings: TabularDataPreviewSettings::default(), last_parse_end_time: None, - engine: TableDataEngine::default(), + _table_subscription: table_subscription, }; view.parse_from_active_editor(false, cx); @@ -207,54 +154,6 @@ impl TabularDataPreviewPane { pub(crate) fn editor_state(&self) -> &EditorState { &self.active_editor_state } - pub(crate) fn apply_sort(&mut self, cx: &mut Context) { - self.apply_filter_sort(cx); - } - - pub fn clear_filters(&mut self, col: types::AnyColumn, cx: &mut Context) { - self.engine.clear_filters_for_col(col); - self.apply_filter_sort(cx); - } - - pub fn toggle_filter( - &mut self, - col: types::AnyColumn, - value: Option, - cx: &mut Context, - ) { - if let Err(err) = self.engine.toggle_filter(col, value) { - log::error!("Failed to toggle filter: {err}"); - return; - } - self.apply_filter_sort(cx); - } - - /// Spawns a background task to recompute the display-to-data mapping after a filter or sort - /// change. Storing the task cancels any previous in-flight computation automatically. - pub(crate) fn apply_filter_sort(&mut self, cx: &mut Context) { - let contents = self.engine.contents.clone(); - let filter_stack = self.engine.filter_stack.clone(); - let sorting = self.engine.applied_sorting; - - self.filter_sort_task = Some(cx.spawn(async move |this, cx| { - let mapping = cx - .background_spawn(async move { - DisplayToDataMapping::compute(&contents, &filter_stack, sorting) - }) - .await; - - this.update(cx, |view, cx| { - view.engine.set_d2d_mapping(mapping); - let visible_rows = view.engine.d2d_mapping().visible_row_count(); - // Uses the row height measured on the last render. Cheaper than a full - // `.measure_all()` pass; exact row heights are re-measured on scrolling. - view.list_state - .reset_with_uniform_height(visible_rows, view.row_height); - cx.notify(); - }) - .ok(); - })); - } pub fn resolve_active_item_as_tabular_data_editor( workspace: &Workspace, @@ -272,8 +171,25 @@ impl TabularDataPreviewPane { } impl Focusable for TabularDataPreviewPane { - fn focus_handle(&self, _cx: &App) -> FocusHandle { - self.focus_handle.clone() + fn focus_handle(&self, cx: &App) -> FocusHandle { + self.table.read(cx).focus_handle(cx) + } +} + +impl Render for TabularDataPreviewPane { + fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { + div().size_full().child(match &self.parse_error { + Some(error) => div() + .size_full() + .flex() + .items_center() + .justify_center() + .p_4() + .text_color(cx.theme().status().error) + .child(error.clone()) + .into_any_element(), + None => self.table.clone().into_any_element(), + }) } } @@ -305,65 +221,6 @@ impl Item for TabularDataPreviewPane { } } -#[derive(Debug, Default)] -pub struct PerformanceMetrics { - /// Map of timing metrics with their duration and measurement time. - pub timings: HashMap<&'static str, (Duration, Instant)>, - /// List of display indices that were rendered in the current frame. - pub rendered_indices: Vec, -} -impl PerformanceMetrics { - pub fn record(&mut self, name: &'static str, mut f: F) -> R - where - F: FnMut() -> R, - { - let start_time = Instant::now(); - let ret = f(); - let duration = start_time.elapsed(); - self.timings.insert(name, (duration, Instant::now())); - ret - } - - /// Displays all metrics sorted A-Z in format: `{name}: {took}ms {ago}s ago` - pub fn display(&self) -> String { - let mut metrics = self.timings.iter().collect::>(); - metrics.sort_by_key(|&(name, _)| *name); - metrics - .iter() - .map(|(name, (duration, time))| { - let took = duration.as_secs_f32() * 1000.; - let ago = time.elapsed().as_secs(); - format!("{name}: {took:.3}ms {ago}s ago") - }) - .collect::>() - .join("\n") - } - - /// Get timing for a specific metric - pub fn get_timing(&self, name: &str) -> Option { - self.timings.get(name).map(|(duration, _)| *duration) - } -} - -/// Holds state of column widths for a table component in the tabular data preview. -pub(crate) struct ColumnWidths { - pub widths: Entity, -} - -impl ColumnWidths { - pub(crate) fn new(cx: &mut Context, cols: usize) -> Self { - Self { - widths: cx.new(|_cx| { - ResizableColumnsState::new( - cols, - vec![AbsoluteLength::Pixels(px(150.)); cols], - vec![ui::TableResizeBehavior::Resizable; cols], - ) - }), - } - } -} - #[cfg(test)] mod tests { use super::*; @@ -453,8 +310,15 @@ mod tests { let Some(preview) = preview else { anyhow::bail!("preview did not open"); }; - cx.condition(&preview, |preview, _| { - !preview.is_parsing && preview.engine.d2d_mapping().visible_row_count() == 2 + cx.condition(&preview, |preview, cx| { + !preview.is_parsing + && preview + .table + .read(cx) + .engine + .d2d_mapping() + .visible_row_count() + == 2 }) .await; @@ -462,13 +326,14 @@ mod tests { cx.observe(&preview, |preview, cx| { let preview = preview.read(cx); if !preview.is_parsing && preview.parse_error.is_none() { - let mapping = preview.engine.d2d_mapping(); - assert_eq!(preview.list_state.item_count(), mapping.visible_row_count()); + let table = preview.table.read(cx); + let mapping = table.engine.d2d_mapping(); + assert_eq!(table.list_state.item_count(), mapping.visible_row_count()); for display_row in 0..mapping.visible_row_count() { assert!( mapping .get_data_row(DisplayRow(display_row)) - .and_then(|data_row| preview.engine.contents.get_row(data_row)) + .and_then(|data_row| table.engine.contents.get_row(data_row)) .is_some(), "display mapping points to a deleted row" ); @@ -489,10 +354,11 @@ mod tests { editor.update_in(cx, |editor, window, cx| { editor.set_text(text, window, cx); }); - cx.condition(&preview, |preview, _| { + cx.condition(&preview, |preview, cx| { + let table = preview.table.read(cx); !preview.is_parsing - && preview.engine.contents.rows.len() == expected_rows - && preview.engine.d2d_mapping().visible_row_count() == expected_rows + && table.engine.contents.rows.len() == expected_rows + && table.engine.d2d_mapping().visible_row_count() == expected_rows }) .await; } @@ -541,25 +407,45 @@ mod tests { let Some(preview) = preview else { anyhow::bail!("preview did not open"); }; - cx.condition(&preview, |preview, _| { - !preview.is_parsing && preview.engine.d2d_mapping().visible_row_count() == 2 + cx.condition(&preview, |preview, cx| { + !preview.is_parsing + && preview + .table + .read(cx) + .engine + .d2d_mapping() + .visible_row_count() + == 2 }) .await; preview.update(cx, |preview, cx| { - preview.engine.applied_sorting = Some(AppliedSorting { - col_idx: AnyColumn(0), - direction: SortDirection::Asc, + preview.table.update(cx, |table, cx| { + table.engine.applied_sorting = Some(AppliedSorting { + col_idx: AnyColumn(0), + direction: SortDirection::Asc, + }); + table.toggle_filter(AnyColumn(0), Some(r#""Ada""#.into()), cx); }); - preview.toggle_filter(AnyColumn(0), Some(r#""Ada""#.into()), cx); }); - cx.condition(&preview, |preview, _| { - preview.engine.d2d_mapping().visible_row_count() == 1 + cx.condition(&preview, |preview, cx| { + preview + .table + .read(cx) + .engine + .d2d_mapping() + .visible_row_count() + == 1 }) .await; - preview.read_with(cx, |preview, _| { + preview.read_with(cx, |preview, cx| { assert_eq!( - preview.engine.d2d_mapping().get_data_row(DisplayRow(0)), + preview + .table + .read(cx) + .engine + .d2d_mapping() + .get_data_row(DisplayRow(0)), Some(DataRow(1)) ); }); @@ -583,15 +469,22 @@ mod tests { editor.update_in(cx, |editor, window, cx| { editor.set_text("{\"name\":\"Ada\"}\n{\"name\":\"Grace\"}", window, cx); }); - cx.condition(&preview, |preview, _| { + cx.condition(&preview, |preview, cx| { !preview.is_parsing && preview.parse_error.is_none() - && preview.engine.d2d_mapping().get_data_row(DisplayRow(0)) == Some(DataRow(0)) + && preview + .table + .read(cx) + .engine + .d2d_mapping() + .get_data_row(DisplayRow(0)) + == Some(DataRow(0)) }) .await; - preview.read_with(cx, |preview, _| { - assert!(preview.engine.has_active_filters(AnyColumn(0))); - assert!(preview.engine.applied_sorting.is_some()); + preview.read_with(cx, |preview, cx| { + let table = preview.table.read(cx); + assert!(table.engine.has_active_filters(AnyColumn(0))); + assert!(table.engine.applied_sorting.is_some()); }); editor.update_in(cx, |editor, window, cx| { @@ -601,15 +494,17 @@ mod tests { cx, ); }); - cx.condition(&preview, |preview, _| { + cx.condition(&preview, |preview, cx| { + let table = preview.table.read(cx); !preview.is_parsing - && preview.engine.contents.number_of_cols == 2 - && preview.engine.d2d_mapping().visible_row_count() == 2 + && table.engine.contents.number_of_cols == 2 + && table.engine.d2d_mapping().visible_row_count() == 2 }) .await; - preview.read_with(cx, |preview, _| { - assert!(!preview.engine.has_active_filters(AnyColumn(0))); - assert!(preview.engine.applied_sorting.is_none()); + preview.read_with(cx, |preview, cx| { + let table = preview.table.read(cx); + assert!(!table.engine.has_active_filters(AnyColumn(0))); + assert!(table.engine.applied_sorting.is_none()); assert!(preview.parse_error.is_none()); }); Ok(())