FTXUI 6.1.9 C++ functional terminal UI.

Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
ftxui Namespace Reference

The FTXUI ftxui:: namespace. More...

## Namespaces
namespace | animation
| The FTXUI ftxui::animation:: namespace.
namespace | box_helper
namespace | Container
namespace | Dimension
| Define how the Screen's dimensions should look like.
namespace | flexbox_helper
namespace | literals
namespace | Terminal
namespace | util

## Classes
struct | AnimatedColorOption
| Option about a potentially animated color. More...
struct | AnimatedColorsOption
class | AnimationTask
class | AutoReset
| Assign a value to a variable, reset its old value when going out of scope. More...
struct | Box
| Box is a structure that represents a rectangular area in a 2D space. More...
struct | ButtonOption
| Option for the AnimatedButton component. More...
struct | Canvas
| Canvas is a drawable buffer associated with drawing operations. More...
class | CapturedMouseInterface
struct | CheckboxOption
| Option for the Checkbox component. More...
class | Color
| Color is a class that represents a color in the terminal user interface. More...
struct | ColorInfo
| ColorInfo is a structure that contains information about the terminal color palette. More...
class | ComponentBase
| It implement rendering itself as ftxui::Element. It implement keyboard navigation by responding to ftxui::Event. More...
class | ConstRef
| An adapter. Own or reference an immutable object. More...
class | ConstStringListRef
| An adapter. Reference a list of strings. More...
class | ConstStringRef
| An adapter. Own or reference a constant string. For convenience, this class convert multiple immutable string toward a shared representation. More...
struct | Dimensions
| Dimensions is a structure that represents the size of the terminal. More...
struct | DropdownOption
| Option for the Dropdown component.A dropdown menu is a checkbox opening/closing a radiobox. More...
struct | EntryState
| arguments for transform from |ButtonOption|, |CheckboxOption|, |RadioboxOption|, |MenuEntryOption|, |MenuOption|. More...
struct | Event
| Represent an event. It can be key press event, a terminal resize, or more ... More...
struct | FlexboxConfig
| FlexboxConfig is a configuration structure that defines the layout properties for a flexbox container. More...
class | Image
| A rectangular grid of Pixel. More...
struct | InputOption
| Option for the Input component. More...
struct | InputState
| Used to define style for the Input component. More...
struct | LinearGradient
| A class representing the settings for linear-gradient color effect. More...
class | Loop
| Loop is a class that manages the event loop for a component. More...
struct | MenuEntryOption
| Option for the MenuEntry component. More...
struct | MenuOption
| Option for the Menu component. More...
struct | Mouse
| A mouse event. It contains the coordinate of the mouse, the button pressed and the modifier (shift, ctrl, meta). More...
class | Node
| Node is the base class for all elements in the DOM tree. More...
class | NodeDecorator
struct | Pixel
| A Unicode character and its associated style. More...
struct | RadioboxOption
| Option for the Radiobox component. More...
class | ReceiverImpl
class | Ref
| An adapter. Own or reference an mutable object. More...
struct | Requirement
| Requirement is a structure that defines the layout requirements for a Node in the terminal user interface. More...
struct | ResizableSplitOption
class | Screen
| A rectangular grid of Pixel. More...
class | ScreenInteractive
| ScreenInteractive is a `Screen` that can handle events, run a main loop, and manage components. More...
class | Selection
| Represents a selection in a terminal user interface. More...
class | SenderImpl
struct | SliderOption
class | StringRef
| An adapter. Own or reference a constant string. For convenience, this class convert multiple mutable string toward a shared representation. More...
class | Table
| Table is a utility to draw tables. More...
class | TableSelection
class | TerminalInputParser
struct | UnderlineOption
| Option for the underline effect. More...
struct | WindowOptions
struct | WindowRenderState
| State passed to the `Window` component's render function. More...

## Typedefs
using | CapturedMouse = std::unique_ptr<CapturedMouseInterface>
using | ComponentDecorator = std::function<Component(Component)>
using | ElementDecorator = std::function<Element(Element)>
using | Component = std::shared_ptr<ComponentBase>
using | Components = std::vector<Component>
template<class T >
using | Sender = std::unique_ptr<SenderImpl<T>>
template<class T >
using | Receiver = std::unique_ptr<ReceiverImpl<T>>
using | Closure = std::function<void()>
using | Task = std::variant<Event, Closure, AnimationTask>
using | Element = std::shared_ptr<Node>
using | Elements = std::vector<Element>
using | Decorator = std::function<Element(Element)>
using | GraphFunction = std::function<std::vector<int>(int, int)>

## Enumerations
enum class | Direction { Up = 0 , Down = 1 , Left = 2 , Right = 3 }
| Direction is an enumeration that represents the four cardinal directions. More...
enum | BorderStyle { LIGHT , DASHED , HEAVY , DOUBLE , ROUNDED , EMPTY }
| BorderStyle is an enumeration that represents the different styles of borders that can be applied to elements in the terminal UI. More...
enum | WidthOrHeight { WIDTH , HEIGHT }
enum | Constraint { LESS_THAN , EQUAL , GREATER_THAN }
enum class | WordBreakProperty : int8_t { ALetter , CR , Double_Quote , Extend , ExtendNumLet , Format , Hebrew_Letter , Katakana , LF , MidLetter , MidNum , MidNumLet , Newline , Numeric , Regional_Indicator , Single_Quote , WSegSpace , ZWJ }

## Functions
template<class T , class... Args>
std::shared_ptr< T > | Make (Args &&... args)
Component | operator| (Component component, ComponentDecorator decorator)
Component | operator| (Component component, ElementDecorator decorator)
Component & | operator|= (Component &component, ComponentDecorator decorator)
Component & | operator|= (Component &component, ElementDecorator decorator)
Component | Button (ButtonOption option)
| Draw a button. Execute a function when clicked.
Component | Button (ConstStringRef label, std::function< void()> on_click, ButtonOption option)
| Draw a button. Execute a function when clicked.
Component | Checkbox (CheckboxOption option)
| Draw checkable element.
Component | Checkbox (ConstStringRef label, bool *checked, CheckboxOption option)
| Draw checkable element.
Component | Input (InputOption option)
| An input box for editing text.
Component | Input (StringRef content, InputOption option)
| An input box for editing text.
Component | Input (StringRef content, StringRef placeholder, InputOption option)
| An input box for editing text.
Component | Menu (MenuOption option)
| A list of text. The focused element is selected.
Component | Menu (ConstStringListRef entries, int *selected, MenuOption option)
| A list of text. The focused element is selected.
Component | MenuEntry (MenuEntryOption option)
| A specific menu entry. They can be put into a Container::Vertical to form a menu.
Component | MenuEntry (ConstStringRef label, MenuEntryOption option)
| A specific menu entry. They can be put into a Container::Vertical to form a menu.
Component | Radiobox (RadioboxOption option)
| A list of element, where only one can be selected.
Component | Radiobox (ConstStringListRef entries, int *selected, RadioboxOption option)
| A list of element, where only one can be selected.
Component | Dropdown (ConstStringListRef entries, int *selected)
| A dropdown menu.
Component | Dropdown (DropdownOption option)
| A dropdown menu.
Component | Toggle (ConstStringListRef entries, int *selected)
| An horizontal list of elements. The user can navigate through them.
template<typename T >
Component | Slider (SliderOption< T > options)
| A slider in any direction.
Component | Slider (ConstStringRef label, Ref< int > value, ConstRef< int > min, ConstRef< int > max, ConstRef< int > increment)
| An horizontal slider.
Component | Slider (ConstStringRef label, Ref< float > value, ConstRef< float > min=0.f, ConstRef< float > max=100.f, ConstRef< float > increment=5.f)
Component | Slider (ConstStringRef label, Ref< long > value, ConstRef< long > min=0L, ConstRef< long > max=100L, ConstRef< long > increment=5L)
Component | ResizableSplit (ResizableSplitOption options)
| A split in between two components.
Component | ResizableSplitLeft (Component main, Component back, int *main_size)
| An horizontal split in between two components, configurable using the mouse.
Component | ResizableSplitRight (Component main, Component back, int *main_size)
| An horizontal split in between two components, configurable using the mouse.
Component | ResizableSplitTop (Component main, Component back, int *main_size)
| An vertical split in between two components, configurable using the mouse.
Component | ResizableSplitBottom (Component main, Component back, int *main_size)
| An vertical split in between two components, configurable using the mouse.
Component | Renderer (Component child, std::function< Element()> render)
| Return a new Component, similar to |child|, but using |render| as the Component::Render() event.
Component | Renderer (std::function< Element()> render)
| Return a component, using |render| to render its interface.
Component | Renderer (std::function< Element(bool)> render)
| Return a focusable component, using |render| to render its interface.
ComponentDecorator | Renderer (ElementDecorator decorator)
| Decorate a component, by decorating what it renders.
Component | CatchEvent (Component child, std::function< bool(Event)>)
ComponentDecorator | CatchEvent (std::function< bool(Event)> on_event)
| Decorate a component, using |on_event| to catch events. This function must returns true when the event has been handled, false otherwise.
Component | Maybe (Component child, const bool *show)
| Decorate a component |child|. It is shown only when |show| is true.
Component | Maybe (Component child, std::function< bool()> show)
| Decorate a component |child|. It is shown only when |show| returns true.
ComponentDecorator | Maybe (const bool *show)
| Decorate a component. It is shown only when |show| is true.
ComponentDecorator | Maybe (std::function< bool()> show)
| Decorate a component. It is shown only when the |show| function returns true.
Component | Modal (Component main, Component modal, const bool *show_modal)
ComponentDecorator | Modal (Component modal, const bool *show_modal)
Component | Collapsible (ConstStringRef label, Component child, Ref< bool > show)
| A collapsible component. It displays a checkbox with an arrow. Once activated, the child is displayed.
Component | Hoverable (Component component, bool *hover)
| Wrap a component. Gives the ability to know if it is hovered by the mouse.
Component | Hoverable (Component component, std::function< void()> on_enter, std::function< void()> on_leave)
| Wrap a component. Uses callbacks.
Component | Hoverable (Component component, std::function< void(bool)> on_change)
| Wrap a component. Gives the ability to know if it is hovered by the mouse.
ComponentDecorator | Hoverable (bool *hover)
| Wrap a component. Gives the ability to know if it is hovered by the mouse.
ComponentDecorator | Hoverable (std::function< void()> on_enter, std::function< void()> on_leave)
| Wrap a component. Gives the ability to know if it is hovered by the mouse.
ComponentDecorator | Hoverable (std::function< void(bool)> on_change)
| Wrap a component. Gives the ability to know if it is hovered by the mouse.
Component | Window (WindowOptions option)
| A draggeable / resizeable window. To use multiple of them, they must be stacked using `Container::Stacked({...})` component;.
template<class T >
Receiver< T > | MakeReceiver ()
Element | text (std::wstring text)
| Display a piece of unicode text.
Element | vtext (std::wstring text)
| Display a piece unicode text vertically.
Elements | paragraph (std::wstring text)
Element | operator| (Element element, Decorator decorator)
| From an element, apply a decorator.
Element & | operator|= (Element &e, Decorator d)
| Apply a decorator to an element.
Elements | operator| (Elements elements, Decorator decorator)
| From a set of element, apply a decorator to every elements.
Decorator | operator| (Decorator a, Decorator b)
| Compose two decorator into one.
Element | text (std::string text)
| Display a piece of UTF8 encoded unicode text.
Element | vtext (std::string text)
| Display a piece of unicode text vertically.
Element | separator ()
| Draw a vertical or horizontal separation in between two other elements.
Element | separatorLight ()
| Draw a vertical or horizontal separation in between two other elements, using the LIGHT style.
Element | separatorDashed ()
| Draw a vertical or horizontal separation in between two other elements, using the DASHED style.
Element | separatorHeavy ()
| Draw a vertical or horizontal separation in between two other elements, using the HEAVY style.
Element | separatorDouble ()
| Draw a vertical or horizontal separation in between two other elements, using the DOUBLE style.
Element | separatorEmpty ()
| Draw a vertical or horizontal separation in between two other elements, using the EMPTY style.
Element | separatorStyled (BorderStyle style)
| Draw a vertical or horizontal separation in between two other elements.
Element | separator (Pixel pixel)
| Draw a separator in between two element filled with a given pixel.
Element | separatorCharacter (std::string value)
| Draw a vertical or horizontal separation in between two other elements.
Element | separatorHSelector (float left, float right, Color unselected_color, Color selected_color)
| Draw a horizontal bar, with the area in between left/right colored differently.
Element | separatorVSelector (float up, float down, Color unselected_color, Color selected_color)
| Draw an vertical bar, with the area in between up/downcolored differently.
Element | gauge (float progress)
| Draw a high definition progress bar.
Element | gaugeLeft (float progress)
| Draw a high definition progress bar progressing from right to left.
Element | gaugeRight (float progress)
| Draw a high definition progress bar progressing from left to right.
Element | gaugeUp (float progress)
| Draw a high definition progress bar progressing from bottom to top.
Element | gaugeDown (float progress)
| Draw a high definition progress bar progressing from top to bottom.
Element | gaugeDirection (float progress, Direction direction)
| Draw a high definition progress bar progressing in specified direction.
Element | border (Element child)
| Draw a border around the element.
Element | borderLight (Element child)
| Draw a light border around the element.
Element | borderDashed (Element child)
| Draw a dashed border around the element.
Element | borderHeavy (Element child)
| Draw a heavy border around the element.
Element | borderDouble (Element child)
| Draw a double border around the element.
Element | borderRounded (Element child)
| Draw a rounded border around the element.
Element | borderEmpty (Element child)
| Draw an empty border around the element.
Decorator | borderStyled (BorderStyle style)
| Same as border but with different styles.
Decorator | borderStyled (BorderStyle style, Color foreground_color)
| Same as border but with a foreground color and a different style.
Decorator | borderStyled (Color foreground_color)
| Same as border but with a foreground color.
Decorator | borderWith (const Pixel &pixel)
| Same as border but with a constant Pixel around the element.
Element | window (Element title, Element content, BorderStyle border)
| Draw window with a title and a border around the element.
Element | spinner (int charset_index, size_t image_index)
| Useful to represent the effect of time and/or events. This displays an ASCII art "video".
Element | paragraph (const std::string &the_text)
| Return an element drawing the paragraph on multiple lines.
Element | paragraphAlignLeft (const std::string &the_text)
| Return an element drawing the paragraph on multiple lines, aligned on the left.
Element | paragraphAlignRight (const std::string &the_text)
| Return an element drawing the paragraph on multiple lines, aligned on the right.
Element | paragraphAlignCenter (const std::string &the_text)
| Return an element drawing the paragraph on multiple lines, aligned on the center.
Element | paragraphAlignJustify (const std::string &the_text)
| Return an element drawing the paragraph on multiple lines, aligned using a justified alignment. the center.
Element | graph (GraphFunction graph_function)
| Draw a graph using a GraphFunction.
Element | emptyElement ()
Element | canvas (ConstRef< Canvas > canvas)
| Produce an element from a Canvas, or a reference to a Canvas.
Element | canvas (int width, int height, std::function< void(Canvas &)> fn)
| Produce an element drawing a canvas of requested size.
Element | canvas (std::function< void(Canvas &)> fn)
| Produce an element drawing a canvas.
Element | bold (Element child)
| Use a bold font, for elements with more emphasis.
Element | dim (Element child)
| Use a light font, for elements with less emphasis.
Element | italic (Element child)
| Apply a underlinedDouble to text.
Element | inverted (Element child)
| Add a filter that will invert the foreground and the background colors.
Element | underlined (Element child)
| Underline the given element.
Element | underlinedDouble (Element child)
| Apply a underlinedDouble to text.
Element | blink (Element child)
| The text drawn alternates in between visible and hidden.
Element | strikethrough (Element child)
| Apply a strikethrough to text.
Decorator | color (Color c)
| Decorate using a foreground color.
Decorator | bgcolor (Color color)
| Decorate using a background color.
Decorator | color (const LinearGradient &gradient)
| Decorate using a linear-gradient effect on the foreground color.
Decorator | bgcolor (const LinearGradient &gradient)
| Decorate using a linear-gradient effect on the background color.
Element | color (Color color, Element child)
| Set the foreground color of an element.
Element | bgcolor (Color color, Element child)
| Set the background color of an element.
Element | color (const LinearGradient &gradient, Element child)
| Set the foreground color of an element with linear-gradient effect.
Element | bgcolor (const LinearGradient &gradient, Element child)
| Set the background color of an element with linear-gradient effect.
Decorator | focusPosition (int x, int y)
| Used inside a `frame`, this force the view to be scrolled toward a a given position. The position is expressed in the numbers of cells.
Decorator | focusPositionRelative (float x, float y)
| Used inside a `frame`, this force the view to be scrolled toward a a given position. The position is expressed in proportion of the requested size.
Element | automerge (Element child)
| Enable character to be automatically merged with others nearby.
Decorator | hyperlink (std::string link)
| Decorate using a hyperlink. The link will be opened when the user clicks on it. This is supported only on a limited set of terminal emulators. List: https://github.com/Alhadis/OSC8-Adoption/.
Element | hyperlink (std::string link, Element child)
| Make the rendered area clickable using a web browser. The link will be opened when the user clicks on it. This is supported only on a limited set of terminal emulators. List: https://github.com/Alhadis/OSC8-Adoption/.
Element | selectionStyleReset (Element child)
| Reset the selection style of an element.
Decorator | selectionColor (Color foreground)
| Set the color of an element when selected.
Decorator | selectionBackgroundColor (Color foreground)
| Set the background color of an element when selected. Note that the style is applied on top of the existing style.
Decorator | selectionForegroundColor (Color foreground)
| Set the foreground color of an element when selected. Note that the style is applied on top of the existing style.
Decorator | selectionStyle (std::function< void(Pixel &)> style)
| Set the style of an element when selected.
Element | hbox (Elements children)
| A container displaying elements horizontally one by one.
Element | vbox (Elements children)
| A container displaying elements vertically one by one.
Element | dbox (Elements children_)
| Stack several element on top of each other.
Element | flexbox (Elements children, FlexboxConfig config)
| A container displaying elements on row/columns and capable of wrapping on the next column/row when full.
Element | gridbox (std::vector< Elements > lines)
| A container displaying a grid of elements.
Element | hflow (Elements children)
| A container displaying elements in rows from left to right. When filled, it starts on a new row below.
Element | vflow (Elements children)
| A container displaying elements in rows from top to bottom. When filled, it starts on a new columns on the right. filled, it starts on a new row. is full, it starts a new row.
Element | flex (Element child)
| Make a child element to expand proportionally to the space left in a container.
Element | flex_grow (Element child)
| Expand if possible.
Element | flex_shrink (Element child)
| Minimize if needed.
Element | xflex (Element child)
| Expand/Minimize if possible/needed on the X axis.
Element | xflex_grow (Element child)
| Expand if possible on the X axis.
Element | xflex_shrink (Element child)
| Minimize if needed on the X axis.
Element | yflex (Element child)
| Expand/Minimize if possible/needed on the Y axis.
Element | yflex_grow (Element child)
| Expand if possible on the Y axis.
Element | yflex_shrink (Element child)
| Minimize if needed on the Y axis.
Element | notflex (Element child)
| Make the element not flexible.
Element | filler ()
| An element that will take expand proportionally to the space left in a container.
Decorator | size (WidthOrHeight direction, Constraint constraint, int value)
| Apply a constraint on the size of an element.
Element | frame (Element child)
| Allow an element to be displayed inside a 'virtual' area. It size can be larger than its container. In this case only a smaller portion is displayed. The view is scrollable to make the focused element visible.
Element | xframe (Element child)
| Same as `frame`, but only on the x-axis.
Element | yframe (Element child)
| Same as `frame`, but only on the y-axis.
Element | focus (Element child)
| Set the `child` to be the one focused among its siblings.
Element | select (Element child)
| Set the `child` to be the one focused among its siblings.
Element | focusCursorBlock (Element child)
| Same as `focus`, but set the cursor shape to be a still block.
Element | focusCursorBlockBlinking (Element child)
| Same as `focus`, but set the cursor shape to be a blinking block.
Element | focusCursorBar (Element child)
| Same as `focus`, but set the cursor shape to be a still block.
Element | focusCursorBarBlinking (Element child)
| Same as `focus`, but set the cursor shape to be a blinking bar.
Element | focusCursorUnderline (Element child)
| Same as `focus`, but set the cursor shape to be a still underline.
Element | focusCursorUnderlineBlinking (Element child)
| Same as `focus`, but set the cursor shape to be a blinking underline.
Element | vscroll_indicator (Element child)
| Display a vertical scrollbar on the right. Colors follow the content.
Element | hscroll_indicator (Element child)
| Display a horizontal scrollbar at the bottom. Colors follow the content.
Decorator | reflect (Box &box)
Element | clear_under (Element element)
| Before drawing |child|, clear the pixels below. This is useful in combination with dbox.
Element | hcenter (Element child)
| Center an element horizontally.
Element | vcenter (Element child)
| Center an element vertically.
Element | center (Element child)
| Center an element horizontally and vertically.
Element | align_right (Element child)
| Align an element on the right side.
Element | nothing (Element element)
| A decoration doing absolutely nothing.
void | Render (Screen &screen, const Element &element)
| Display an element on a ftxui::Screen.
void | Render (Screen &screen, Node *node)
| Display an element on a ftxui::Screen.
void | Render (Screen &screen, Node *node, Selection &selection)
std::string | GetNodeSelectedContent (Screen &screen, Node *node, Selection &selection)
Color | operator""_rgb (unsigned long long int combined)
| Creates a color from a combined hex RGB representation, e.g. 0x808000_rgb.
ColorInfo | GetColorInfo (Color::Palette256 index)
ColorInfo | GetColorInfo (Color::Palette16 index)
int | wchar_width (wchar_t)
int | wstring_width (const std::wstring &)
std::string | to_string (const std::wstring &s)
| Convert a std::wstring into a UTF8 std::string.
std::wstring | to_wstring (const std::string &s)
| Convert a UTF8 std::string into a std::wstring.
template<typename T >
std::wstring | to_wstring (T s)
int | string_width (const std::string &)
std::vector< std::string > | Utf8ToGlyphs (const std::string &input)
std::vector< int > | CellToGlyphIndex (const std::string &input)
Component | CatchEvent (Component child, std::function< bool(Event event)> on_event)
| Return a component, using |on_event| to catch events. This function must returns true when the event has been handled, false otherwise.
template Component | Slider (SliderOption< int8_t >)
template Component | Slider (SliderOption< int16_t >)
template Component | Slider (SliderOption< int32_t >)
template Component | Slider (SliderOption< int64_t >)
template Component | Slider (SliderOption< uint8_t >)
template Component | Slider (SliderOption< uint16_t >)
template Component | Slider (SliderOption< uint32_t >)
template Component | Slider (SliderOption< uint64_t >)
template Component | Slider (SliderOption< float >)
template Component | Slider (SliderOption< double >)
bool | EatCodePoint (const std::string &input, size_t start, size_t *end, uint32_t *ucs)
bool | EatCodePoint (const std::wstring &input, size_t start, size_t *end, uint32_t *ucs)
bool | IsCombining (uint32_t ucs)
bool | IsFullWidth (uint32_t ucs)
bool | IsControl (uint32_t ucs)
WordBreakProperty | CodepointToWordBreakProperty (uint32_t codepoint)
size_t | GlyphPrevious (const std::string &input, size_t start)
size_t | GlyphNext (const std::string &input, size_t start)
size_t | GlyphIterate (const std::string &input, int glyph_offset, size_t start)
int | GlyphCount (const std::string &input)
std::vector< WordBreakProperty > | Utf8ToWordBreakProperty (const std::string &input)
bool | IsWordBreakingCharacter (const std::string &input, size_t glyph_index)

## Variables
const std::map< std::string, std::string > | g_uniformize
const std::array< ColorInfo, 256 > | palette256

## Detailed Description

The FTXUI ftxui:: namespace.

## Typedef Documentation

## ◆ CapturedMouse

using CapturedMouse = std::unique_ptr<CapturedMouseInterface>

Definition at line 20 of file captured_mouse.hpp.

## ◆ ComponentDecorator

using ComponentDecorator = std::function<Component(Component)>

Definition at line 31 of file component.hpp.

## ◆ ElementDecorator

using ElementDecorator = std::function<Element(Element)>

Definition at line 32 of file component.hpp.

## ◆ Component

typedef std::shared_ptr< ComponentBase > Component = std::shared_ptr<ComponentBase>

Definition at line 24 of file component_base.hpp.

## ◆ Components

using Components = std::vector<Component>

Definition at line 25 of file component_base.hpp.

## ◆ Sender

template<class T >

using Sender = std::unique_ptr<SenderImpl<T>>

Definition at line 45 of file receiver.hpp.

## ◆ Receiver

template<class T >

using Receiver = std::unique_ptr<ReceiverImpl<T>>

Definition at line 46 of file receiver.hpp.

## ◆ Closure

using Closure = std::function<void()>

Definition at line 13 of file task.hpp.

## ◆ Task

using Task = std::variant<Event, Closure, AnimationTask>

Definition at line 14 of file task.hpp.

## ◆ Element

typedef std::shared_ptr< Node > Element = std::shared_ptr<Node>

Definition at line 22 of file elements.hpp.

## ◆ Elements

typedef std::vector< Element > Elements = std::vector<Element>

Definition at line 23 of file elements.hpp.

## ◆ Decorator

using Decorator = std::function<Element(Element)>

Definition at line 24 of file elements.hpp.

## ◆ GraphFunction

using GraphFunction = std::function<std::vector<int>(int, int)>

Definition at line 25 of file elements.hpp.

## Enumeration Type Documentation

## ◆ WidthOrHeight

enum WidthOrHeight

Enumerator
WIDTH |
HEIGHT |

Definition at line 161 of file elements.hpp.

## ◆ Constraint

enum Constraint

Enumerator
LESS_THAN |
EQUAL |
GREATER_THAN |

Definition at line 162 of file elements.hpp.

## ◆ WordBreakProperty

enum class WordBreakProperty : int8_t
| strong

Enumerator
ALetter |
CR |
Double_Quote |
Extend |
ExtendNumLet |
Format |
Hebrew_Letter |
Katakana |
LF |
MidLetter |
MidNum |
MidNumLet |
Newline |
Numeric |
Regional_Indicator |
Single_Quote |
WSegSpace |
ZWJ |

Definition at line 40 of file string_internal.hpp.

## Function Documentation

## ◆ Make()

template<class T , class... Args>

std::shared_ptr< T > Make | ( | Args &&... | args | ) |

Definition at line 26 of file component.hpp.

## ◆ operator|() [1/2]

Component operator| | ( | Component | component,
|  | ComponentDecorator | decorator )

Definition at line 12 of file component/util.cpp.

## ◆ operator|() [2/2]

Component operator| | ( | Component | component,
|  | ElementDecorator | decorator )

Definition at line 17 of file component/util.cpp.

## ◆ operator|=() [1/2]

Component & operator|= | ( | Component & | component,
|  | ComponentDecorator | decorator )

Definition at line 22 of file component/util.cpp.

## ◆ operator|=() [2/2]

Component & operator|= | ( | Component & | component,
|  | ElementDecorator | decorator )

Definition at line 28 of file component/util.cpp.

## ◆ Slider() [1/13]

template<typename T >

Component Slider | ( | SliderOption< T > | options | ) |

A slider in any direction.

Parameters

  options | The options

### Example

auto screen = ScreenInteractive::TerminalOutput();
int value = 50;
auto slider = Slider({
.value = &value,
.min = 0,
.max = 100,
.increment= 20,
});
screen.Loop(slider);
ftxui::ScreenInteractive::TerminalOutput
static ScreenInteractive TerminalOutput()
Definition screen_interactive.cpp:410
ftxui::Slider
Component Slider(SliderOption< T > options)
A slider in any direction.
Definition src/ftxui/component/slider.cpp:346

Definition at line 346 of file src/ftxui/component/slider.cpp.

## ◆ Slider() [2/13]

Component Slider | ( | ConstStringRef | label,
|  | Ref< float > | value,
|  | ConstRef< float > | min = 0.f,
|  | ConstRef< float > | max = 100.f,
|  | ConstRef< float > | increment = 5.f )

Definition at line 303 of file src/ftxui/component/slider.cpp.

## ◆ Slider() [3/13]

Component Slider | ( | ConstStringRef | label,
|  | Ref< long > | value,
|  | ConstRef< long > | min = 0L,
|  | ConstRef< long > | max = 100L,
|  | ConstRef< long > | increment = 5L )

Definition at line 316 of file src/ftxui/component/slider.cpp.

## ◆ ResizableSplit()

Component ResizableSplit | ( | ResizableSplitOption | options | ) |

A split in between two components.

Parameters

  options | all the parameters.

### Example

auto left = Renderer([] { return text("Left") | center;});
auto right = Renderer([] { return text("right") | center;});
int left_size = 10;
auto component = ResizableSplit({
.main = left,
.back = right,
.direction = Direction::Left,
.main_size = &left_size,
.separator_func = [] { return separatorDouble(); },
});
ftxui::Renderer
Component Renderer(Component child, std::function< Element()>)
Return a new Component, similar to |child|, but using |render| as the Component::Render() event.
Definition src/ftxui/component/renderer.cpp:61
ftxui::center
Element center(Element)
Center an element horizontally and vertically.
Definition composite_decorator.cpp:31
ftxui::text
Element text(std::wstring text)
Display a piece of unicode text.
Definition text.cpp:160
ftxui::separatorDouble
Element separatorDouble()
Draw a vertical or horizontal separation in between two other elements, using the DOUBLE style.
Definition src/ftxui/dom/separator.cpp:320
ftxui::Direction::Left
@ Left
ftxui::ResizableSplit
Component ResizableSplit(ResizableSplitOption options)
A split in between two components.
Definition src/ftxui/component/resizable_split.cpp:186
left
std::uint8_t left
Definition screen.cpp:129
right
std::uint8_t right
Definition screen.cpp:131

### Output

║
left ║ right
║

Definition at line 186 of file src/ftxui/component/resizable_split.cpp.

## ◆ CatchEvent()

Component CatchEvent | ( | Component | child,
|  | std::function< bool(Event)> | )

## ◆ Collapsible()

Component Collapsible | ( | ConstStringRef | label,
|  | Component | child,
|  | Ref< bool > | show )

A collapsible component. It displays a checkbox with an arrow. Once activated, the child is displayed.

Parameters

  label | The label of the checkbox.
  child | The child to display.
  show | Hold the state about whether the child is displayed or not.

### Example

auto component = Collapsible("Show details", details);
ftxui::Collapsible
Component Collapsible(ConstStringRef label, Component child, Ref< bool > show=false)
A collapsible component. It displays a checkbox with an arrow. Once activated, the child is displayed...
Definition src/ftxui/component/collapsible.cpp:33

### Output

▼ Show details
<details component>

Definition at line 33 of file src/ftxui/component/collapsible.cpp.

## ◆ MakeReceiver()

template<class T >

Receiver< T > MakeReceiver | ( |  | ) |

Definition at line 139 of file receiver.hpp.

## ◆ paragraph()

Elements paragraph | ( | std::wstring | text | ) |

## ◆ separatorHSelector()

Element separatorHSelector | ( | float | left,
|  | float | right,
|  | Color | unselected_color,
|  | Color | selected_color )

Draw a horizontal bar, with the area in between left/right colored differently.

Parameters

  left | the left limit of the active area.
  right | the right limit of the active area.
  selected_color | the color of the selected area.
  unselected_color | the color of the unselected area.

### Example

Element document = separatorHSelector(2,5, Color::White, Color::Blue);
ftxui::Color::White
@ White
Definition color.hpp:69
ftxui::Color::Blue
@ Blue
Definition color.hpp:58
ftxui::Element
std::shared_ptr< Node > Element
Definition elements.hpp:22
ftxui::separatorHSelector
Element separatorHSelector(float left, float right, Color unselected_color, Color selected_color)
Draw a horizontal bar, with the area in between left/right colored differently.
Definition src/ftxui/dom/separator.cpp:442

Definition at line 442 of file src/ftxui/dom/separator.cpp.

## ◆ separatorVSelector()

Element separatorVSelector | ( | float | up,
|  | float | down,
|  | Color | unselected_color,
|  | Color | selected_color )

Draw an vertical bar, with the area in between up/downcolored differently.

Parameters

  up | the left limit of the active area.
  down | the right limit of the active area.
  selected_color | the color of the selected area.
  unselected_color | the color of the unselected area.

### Example

Element document = separatorHSelector(2,5, Color::White, Color::Blue);

Definition at line 512 of file src/ftxui/dom/separator.cpp.

## ◆ graph()

Element graph | ( | GraphFunction | graph_function | ) |

Draw a graph using a GraphFunction.

Parameters

  graph_function | the function to be called to get the data.

Definition at line 71 of file src/ftxui/dom/graph.cpp.

## ◆ canvas() [1/3]

Element canvas | ( | ConstRef< Canvas > | canvas | ) |

Produce an element from a Canvas, or a reference to a Canvas.

Definition at line 891 of file src/ftxui/dom/canvas.cpp.

## ◆ canvas() [2/3]

Element canvas | ( | int | width,
|  | int | height,
|  | std::function< void(Canvas &)> | fn )

Produce an element drawing a canvas of requested size.

Parameters

  width | the width of the canvas.
  height | the height of the canvas.
  fn | a function drawing the canvas.

Definition at line 908 of file src/ftxui/dom/canvas.cpp.

## ◆ canvas() [3/3]

Element canvas | ( | std::function< void(Canvas &)> | fn | ) |

Produce an element drawing a canvas.

Parameters

  fn | a function drawing the canvas.

Definition at line 938 of file src/ftxui/dom/canvas.cpp.

## ◆ selectionStyleReset()

Element selectionStyleReset | ( | Element | child | ) |

Reset the selection style of an element.

Parameters

  child | The input element.

Returns
  The output element with the selection style reset.

Definition at line 55 of file selection_style.cpp.

## ◆ selectionColor()

Decorator selectionColor | ( | Color | foreground | ) |

Set the color of an element when selected.

Parameters

  foreground | The color to be applied. Note that the style is applied on top of the existing style.

Definition at line 78 of file selection_style.cpp.

## ◆ selectionBackgroundColor()

Decorator selectionBackgroundColor | ( | Color | foreground | ) |

Set the background color of an element when selected. Note that the style is applied on top of the existing style.

Definition at line 61 of file selection_style.cpp.

## ◆ selectionForegroundColor()

Decorator selectionForegroundColor | ( | Color | foreground | ) |

Set the foreground color of an element when selected. Note that the style is applied on top of the existing style.

Definition at line 69 of file selection_style.cpp.

## ◆ selectionStyle()

Decorator selectionStyle | ( | std::function< void(Pixel &)> | style | ) |

Set the style of an element when selected.

Parameters

  style | The style to be applied. Note that the style is applied on top of the existing style.

Definition at line 86 of file selection_style.cpp.

## ◆ hbox()

Element hbox | ( | Elements | children | ) |

A container displaying elements horizontally one by one.

Parameters

  children | The elements in the container

Returns
  The container.

#### Example

hbox({
text("Left"),
text("Right"),
});
ftxui::hbox
Element hbox(Elements)
A container displaying elements horizontally one by one.
Definition hbox.cpp:94

Definition at line 94 of file hbox.cpp.

## ◆ flexbox()

Element flexbox | ( | Elements | children,
|  | FlexboxConfig | config )

A container displaying elements on row/columns and capable of wrapping on the next column/row when full.

Parameters

  children | The elements in the container
  config | The option

Returns
  The container.

#### Example

flexbox({
text("element 1"),
text("element 2"),
text("element 3"),
}, FlexboxConfig()
.Set(FlexboxConfig::Direction::Column)
.Set(FlexboxConfig::Wrap::WrapInversed)
.SetGapMainAxis(1)
.SetGapCrossAxis(1)
)
ftxui::FlexboxConfig::Direction::Column
@ Column
Flex items are laid out in a column.
ftxui::FlexboxConfig::Wrap::WrapInversed
@ WrapInversed
ftxui::flexbox
Element flexbox(Elements, FlexboxConfig config=FlexboxConfig())
A container displaying elements on row/columns and capable of wrapping on the next column/row when fu...
Definition flexbox.cpp:251

Definition at line 251 of file flexbox.cpp.

## ◆ gridbox()

Element gridbox | ( | std::vector< Elements > | lines | ) |

A container displaying a grid of elements.

Parameters

  lines | A list of lines, each line being a list of elements.

Returns
  The container.

#### Example

auto cell = [](const char* t) { return text(t) | border; };
auto document = gridbox({
{cell("north-west") , cell("north") , cell("north-east")} ,
{cell("west") , cell("center") , cell("east")} ,
{cell("south-west") , cell("south") , cell("south-east")} ,
});
ftxui::border
Element border(Element)
Draw a border around the element.
Definition src/ftxui/dom/border.cpp:227
ftxui::gridbox
Element gridbox(std::vector< Elements > lines)
A container displaying a grid of elements.
Definition src/ftxui/dom/gridbox.cpp:173

Output:

╭──────────╮╭──────╮╭──────────╮
│north-west││north ││north-east│
╰──────────╯╰──────╯╰──────────╯
╭──────────╮╭──────╮╭──────────╮
│west ││center││east │
╰──────────╯╰──────╯╰──────────╯
╭──────────╮╭──────╮╭──────────╮
│south-west││south ││south-east│
╰──────────╯╰──────╯╰──────────╯

Definition at line 173 of file src/ftxui/dom/gridbox.cpp.

## ◆ hflow()

Element hflow | ( | Elements | children | ) |

A container displaying elements in rows from left to right. When filled, it starts on a new row below.

Parameters

  children | The elements in the container

Returns
  The container.

#### Example

hflow({
text("element 1"),
text("element 2"),
text("element 3"),
});
ftxui::hflow
Element hflow(Elements)
A container displaying elements in rows from left to right. When filled, it starts on a new row below...
Definition flexbox.cpp:269

Definition at line 269 of file flexbox.cpp.

## ◆ vflow()

Element vflow | ( | Elements | children | ) |

A container displaying elements in rows from top to bottom. When filled, it starts on a new columns on the right. filled, it starts on a new row. is full, it starts a new row.

Parameters

  children | The elements in the container

Returns
  The container.

#### Example

vflow({
text("element 1"),
text("element 2"),
text("element 3"),
});
ftxui::vflow
Element vflow(Elements)
A container displaying elements in rows from top to bottom. When filled, it starts on a new columns o...
Definition flexbox.cpp:289

Definition at line 289 of file flexbox.cpp.

## ◆ frame()

Element frame | ( | Element | child | ) |

Allow an element to be displayed inside a 'virtual' area. It size can be larger than its container. In this case only a smaller portion is displayed. The view is scrollable to make the focused element visible.

See also
  frame
  xframe
  yframe

Definition at line 118 of file frame.cpp.

## ◆ xframe()

Element xframe | ( | Element | child | ) |

Same as `frame`, but only on the x-axis.

See also
  frame
  xframe
  yframe

Definition at line 126 of file frame.cpp.

## ◆ yframe()

Element yframe | ( | Element | child | ) |

Same as `frame`, but only on the y-axis.

See also
  frame
  xframe
  yframe

Definition at line 134 of file frame.cpp.

## ◆ select()

Element select | ( | Element | child | ) |

Set the `child` to be the one focused among its siblings.

This is deprecated. Use `focus` instead.

Parameters

  child | The element to be focused.

Definition at line 108 of file frame.cpp.

## ◆ reflect()

Decorator reflect | ( | Box & | box | ) |

Definition at line 43 of file reflect.cpp.

## ◆ Render()

void Render | ( | Screen & | screen,
|  | Node * | node,
|  | Selection & | selection )

Definition at line 96 of file node.cpp.

## ◆ GetNodeSelectedContent()

std::string GetNodeSelectedContent | ( | Screen & | screen,
|  | Node * | node,
|  | Selection & | selection )

Definition at line 168 of file node.cpp.

## ◆ GetColorInfo() [1/2]

ColorInfo GetColorInfo | ( | Color::Palette256 | index | ) |

Definition at line 272 of file color_info.cpp.

## ◆ GetColorInfo() [2/2]

ColorInfo GetColorInfo | ( | Color::Palette16 | index | ) |

Definition at line 276 of file color_info.cpp.

## ◆ wchar_width()

int wchar_width | ( | wchar_t | ucs | ) |

Definition at line 1313 of file string.cpp.

## ◆ wstring_width()

int wstring_width | ( | const std::wstring & | text | ) |

Definition at line 1317 of file string.cpp.

## ◆ to_string()

std::string to_string | ( | const std::wstring & | s | ) |

Convert a std::wstring into a UTF8 std::string.

Definition at line 1565 of file string.cpp.

## ◆ to_wstring() [1/2]

std::wstring to_wstring | ( | const std::string & | s | ) |

Convert a UTF8 std::string into a std::wstring.

Definition at line 1637 of file string.cpp.

## ◆ to_wstring() [2/2]

template<typename T >

std::wstring to_wstring | ( | T | s | ) |

Definition at line 15 of file string.hpp.

## ◆ string_width()

int string_width | ( | const std::string & | input | ) |

Definition at line 1330 of file string.cpp.

## ◆ Utf8ToGlyphs()

std::vector< std::string > Utf8ToGlyphs | ( | const std::string & | input | ) |

Definition at line 1357 of file string.cpp.

## ◆ CellToGlyphIndex()

std::vector< int > CellToGlyphIndex | ( | const std::string & | input | ) |

Definition at line 1464 of file string.cpp.

## ◆ Slider() [4/13]

template Component Slider | ( | SliderOption< int8_t > |  | ) |

## ◆ Slider() [5/13]

template Component Slider | ( | SliderOption< int16_t > |  | ) |

## ◆ Slider() [6/13]

template Component Slider | ( | SliderOption< int32_t > |  | ) |

## ◆ Slider() [7/13]

template Component Slider | ( | SliderOption< int64_t > |  | ) |

## ◆ Slider() [8/13]

template Component Slider | ( | SliderOption< uint8_t > |  | ) |

## ◆ Slider() [9/13]

template Component Slider | ( | SliderOption< uint16_t > |  | ) |

## ◆ Slider() [10/13]

template Component Slider | ( | SliderOption< uint32_t > |  | ) |

## ◆ Slider() [11/13]

template Component Slider | ( | SliderOption< uint64_t > |  | ) |

## ◆ Slider() [12/13]

template Component Slider | ( | SliderOption< float > |  | ) |

## ◆ Slider() [13/13]

template Component Slider | ( | SliderOption< double > |  | ) |

## ◆ EatCodePoint() [1/2]

bool EatCodePoint | ( | const std::string & | input,
|  | size_t | start,
|  | size_t * | end,
|  | uint32_t * | ucs )

Definition at line 1174 of file string.cpp.

## ◆ EatCodePoint() [2/2]

bool EatCodePoint | ( | const std::wstring & | input,
|  | size_t | start,
|  | size_t * | end,
|  | uint32_t * | ucs )

Definition at line 1244 of file string.cpp.

## ◆ IsCombining()

bool IsCombining | ( | uint32_t | ucs | ) |

Definition at line 1282 of file string.cpp.

## ◆ IsFullWidth()

bool IsFullWidth | ( | uint32_t | ucs | ) |

Definition at line 1286 of file string.cpp.

## ◆ IsControl()

bool IsControl | ( | uint32_t | ucs | ) |

Definition at line 1293 of file string.cpp.

## ◆ CodepointToWordBreakProperty()

WordBreakProperty CodepointToWordBreakProperty | ( | uint32_t | codepoint | ) |

Definition at line 1307 of file string.cpp.

## ◆ GlyphPrevious()

size_t GlyphPrevious | ( | const std::string & | input,
|  | size_t | start )

Definition at line 1399 of file string.cpp.

## ◆ GlyphNext()

size_t GlyphNext | ( | const std::string & | input,
|  | size_t | start )

Definition at line 1424 of file string.cpp.

## ◆ GlyphIterate()

size_t GlyphIterate | ( | const std::string & | input,
|  | int | glyph_offset,
|  | size_t | start )

Definition at line 1450 of file string.cpp.

## ◆ GlyphCount()

int GlyphCount | ( | const std::string & | input | ) |

Definition at line 1505 of file string.cpp.

## ◆ Utf8ToWordBreakProperty()

std::vector< WordBreakProperty > Utf8ToWordBreakProperty | ( | const std::string & | input | ) |

Definition at line 1533 of file string.cpp.

## ◆ IsWordBreakingCharacter()

bool IsWordBreakingCharacter | ( | const std::string & | input,
|  | size_t | glyph_index )

## Variable Documentation

## ◆ g_uniformize

const std::map<std::string, std::string> g_uniformize

Definition at line 19 of file terminal_input_parser.cpp.

## ◆ palette256

const std::array<ColorInfo, 256> palette256

Definition at line 13 of file color_info.cpp.