Chart export: the chart is drawn once as SVG, in the bundled font (IBM Plex Sans,
under the SIL Open Font License, in assets/fonts), then written as SVG with
its text as outlines, rasterized to PNG, or written as PDF from the same
outlines (chart_pdf). The same figure comes out the same on every machine;
text the bundled font lacks falls back to a system font.
Chart export dialog: where, in what format, style and size, with what legend,
and the words around the chart. Its keys are the shared form keys
(crate::form).
A column’s declared type: one vocabulary for the type row, a delimited spec’s
[columns], the typing of text columns, and a column retyped in the table.
The menu a right click on a table cell opens: the keys that act on a cell, each
line naming its key. A line chosen closes the menu and presses its key, so the
menu does exactly what typing the key does. A menu is not a dialog: a click
anywhere else closes it.
Copy dialog state: scope × format, a column for the cell scope, and the
header toggle, with the last choices kept for the session so a repeat copy
is yEnter. The Python scope copies the view’s pipeline as code rather
than its rows.
Format specs of kind = "delimited": the reading options for a family of CSV-like
files, with header rows that have roles (names, units), a metadata line, and a few
derived columns.
Records that are not all one size, read from a memory map: length-prefixed records,
variants a type field picks, records found by a sync marker, records in compressed
blocks or in the payloads of a packet capture, and fixed records with fields that
are read one at a time (varints, NUL-terminated text, counted groups, bit fields,
deltas, checksums).
The home screen’s ROWS preview: the first rows of the selected file, read the way
the open reads them and handed to the open as its first page (#547 M4).
What a binary value holds, told from its first bytes, and the text in it
where that is cheap to get: UTF-8 stored as bytes, or gzip and zstd of text.
Nothing here runs or renders what it finds; decompression stops at
DECODE_MAX bytes of output, whatever the input claims.
Row inspector state: which field is focused and which are listed, where the
focus is (the list or the value), the find text, the value’s view and where
it is read to, the row compared with, and the fields read for this row that
the table’s rows do not hold.
The form Data Quality Setup opens on one column to declare what it must hold:
part of the key, required, read as a number, an allowed set, a range. It stages
into Setup’s draft, which only Run reads with.
List, array and struct cells as JSON text, for the destinations that hold
one value per field: a CSV export and every clipboard copy. JSON rather than
the table’s own rendering ([1, 2], {1,"a"}) because it keeps struct field
names and reads back with any JSON parser, Polars’ str.json_decode included.
A text file that ends in a run of NUL bytes ends where the run starts. Loggers that
preallocate a file at a fixed size and never write past their last line leave the
rest as NULs, which a CSV reader would take as one last row of junk text.
Polars operations that panic on a date or datetime past the calendar’s range
(a sentinel like i64::MIN + 1 microseconds): a cast to text, dt.to_string,
and the date parts that go through a calendar date (dt.date with a zone,
dt.month_start, dt.truncate, …). Each panics for the whole column, even
when one row holds such a value.
Pivot & Melt builder state: a form of rows, each edited through one Picker
scoped to that row alone, and the live preview of the spec it stages. The spec
is echoed live; Enter applies it.
A Data Quality report written to a file: the measurements on screen, the setup
they were measured with, and the source they were measured on. Built from the
results in memory; writing one reads nothing from the data.
Trends and gaps: a report’s segments in order, pooled into the bars a terminal
has room for, and the time windows a study said to expect checked against the
segments a run counted. Built from the measurements a run kept: nothing here
reads.
A column’s type changed in the table, and a datetime made from columns: the same
names, formats and rules a delimited spec’s [columns] takes (crate::column_types),
as a view step before the filters.
The one sampler every analysis tool reads through: which rows (a scope), how they
are picked (a method), how many, and the seed. Describe, Distribution, Correlation
and Data Quality all take their rows from read, so a sample means the same
thing whichever tool shows it.
SDF (structure-data format) compound files, read into a table: one row per record,
with the molecule’s name, its atom and bond counts, and every data item
(> <FIELD>) as a column.
The Sort & Filter sidebar: what is in effect first — the sorts and the filters,
each a row to flip, edit, reorder or remove, and a row to add one — and the
Columns tab beside it, every per-column property in one list. One form
(crate::form): the tab bar is its first field, and every entry is a field.
T at the table: the other tables of the source on screen, to open one in its
place. Listed from what the open already holds (a workbook’s or a database’s tab of
the Info panel, a spec’s record types, a cache’s splits), so nothing is read to list
them; opening one is an open of the file with --table, as home’s row for it is.
Named themes: the two built in, and every *.toml in the config directory’s
themes/, each a set of theme.colors slots named by its file. theme.dark and
theme.light pick one per mode; theme.colors lies over whichever is in use.
A completion flash (the Feedback rules’ second rung): one plain sentence on
the control bar, cleared by the next keypress or after two seconds,
whichever comes first. Every screen’s completions go here, the home screen’s
included. The home screen’s own status line beside the filter is for what a
key could not do and why, which has to survive until it is read.
Rows a sampled Data Quality run read, and what decided which rows they were: its
acquisition identity. A run or a drill that names the same rows cuts these instead
of reading.
A remote file downloaded without asking: one the built-in catalog lists, at most
limit bytes by what the server says or, when it says nothing, by the catalog.
Memory Data Quality keeps for the session: the rows its sampled runs read and the
reports they made. Past it, reports that retained rows can remake go first, then
the oldest rows, then the oldest other reports; the newest of each always stays.
The exit status for the binary when a signal ended the session run returned
from: 128 + n for SIGTERM, SIGHUP or SIGINT, as if it had not been caught (the
statuses of datui_cli::exit), and on
Windows the status a console process closed by its window ends with.
As run, but a normal quit hands back the active table’s final view for the
caller to keep working with (the Python binding’s capture=True). None when no
dataset was open at quit. See App::capture_view for what is refused and why.
What App::handle did with an event: Ok carries the follow-up event to send,
if any; Err returns a key that arrived while the app was busy. Nothing was done
with that key and it was not dropped: the caller keeps it and offers it again once
the app is idle.