Crate modalkit_ratatui

modalkit-ratatui

Overview

This crate contains widgets that can be used to build modal editing TUI applications using the ratatui and modalkit crates.

Example

The following example shows a program that opens a single textbox where the user can enter text using Vim keybindings.

For a more complete example that includes a command bar and window splitting, see examples/editor.rs in the source repository.

use modalkit::{
    actions::{Action, Editable, Jumpable, Scrollable},
    editing::{context::Resolve, key::KeyManager, store::Store},
    editing::application::EmptyInfo,
    errors::UIResult,
    env::vim::keybindings::default_vim_keys,
    key::TerminalKey,
    keybindings::BindingMachine,
};
use modalkit_ratatui::textbox::{TextBoxState, TextBox};
use modalkit_ratatui::TerminalExtOps;

use modalkit::crossterm::event::{read, Event};
use modalkit::crossterm::terminal::EnterAlternateScreen;
use ratatui::{backend::CrosstermBackend, Terminal};
use std::io::stdout;

fn main() -> UIResult<(), EmptyInfo> {
    let mut stdout = stdout();

    crossterm::terminal::enable_raw_mode()?;
    crossterm::execute!(stdout, EnterAlternateScreen)?;

    let backend = CrosstermBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;
    let mut store = Store::default();
    let mut bindings = KeyManager::new(default_vim_keys::<EmptyInfo>());
    let mut tbox = TextBoxState::new(store.load_buffer(String::from("*scratch*")));

    terminal.clear()?;

    loop {
        terminal.draw(|f| f.render_stateful_widget(TextBox::new(), f.size(), &mut tbox))?;

        if let Event::Key(key) = read()? {
            bindings.input_key(key.into());
        } else {
            continue;
        };

        while let Some((act, ctx)) = bindings.pop() {
            let store = &mut store;

            let _ = match act {
                Action::Editor(act) => tbox.editor_command(&act, &ctx, store)?,
                Action::Macro(act) => bindings.macro_command(&act, &ctx, store)?,
                Action::Scroll(style) => tbox.scroll(&style, &ctx, store)?,
                Action::Repeat(rt) => {
                    bindings.repeat(rt, Some(ctx));
                    None
                },
                Action::Jump(l, dir, count) => {
                    let _ = tbox.jump(l, dir, ctx.resolve(&count), &ctx)?;
                    None
                },
                Action::Suspend => terminal.program_suspend()?,
                Action::NoOp => None,
                _ => continue,
            };
        }
    }
}

Modules

• cmdbar
  Command bar
• list
  List
• screen
  Tabbed window layout
• textbox
  Text box
• windows
  Tiled Window Layouts

Traits

• PromptActions
  A widget that contains content that can be converted into an action when the user is done entering text.
• ScrollActions
  A widget whose content can be scrolled in multiple ways.
• TerminalCursor
  A widget that the user’s cursor can be placed into.
• TerminalExtOps
  Extended operations for Terminal.
• Window
  A widget that the user can open and close on the screen.
• WindowOps
  Trait to allow widgets to control how they get drawn onto the screen when they are either focused or unfocused.

Functions

• render_cursor
  Position and draw a terminal cursor.

Type Aliases

• TermOffset
  An offset from the upper-left corner of the terminal.