mirror of
https://github.com/zed-industries/zed.git
synced 2026-11-19 06:59:22 +01:00
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<TableView>` 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
This commit is contained in:
committed by
GitHub
parent
00def035de
commit
93c87da195
@@ -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();
|
||||
})
|
||||
})
|
||||
|
||||
@@ -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<Self>,
|
||||
|
||||
@@ -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<Self>) -> 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()
|
||||
|
||||
@@ -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<ResizableColumnsState>,
|
||||
cx: &mut Context<Self>,
|
||||
) -> 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<ResizableColumnsState>,
|
||||
cx: &mut Context<Self>,
|
||||
) -> 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<usize>, _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<TabularDataPreviewPane>,
|
||||
cx: &Context<TableView>,
|
||||
) -> Option<UncheckedTableRow<AnyElement>> {
|
||||
// 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,
|
||||
|
||||
@@ -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<AnyElement> {
|
||||
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(),
|
||||
};
|
||||
|
||||
|
||||
@@ -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<TabularDataPreviewPane>,
|
||||
set: impl Fn(&mut TabularDataPreviewSettings) + 'static,
|
||||
view_entity: &Entity<TableView>,
|
||||
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<TabularDataPreviewPane>,
|
||||
) -> PopoverMenu<ContextMenu> {
|
||||
pub(crate) fn settings_popover_menu(view_entity: Entity<TableView>) -> PopoverMenu<ContextMenu> {
|
||||
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<TabularDataPreviewPane>,
|
||||
settings: &TabularDataPreviewSettings,
|
||||
view_entity: &Entity<TableView>,
|
||||
settings: &TableViewSettings,
|
||||
) -> ContextMenu {
|
||||
use crate::settings::RowRenderMechanism;
|
||||
|
||||
|
||||
@@ -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<E: StatefulInteractiveElement>(
|
||||
}))
|
||||
}
|
||||
|
||||
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<TabularDataPreviewPane>,
|
||||
cx: &Context<TableView>,
|
||||
) -> 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<Div> {
|
||||
let cell = div()
|
||||
.id(ElementId::NamedInteger(
|
||||
|
||||
@@ -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<TabularDataPreviewPane>,
|
||||
view: Entity<TableView>,
|
||||
/// 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<TabularDataPreviewPane>,
|
||||
view: Entity<TableView>,
|
||||
sort_order: FilterSortOrder,
|
||||
column_filters: Arc<Vec<(FilterEntry, FilterEntryState)>>,
|
||||
cx: &mut Context<Picker<Self>>,
|
||||
@@ -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<Picker<ColumnFilterDelegate>> {
|
||||
let has_active_filters = self.engine.has_active_filters(col);
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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<usize>,
|
||||
}
|
||||
|
||||
impl PerformanceMetrics {
|
||||
pub fn record<F, R>(&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::<Vec<_>>();
|
||||
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::<Vec<_>>()
|
||||
.join("\n")
|
||||
}
|
||||
|
||||
/// Get timing for a specific metric
|
||||
pub fn get_timing(&self, name: &str) -> Option<Duration> {
|
||||
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<TableInteractionState>,
|
||||
pub(crate) column_widths: Entity<ResizableColumnsState>,
|
||||
/// 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<Task<()>>,
|
||||
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>) -> 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>) {
|
||||
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>) {
|
||||
self.is_loading = is_loading;
|
||||
cx.notify();
|
||||
}
|
||||
|
||||
pub(crate) fn sync_column_widths(&self, cx: &mut Context<Self>) {
|
||||
// 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<AbsoluteLength> = 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>) {
|
||||
self.engine.clear_filters_for_col(col);
|
||||
self.apply_filter_sort(cx);
|
||||
}
|
||||
|
||||
pub fn toggle_filter(
|
||||
&mut self,
|
||||
col: AnyColumn,
|
||||
value: Option<SharedString>,
|
||||
cx: &mut Context<Self>,
|
||||
) {
|
||||
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<Self>) {
|
||||
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()
|
||||
}
|
||||
}
|
||||
@@ -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<TableView>,
|
||||
active_editor_state: EditorState,
|
||||
pub(crate) table_interaction_state: Entity<TableInteractionState>,
|
||||
pub(crate) column_widths: ColumnWidths,
|
||||
pub(crate) parsing_task: Option<Task<anyhow::Result<()>>>,
|
||||
pub(crate) is_parsing: bool,
|
||||
pub(crate) parse_error: Option<SharedString>,
|
||||
/// 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<Task<()>>,
|
||||
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<std::time::Instant>,
|
||||
/// 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<Self>) {
|
||||
// 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<AbsoluteLength> = 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<Editor>, window: &Window, cx: &mut Context<Workspace>) -> Entity<Self> {
|
||||
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>) {
|
||||
self.apply_filter_sort(cx);
|
||||
}
|
||||
|
||||
pub fn clear_filters(&mut self, col: types::AnyColumn, cx: &mut Context<Self>) {
|
||||
self.engine.clear_filters_for_col(col);
|
||||
self.apply_filter_sort(cx);
|
||||
}
|
||||
|
||||
pub fn toggle_filter(
|
||||
&mut self,
|
||||
col: types::AnyColumn,
|
||||
value: Option<SharedString>,
|
||||
cx: &mut Context<Self>,
|
||||
) {
|
||||
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<Self>) {
|
||||
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<Self>) -> 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<usize>,
|
||||
}
|
||||
impl PerformanceMetrics {
|
||||
pub fn record<F, R>(&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::<Vec<_>>();
|
||||
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::<Vec<_>>()
|
||||
.join("\n")
|
||||
}
|
||||
|
||||
/// Get timing for a specific metric
|
||||
pub fn get_timing(&self, name: &str) -> Option<Duration> {
|
||||
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<ResizableColumnsState>,
|
||||
}
|
||||
|
||||
impl ColumnWidths {
|
||||
pub(crate) fn new(cx: &mut Context<TabularDataPreviewPane>, 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(())
|
||||
|
||||
Reference in New Issue
Block a user