Crate qframe 

Quvyta framework: build beautiful terminal applications.

quvyta-framework is a framework for building terminal applications in Rust. It was started to design Quvyta’s own applications and has grown into an open-source framework anyone can use.

An application gives the framework three things: language files, theme files (with icon files), and components built in code. A default theme, icon set and English and Turkish strings are embedded, so an application runs without any files.

An application is data, a view that draws it and an update that changes it:

use qframe::prelude::*;

#[derive(Default)]
struct Counter {
    count: i32,
}

#[derive(Clone)]
enum Msg {
    Increment,
}

impl App for Counter {
    type Msg = Msg;

    fn update(&mut self, msg: Msg) -> Command<Msg> {
        match msg {
            Msg::Increment => self.count += 1,
        }
        Command::none()
    }

    fn view(&self, ui: &mut View<'_, Msg>) {
        ui.column(|ui| {
            ui.add(Text::new(format!("Count: {}", self.count)));
            ui.add(Button::new("Add one").variant("primary").on_press(Msg::Increment));
        })
        .gap(1);
    }
}

// Tests drive the application without a terminal; a program calls
// `Runtime::new(Counter::default()).run()` in `main` instead.
let mut app = Harness::new(Counter::default(), 30, 4);
app.press("tab").press("enter");
assert!(app.screen().contains("Count: 1"));

Modules:

• prelude — the names nearly every application uses.
• runtime — the App trait, commands, the terminal runtime, background tasks and the test harness.
• widget — the widget model, the view builder and layout.
• widgets — ready-made widgets.
• theme — colour tokens, motion values and CSS-like style rules; style and color hold the resolved styles and colours widgets paint with.
• icons — icon sets with Nerd Font, Unicode and ASCII glyphs; animation — one-cell animations defined in icon sets and themes.
• i18n — locales, plural forms and the t! macro.
• keymap — named actions bound to key chords; event — key, mouse and paste events.
• env — the loaded theme, icons, language and keymap an application runs with.
• geometry and text — rectangles and padding in cells, and text measured in cells.
• date — calendar dates, times of day and the local time zone offset.
• uptime — the monotonic clocks that tell time awake from time the machine slept.
• motion — easing, moving values and cell-stepped progress.
• router — page navigation.
• storage — settings saved as TOML in the platform config directory, checked against a schema and optionally repaired; the config and data folders, atomic writes and the one-instance lock every application needs around its own files.
• document — an application’s own data file: a schema’d TOML document that holds arrays of tables and is never repaired behind the application’s back.

Every loader reports problems as diagnostics::Diagnostics with file, line and column instead of failing, and built-in defaults are always available.

Modules

animation

One-cell animations: an ordered list of frames, each with a glyph per glyph mode and an optional colour, played at a theme or literal frame time.

color

Colours: parsing, blending, contrast and perceptual distance, and reduction to the 256- and 16-colour palettes for terminals without 24-bit colour.

date

Calendar dates in the proleptic Gregorian calendar, times of day, and the two together.

diagnostics

Problems found while loading theme, icon, locale and keymap files.

document

An application’s own data file: a TOML document with a declared shape, which can hold arrays of tables and is never repaired behind the application’s back.

env

The environment widgets draw in: active theme, icons, language, keymap and colour depth, together with everything a settings screen needs to list the alternatives.

event

Input events delivered to widgets.

geometry

Cell geometry: rectangles, sizes and padding.

i18n

Localisation: locale files, plural forms, system language detection and t!.

icons

Icon sets: every icon has a Nerd Font, a Unicode and an ASCII glyph, and the terminal’s capabilities decide which one is drawn.

keymap

Keymaps: named actions bound to key chords, overridable from files.

motion

Motion: easing, values that move over time, and cell-stepped progress.

prelude

The names almost every application uses: use qframe::prelude::*;.

router

Page navigation as a stack.

runtime

Running applications: the App trait, Commands, the terminal Runtime and the test Harness.

storage

Settings storage: an application’s preferences in a TOML file in the platform config directory.

style

Drawing styles: what a cell looks like, and theme styles resolved for one frame.

text

Measuring text in terminal cells: width, truncation with an ellipsis at the end or in the middle, and word wrapping.

theme

Themes: colour tokens, motion timing, typography roles and CSS-like style rules.

uptime

Two monotonic clocks read together, so an application can tell time spent working from time the machine spent asleep.

widget

The widget model: the Widget trait, view nodes, layout properties and the contexts widgets measure, paint and handle events with.

widgets

Ready-made widgets. Every one takes its look from the theme and works with keyboard and mouse.

Macros

t

Translates a key with the active translator.