NAME

Term::Fabulous::Manual::Glossary - The terms used in the Term::Fabulous documentation

DESCRIPTION

This page is part of Term::Fabulous::Manual. Previous page: Term::Fabulous::Manual::Troubleshooting.

The terms the Term::Fabulous documentation uses, in alphabetical order, each with a link to the section that explains it. A term with several meanings lists them all; a word in parentheses names the area a term belongs to, such as (table) or (KDL).

GLOSSARY

alias (KDL)

The short name a KDL layout gives a widget class in its use instructions (use Term::Fabulous::Widget::Box as Box); widget nodes use it as their name. See "Declaring widget classes" in Term::Fabulous::Manual::KDL.

ancestor

A widget's parent, the parent's parent, and so on up to the root.

application object

The Term::Fabulous object of a program: it holds the widget tree, opens the terminal and runs the event loop (run).

bubbling

An event, after the listeners of its target ran, is passed on to the target's ancestors. See "Return values and bubbling" in Term::Fabulous::Manual::Events.

canvas

A widget you draw into yourself: a Term::Fabulous::Widget::Canvas cell by cell, a Term::Fabulous::Widget::PixelCanvas pixel by pixel. See "CANVASES" in Term::Fabulous::Manual::Charts. A canvas that paints itself from its own state is a Term::Fabulous::Widget::Display.

cell

The word has three meanings, which the context tells apart:

1. One character position of the terminal. Wide characters take two cells. Sizes, padding and positions are counted in cells.

2. On a canvas, one position of its buffer: a character with a foreground and a background color. See "Drawing cells" in Term::Fabulous::Manual::Charts.

3. In a table, the place where a row and a column meet, with the value the column takes from the row. See "Table terms" in Term::Fabulous::Manual::Tables.

cell context (table)

The hash reference a table passes to a column's cell, update_cell and cell_style code: the raw value, the display text, a copy of the row, the row id, the column and the table. See "CELL WIDGETS" in Term::Fabulous::Manual::Tables.

character string

Decoded Perl text, where each character is one Unicode code point. Compare "UTF-8 byte string".

chart

A canvas that draws itself from data: line, area, bar, scatter, histogram, sparkline, pie, donut, polar area and radar charts. See "CHARTS" in Term::Fabulous::Manual::Charts.

Clay

The layout engine Term::Fabulous uses; see Clay::XS and Clay::UI.

column, row

1. The horizontal and vertical position of a terminal cell or a canvas cell, counted from 0 at the top-left corner.

2. In a table, a row is one hash reference of your data, shown as one line, and a column is one Term::Fabulous::Widget::Table::Column object, which picks a value out of each row. See "Table terms" in Term::Fabulous::Manual::Tables.

column chooser (table)

A list with a check box per column that lets the user show and hide the columns of a table. See "Choosing the visible columns" in Term::Fabulous::Manual::Tables.

command

One thing the user can do, with a label, keys and code: a Term::Fabulous::Command, usually kept in a Term::Fabulous::Commands table that runs it by its keys and shows it in menus. See "COMMANDS" in Term::Fabulous::Manual::Menus.

content box

The area of a widget inside its border and padding, where its children (or a canvas's cells) are placed.

context menu

A menu of what can be done with the thing under the pointer, opened with a right click, the Menu key or Shift+F10. In Term::Fabulous, a Term::Fabulous::Widget::Menu opened as a popup. See "CONTEXT MENUS" in Term::Fabulous::Manual::Menus.

contributor

A method of a widget whose name starts with contribute_. Clay::UI calls all of them, in alphabetical order, to build the widget's configuration (colors, border, layout) for a frame. See "A box that takes the focus and reacts to the mouse" in Term::Fabulous::Manual::CustomWidgets.

cursor (table)

The line of a Term::Fabulous::Widget::Table the keyboard works on, highlighted while the table has the focus. Not the same as the selection. See "The cursor" in Term::Fabulous::Manual::TableRows.

debounced

Delayed until the input has stopped changing for a short time; used for terminal resizes, see "Event reference" in Term::Fabulous::Manual::Events.

display text (table)

The text a table cell shows: its raw value after the column's mutators. See "DISPLAY TEXT AND MUTATORS" in Term::Fabulous::Manual::Tables.

event

Something that happened, as an object: a key press, a click, a changed value. Events are fired on a widget, run its listeners and then bubble. See "EVENTS" in Term::Fabulous::Manual::Events.

event loop

The IO::Async::Loop that $ui->run runs: it waits for input, draws frames and runs timers. See "THE EVENT LOOP" in Term::Fabulous::Manual::Programs.

family (theme)

The kind of a widget as the theme sees it: button, input, table, ... Each family has slots. See "What a theme colors" in Term::Fabulous::Manual::Looks.

filter expression (table)

The text in a field of a table's filter row, such as >=2019 or !ann; its notation depends on the column's type. See "The filter row" in Term::Fabulous::Manual::TableRows.

focus

Which widget receives key presses. See "FOCUS" in Term::Fabulous::Manual::Events.

frame

1. One complete layout and drawing of the screen. Term::Fabulous checks 30 times per second whether a frame is needed and draws one when something changed, so a change "shows in the next frame" within 1/30 second.

2. Of a table, the lines around it, set with its border parameter. See "Lines between and around the cells" in Term::Fabulous::Manual::TableStyles.

grapheme cluster

What a reader sees as one character, even if it consists of several Unicode code points (a letter with combining accents, a flag emoji). Cursor movement and canvas cells work with clusters.

group, group header (table)

The rows of a table that share the value of a group column (group_by), and the line above them that shows the value and the number of rows; the user opens and closes a group there. See "GROUPING" in Term::Fabulous::Manual::TableRows.

hoverable, pressable, focusable

Widgets that track whether the pointer is over them, whether they are pressed, and whether they can take the keyboard focus. They compose the Clay::UI roles of these names: Button and the input widgets all three, Table and RadioGroup focusable (Table also hoverable), charts hoverable. See "A box that takes the focus and reacts to the mouse" in Term::Fabulous::Manual::CustomWidgets.

inline mode, inline region

A way to run a program in a few rows below the shell's output instead of the whole screen; the rows are the inline region. See "INLINE MODE" in Term::Fabulous.

interaction tracker

The Clay::UI::Interaction object of the UI, $ui->interaction: it knows which widget has the focus, which is hovered and which is pressed, and moves the focus from code. See "Moving the focus" in Term::Fabulous::Manual::Events.

KDL

A configuration language (https://kdl.dev) in which widget trees can be written. See "KDL LAYOUT FILES" in Term::Fabulous::Manual::KDL.

key name

The readable name of a key press, such as q, Enter or Ctrl+Left, as the method key_name of a KeyPress event returns it. See "Key names" in Term::Fabulous::Manual::Events.

kitty keyboard protocol

A way for terminals to report keys that the older encodings cannot tell apart. See "THE KITTY KEYBOARD PROTOCOL" in Term::Fabulous::Event::KeyPress.

layout

The sizes and positions of the widgets, which Clay works out for every frame from each widget's layout hash. See "LAYOUT" in Term::Fabulous::Manual::Layout.

line (table)

One entry of a table's view: a data row or a group header. Pages count lines. See "Table terms" in Term::Fabulous::Manual::Tables.

listener

A code reference registered with $widget->on( $event_name => $code ). See "Listening to events" in Term::Fabulous::Manual::Events.

mnemonic

The underlined letter of a menu title, which opens the menu together with Alt. See "Opening the menus" in Term::Fabulous::Manual::Menus.

mutator

A code reference that turns a table cell's raw value into its display text, for example epoch seconds into a date; see Term::Fabulous::Widget::Table::Mutator.

node (KDL)

One element of a KDL document: a name, optional values and an optional block of child nodes in braces. In a layout, a node whose name starts with an uppercase letter is a widget, any other node a property. See "Widget nodes and ids" in Term::Fabulous::Manual::KDL.

notifier

IO::Async's word for anything that runs in its event loop: timers, sockets, child processes, signal handlers.

padding

Empty space inside a widget, between its edge (or border) and its children, in cells per side; in a table, cell_padding is the space inside every cell. See "Padding" in Term::Fabulous::Manual::Layout.

pager (table)

The bar below a table with pages: buttons to turn the pages, the page number, a list of page sizes and a count of the lines. See "PAGES" in Term::Fabulous::Manual::TableRows.

palette (chart)

The list of colors a chart gives its series or slices in turn: default, classic, pastel, vivid or colors of your own. See "Colors, palettes and themes" in Term::Fabulous::Manual::Charts.

pixel (PixelCanvas)

Half a terminal cell: a Term::Fabulous::Widget::PixelCanvas shows two pixels per cell, one above the other. See "Drawing pixels" in Term::Fabulous::Manual::Charts.

property (KDL)

A node inside a widget node that sets one property of that widget, such as sizing or text. See "Properties" in Term::Fabulous::Manual::KDL.

raw value (table)

The value a table column reads from a row (or computes from it). Tables sort by it and filter by it unless told otherwise. See "How a table works" in Term::Fabulous::Manual::Tables.

root widget

The widget passed as root to Term::Fabulous->new; the top of the widget tree.

row id (table)

The name of a row of a Term::Fabulous::Widget::Table, used by every method and event. See "Row ids" in Term::Fabulous::Manual::Tables.

selection (table)

The set of rows of a table that the user or the program marked; not the same as the cursor. See "Selection" in Term::Fabulous::Manual::TableRows.

series (chart)

A named list of data points a chart draws in one color: a line, an area, a group of bars or a set of points. Pie charts have slices instead. See "Series and data" in Term::Fabulous::Manual::Charts.

sizing

The rule for a widget's width or height in its layout: fit (as small as the content), grow (take the room left over), fixed (a number of cells) or percent (a share of the parent). See "Sizing" in Term::Fabulous::Manual::Layout.

sizing group

Widgets with the same width_group (or height_group) number get the same width (or height); see "Equal sizes across the tree" in Term::Fabulous::Manual::Layout.

slice (chart)

One part of a pie, donut or polar area chart: a unique label and a value. The slices are the chart's series. See "Series and data" in Term::Fabulous::Manual::Charts.

slot (theme)

One part of a widget family that a theme decides, a color, a border style or whether there is a border: button.border.color, input.placeholder, divider.line.style, text_input.border.enabled. A slot has a value for the normal state and may have one for each state the widget shows (focused, disabled, ...). It defaults to a token, a style name, or true or false. See "Families, slots and states" in Term::Fabulous::Theme.

style hash (table)

A hash reference of looks and lines for a column, a row or a cell of a table, such as { text_color => '#ff0000', bold => 1 }. See "Style hashes" in Term::Fabulous::Manual::TableStyles.

subpixel (chart)

One of the dots or blocks a chart draws per terminal cell, for example the 2 x 4 Braille dots of a line or the eighth blocks of a bar. See "How a chart is drawn" in Term::Fabulous::Manual::Charts.

swatch

A named value a Term::Fabulous::Widget::ColorPicker offers in a list, with the color it stands for: a color of its own, a theme's token name, or none for no color. See "Color pickers" in Term::Fabulous::Manual::Forms.

target

The widget an event was fired on.

termbox2

The C library that controls the terminal; see Term::Fabulous::Termbox.

terminal (object)

The object through which Term::Fabulous reads input and draws: the real terminal (Term::Fabulous::Terminal::Termbox) or a terminal in memory for tests (Term::Fabulous::Terminal::Memory). See Term::Fabulous::Role::Terminal.

terminal default color

The text and background color the terminal uses when a program does not set one. Colors with alpha 0 select it.

theme

The colors, border styles and borders every widget draws with when it is not given its own: a palette of tokens and the slots of every widget family, with variants. Set per UI (Term::Fabulous->new( theme => ... )) and switched at run time; built-in: dark and light; written in theme files or in Perl. See "THEMES" in Term::Fabulous::Manual::Looks and Term::Fabulous::Theme.

theme (chart)

Whether a chart draws its text, axes and grid with a dark or a light ink, and which steps of its palette it uses; auto (the default) chooses by the background. See "Colors, palettes and themes" in Term::Fabulous::Manual::Charts.

theme file

A KDL file that describes a theme: a theme node, a palette node and one node per widget family. Loaded with "from_file" in Term::Fabulous::Theme. See "THEME FILES" in Term::Fabulous::Theme.

toggle

A command for a setting that is on or off, which a menu shows with a check mark while it is on. See "Settings that are on or off" in Term::Fabulous::Manual::Menus.

token (theme)

A named color of a theme's palette, such as accent, surface or text, which the slots default to. The background token is the screen behind the widgets, which every frame paints first. See "Tokens" in Term::Fabulous::Theme.

tree row, child row (table)

In a table with children_key, a row can have child rows, shown indented below it while it is open. See "TREES" in Term::Fabulous::Manual::TableRows.

UTF-8 byte string

Text encoded as UTF-8, where non-ASCII characters take several bytes, as produced by encode('UTF-8', $text).

variant (theme)

Slots of a widget family that apply to the widgets whose classes name the variant: a primary variant of button styles the buttons with classes => ['primary']. See "Variants and classes" in Term::Fabulous::Manual::Looks.

view (table)

The lines a table shows: its rows after filtering, grouping, sorting and flattening. See "How a table works" in Term::Fabulous::Manual::Tables.

widget

An object that is drawn on the screen and can react to events: a box, text, a button, an input, a table, a chart. See "The widgets" in Term::Fabulous::Manual::Layout.

widget id

The optional id string of a widget, unique in its tree. Clay keeps per-widget state (such as a scroll position) by it, and find_by_id finds the widget by it. See "Widget ids" in Term::Fabulous::Manual::Layout.

widget tree

The root widget, its children, their children, and so on.

The table guide defines a few more words of its own (open and closed rows, group path, row data, "passes the filters") in its list of table terms.

SEE ALSO

This page is part of Term::Fabulous::Manual. Previous page: Term::Fabulous::Manual::Troubleshooting.