Struct ChartModal 

pub struct ChartModal {

    pub active: bool,
    pub spec: ChartSpec,
    pub series_cap: Option<usize>,
    pub row_order: Option<String>,
    pub suggested: Option<String>,
    pub y_starts_at_zero: bool,
    pub log_scale: bool,
    pub show_legend: bool,
    pub grid: bool,
    pub share: bool,
    pub hist_bins: usize,
    pub heatmap_bins: usize,
    pub kde_bandwidth_factor: f64,
    pub value_range: ValueRange,
    pub bar_order: BarOrder,
    pub row_limit: Option<usize>,
    pub sample_rows: usize,
    pub rows_draft: Option<RowsDraft>,
    pub view_rows: Option<usize>,
    pub view_sampled: bool,
    pub restored: bool,
    pub focus: ChartFocus,
    pub picker: Option<PickerState>,
    pub picker_for: Option<PickerFor>,
    pub picker_details: Vec<String>,
    pub numeric_candidates: Vec<String>,
    pub temporal_candidates: Vec<String>,
    pub bucketable_candidates: Vec<String>,
    pub category_candidates: Vec<String>,
    pub color_counts: Option<ColorCounts>,
    pub dataset: Option<u64>,
    pub opened_on: Option<String>,
    pub units: Vec<(String, String)>,
    pub plot_focus: bool,
    pub cursor_x: Option<f64>,
    pub plot: Option<PlotPlace>,
}

Chart view state: the spec, the options, and the panel’s focus.

Fields

active: bool

spec: ChartSpec

series_cap: Option<usize>

The distinct colors the series slots come out as on this terminal (Theme::series_colors); None before the app says, read as COLOR_MAX.

row_order: Option<String>

The view’s sort as the footer writes it (time ▲), which first and last read the rows in; None for the order they were read in.

suggested: Option<String>

The cursor column’s type when c chose the chart (f64), shown under Type until the type is changed.

y_starts_at_zero: bool

log_scale: bool

show_legend: bool

grid: bool

The grid at the major ticks, on the kinds with axes (g).

share: bool

Histogram: each bin’s share of its group’s rows rather than its count.

hist_bins: usize

heatmap_bins: usize

kde_bandwidth_factor: f64

value_range: ValueRange

Histogram, Box and KDE: which values are drawn.

bar_order: BarOrder

row_limit: Option<usize>

Rows a chart that samples reads: up to this many, spread across the table. None = every row. What the chart reads; the Rows row edits rows_draft.

sample_rows: usize

The sample size Sample returns to, kept while Every row is chosen.

rows_draft: Option<RowsDraft>

The Rows row’s pending change, if any.

view_rows: Option<usize>

The view’s row count when the table knows it, for Every row’s cost.

view_sampled: bool

The view is a sample, held in memory: the chart reads all of it, and has no Rows row of its own.

restored: bool

A saved view put its chart here: c brings it back, whichever column the cursor is on.

focus: ChartFocus

picker: Option<PickerState>

The one Picker, open for the focused row; None while the form has the keys.

picker_for: Option<PickerFor>

picker_details: Vec<String>

Per item of the value picker: its rows, shown beside it.

numeric_candidates: Vec<String>

temporal_candidates: Vec<String>

bucketable_candidates: Vec<String>

Dates and datetimes: the X columns a time bucket truncates.

category_candidates: Vec<String>

color_counts: Option<ColorCounts>

The Color column’s values by rows, once a chart counted them.

dataset: Option<u64>

The dataset the choices were made on (App::dataset_generation), and the column the table’s cursor was on: c again from the same column on the same dataset brings the chart back as it was left.

opened_on: Option<String>

units: Vec<(String, String)>

Each column’s unit, from a delimited spec’s unit row: the axis titles name them. Set as the chart is drawn.

plot_focus: bool

The plot has the keys rather than the panel (x): ←→ move the crosshair.

cursor_x: Option<f64>

The x of the point the crosshair stands on, kept while the panel has the keys so it comes back where it was.

plot: Option<PlotPlace>

Where the line or scatter plot was last drawn, for the crosshair and a click; None when it has no points on screen.

Implementations

impl ChartModal

pub fn new() -> Self

pub fn series_max(&self) -> usize

Most series a chart draws: one per distinct series color, up to COLOR_MAX. A 16-color terminal draws fewer rather than two in one color.

pub fn axis_title(&self, column: &str) -> String

An axis title for column: its name, and its unit when it has one.

pub fn mark(&self) -> Mark

pub fn x(&self) -> Option<&String>

pub fn y(&self) -> &[String]

pub fn aggregate(&self) -> Aggregate

pub fn color(&self) -> Option<&String>

pub fn open( &mut self, columns: ChartColumns<'_>, cursor: Option<(&str, &DataType)>, default_row_limit: Option<usize>, grid: bool, dataset: u64, )

Open the chart view. From the column it was left on, on the same dataset, the chart comes back as it was, less any column the view no longer has. Otherwise the chart is chosen from the cursor column’s type (cursor): a histogram of a number, a bar of a category’s counts, a line over a date.

pub fn restore(&mut self, saved: &SavedChart, dataset: u64)

Put a saved view’s chart in place for dataset: the next c draws it.

pub fn saved(&self, seed: u64, export: Option<SavedChartExport>) -> SavedChart

The chart as a view keeps it, with seed, the one its own sample is drawn with, and export, how it was last exported.

pub fn close(&mut self)

Close the chart view. The choices stay for the next open on this dataset.

pub fn close_picker(&mut self)

pub fn has_crosshair(&self) -> bool

Whether the crosshair can take the keys: a line or scatter plot with points on screen.

pub fn x_is_temporal(&self) -> bool

Whether X is a date or a time, which a line can bucket.

pub fn x_is_bucketable(&self) -> bool

Whether X is a date or a datetime, which a time bucket truncates; a time of day is not.

pub fn y_is_multi(&self) -> bool

Whether the Y shelf takes several columns: a line or scatter chart draws one series each.

pub fn y_use(&self) -> ShelfUse

How the Y shelf is used on the chart on screen.

pub fn color_use(&self) -> ShelfUse

How the Color shelf is used on the chart on screen.

pub fn color_use_in(spec: &ChartSpec) -> ShelfUse

How spec uses its Color shelf.

pub fn colored_in(spec: &ChartSpec) -> bool

Whether spec’s color splits its chart into series.

pub fn takes_aggregate(&self) -> bool

Whether the chart takes an aggregate: a line, a scatter, a bar.

pub fn aggregates(&self) -> bool

Whether the chart reads every row (an aggregate over the whole view) rather than a sample.

pub fn colored(&self) -> bool

Whether the color splits the chart into series.

pub fn shows_other_in(spec: &ChartSpec) -> bool

Whether a colored spec draws Other: as set, or on for a scatter, whose cloud keeps its shape with every point drawn.

pub fn shows_other(&self) -> bool

pub fn row_order(&self) -> Vec<ChartFocus>

The panel’s rows for the chart on screen, in Tab order. A dimmed shelf is left out: focus passes over it.

pub fn has_grid(&self) -> bool

Whether the chart on screen has axes to draw a grid on: the heatmap’s cells and the bar chart’s rows have none.

pub fn set_mark(&mut self, mark: Mark)

Switch the chart type. The shelves carry over where the new type takes what they hold; a column it cannot take moves to where it can, or goes.

pub fn step_mark(&mut self, delta: i8)

pub fn picker_for(&self, focus: ChartFocus) -> Option<PickerFor>

Which picker the focused row opens, if it opens one.

pub fn picker_is_multi(&self, which: PickerFor) -> bool

Whether the focused row’s picker toggles several items.

pub fn open_picker(&mut self)

Open the Picker for the focused row, cursor on the current choice. The value picker opens only once the chart has counted the values.

pub fn has_color_counts(&self) -> bool

Whether the value picker has values to list: the chart has counted the Color column on screen.

pub fn step_picker_row(&mut self, delta: i8)

←/→ on a pick-one column row: the next or previous column, chosen at once.

pub fn picker_choose(&mut self)

Enter in the Picker: a pick-one row takes the cursor’s item; a row of several keeps its toggles, or adopts the cursor’s item when none are toggled, so Enter on a fresh list still charts something. The Picker closes.

pub fn picker_toggle(&mut self)

Space in a picker of several: flip the cursor’s item in or out, up to the palette’s colors.

pub fn is_marked(&self, i: usize) -> bool

Whether the item at i of the open picker is toggled on.

pub fn picker_multi(&self) -> bool

Whether the open picker toggles several items.

pub fn effective_spec(&self) -> ChartSpec

The spec to chart: the one chosen, with an open Picker’s cursor previewed on the Y shelf (and on X, except for a line or scatter, whose X re-reads everything).

pub fn step(&mut self, focus: ChartFocus, delta: i8)

←/→ (and Space, on a choice) on the focused row.

pub fn is_toggle_row(&self, focus: ChartFocus) -> bool

pub fn toggle_grid(&mut self)

pub fn adjust_kde_bandwidth_factor(&mut self, delta: f64)

pub fn adjust_number_row(&mut self, delta: i32)

+/-: step the focused number row.

pub fn rows_shown(&self) -> RowsDraft

What the Rows row shows: the pending change, or what the chart reads.

pub fn rows_pending(&self) -> bool

Whether the Rows row holds a change the chart has not read.

pub fn toggle_rows(&mut self)

←/→ or Space on Rows: Sample or Every row, pending until Enter. A size being typed is taken first; one that cannot be read stays to be fixed.

pub fn type_rows(&mut self, c: char)

A key typed on Rows: part of a sample size (50k). Typing chooses Sample.

pub fn typing_rows(&self) -> bool

Whether a size is being typed on Rows.

pub fn backspace_rows(&mut self)

Backspace on Rows: one character of the typed size off.

pub fn discard_rows(&mut self)

Esc on Rows with a change pending: put back what the chart reads.

pub fn commit_rows(&mut self) -> bool

Enter on Rows: read what it says. False when a typed size cannot be read, which stays on the row with why.

pub fn leave_rows(&mut self)

Focus left the Rows row: what it says is read, and a size that cannot be is dropped.

pub fn is_complete(spec: &ChartSpec) -> bool

Whether the spec names everything its chart needs.

pub fn can_export(&self) -> bool

pub fn how(&self) -> String

How the chart was made of the rows, as a phrase that stands alone: mean by month, running sum, colored by carrier; empty when there is nothing to say. The columns charted are named at their axes, not here.

Trait Implementations

impl Default for ChartModal

fn default() -> Self

Returns the “default value” for a type.

impl Form for ChartModal

type Field = ChartFocus

The modal’s name for a field.

fn fields(&self) -> Vec<(ChartFocus, FieldKind)>

The fields on screen, top to bottom, each with its kind. A field the current state hides or disables is left out, so focus never lands on it.

fn focused(&self) -> ChartFocus

fn set_focused(&mut self, field: ChartFocus)

Put focus on field. Called only with a field of Form::fields; a modal that shows a text cursor in the focused field syncs it here.

fn text_edge(&self, _field: Self::Field) -> (bool, bool)

For a multiline field: whether its cursor is on the first line, and on the last, where ↑ and ↓ leave it.

fn list_row(&self, _field: Self::Field) -> bool

Whether field is a row of a list (a sort, a filter, a column) rather than a setting. A click on a list row only focuses it, so it can be picked to move or remove without changing it; a click on it once focused acts. A setting (a checkbox, a choice, a button) acts on the first click.

fn focused_kind(&self) -> Option<FieldKind>

The focused field’s kind; None when focus is on a field not shown.

fn focus(&mut self, field: Self::Field) -> bool

Focus field if the form shows it: a click on a row, or a modal moving focus itself. Returns whether it did.

fn move_focus(&mut self, delta: isize)

Move focus delta fields along, wrapping. A focus the form no longer shows counts from the top.

fn focus_next(&mut self)

fn focus_prev(&mut self)

fn settle_focus(&mut self)

After a change that hides fields: when the focused one went, focus the first field instead, so it never points at nothing.