Termimad

https://docs.rs/termimad/0.34.0/
Admin
Termimad is a Rust crate for displaying markdown snippets and scrollable wrapped markdown texts in...
Tokens:205,953
Snippets:1,414
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Displaying Markdown in a TextView

Source: https://docs.rs/termimad/0.34.0/src/termimad/views/text_view.rs.html?search=u32+-%3E+bool

Example showing how to initialize a TextView with a defined area and skin, then render it to the terminal.

```rust
use termimad::*;

// You typically borrow those 3 vars from elsewhere
let markdown = "#title\n* item 1\n* item 2";
let area = Area::new(0, 0, 10, 12);
let skin = MadSkin::default();

// displaying
let text = skin.area_text(markdown, &area);
let view = TextView::from(&area, &text);
view.write().unwrap();
```

--------------------------------

### Using the ask! macro

Source: https://docs.rs/termimad/0.34.0/src/termimad/ask.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of using the ask! macro for simple confirmation and complex, nested question flows.

```rust
let confirmed = termimad::ask!(
    termimad::get_default_skin(),
    "Do you want to erase the disk ?", ('n') {
        ('y', "**Y**es") => { true }
        ('n', "**N**o") => { false }
    }
);
```

```rust
use termimad::*;

let skin = get_default_skin();
let beverage = ask!(skin, "What do I serve you ?", {
    ('b', "**B**eer") => {
        ask!(skin, "Really ? We have wine and orange juice too", (2) {
            ("oj", "**o**range **j**uice") => { "orange juice" }
            ('w' , "ok for some wine") => { "wine" }
            ('b' , "I said **beer**") => { "beer" }
            ( 2  , "Make it **2** beer glasses!") => { "beer x 2" }
        })
    }
    ('w', "**W**ine") => {
        println!("An excellent choice!");
        "wine"
    }
});
```

--------------------------------

### Ticker::start_beam

Source: https://docs.rs/termimad/0.34.0/src/termimad/events/tick_beam.rs.html?search=std%3A%3Avec

Starts a new tick beam based on the provided configuration.

```APIDOC
## Ticker::start_beam

### Description
Starts a new beam that generates ticks according to the provided TickBeam configuration. Returns a TickBeamId which can be used to stop the beam later.

### Signature
`pub fn start_beam(&mut self, mission: TickBeam<P>) -> TickBeamId`
```

--------------------------------

### Example Search Queries

Source: https://docs.rs/termimad/0.34.0/src/termimad/fit/composite_fit.rs.html?search=

Common search patterns for finding types, traits, or functional signatures within the documentation.

```text
std::vec
```

```text
u32 -> bool
```

```text
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Ticker::start_beam

Source: https://docs.rs/termimad/0.34.0/src/termimad/events/tick_beam.rs.html

Starts a new tick beam based on the provided TickBeam configuration.

```APIDOC
## Ticker::start_beam(mission: TickBeam<P>)

### Description
Starts a new beam that generates ticks according to the provided TickBeam configuration. Returns a unique identifier that can be used to stop the beam later.

### Parameters
- **mission** (TickBeam<P>) - Required - The configuration for the beam, including period, payload, and count.

### Returns
- **TickBeamId** - The unique identifier for the started beam.
```

--------------------------------

### Get Style Colors

Source: https://docs.rs/termimad/0.34.0/src/termimad/compound_style.rs.html

Retrieves the foreground or background color as an Option.

```rust
#[inline(always)]
    pub const fn get_fg(&self) -> Option<Color> {
        self.object_style.foreground_color
    }

    #[inline(always)]
    pub const fn get_bg(&self) -> Option<Color> {
        self.object_style.background_color
    }
```

--------------------------------

### Ticker::start_beam

Source: https://docs.rs/termimad/0.34.0/termimad/struct.Ticker.html?search=u32+-%3E+bool

Starts a new beam, returning an ID that can be used to stop it.

```APIDOC
### pub fn start_beam(&mut self, mission: TickBeam<P>) -> TickBeamId

Starts a new beam, returning its id, which can be used to stop it.
```

--------------------------------

### ListView Implementation Methods

Source: https://docs.rs/termimad/0.34.0/src/termimad/views/list_view.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for initializing the ListView, configuring columns, and managing sorting.

```rust
impl<'t> ListViewCell<'t> {
    pub fn new(con: String, style: &'t CompoundStyle) -> Self {
        let width = con.chars().count();
        Self { con, style, width }
    }
}

impl<'t, T> ListViewColumn<'t, T> {
    pub fn new(
        title: &str,
        min_width: usize,
        max_width: usize,
        extract: Box<dyn Fn(&T) -> ListViewCell<'t>>,
    ) -> Self {
        Self {
            title: title.to_owned(),
            min_width,
            max_width,
            spacing: Spacing {
                width: min_width,
                align: Alignment::Center,
            },
            extract,
        }
    }
    pub const fn with_align(mut self, align: Alignment) -> Self {
        self.spacing.align = align;
        self
    }
}

impl<'t, T> ListView<'t, T> {
    /// Create a new list view with the passed columns.
    ///
    /// The columns can't be changed afterwards but the area can be modified.
    /// When two columns have the same title, those titles are merged (but
    /// the columns below stay separated).
    pub fn new(area: Area, columns: Vec<ListViewColumn<'t, T>>, skin: &'t MadSkin) -> Self {
        let mut titles: Vec<Title> = Vec::new();
        for (column_idx, column) in columns.iter().enumerate() {
            if let Some(last_title) = titles.last_mut() {
                if columns[last_title.columns[0]].title == column.title {
                    // we merge those columns titles
                    last_title.columns.push(column_idx);
                    continue;
                }
            }
            // this is a new title
            titles.push(Title {
                columns: vec![column_idx],
            });
        }
        Self {
            titles,
            columns,
            rows: Vec::new(),
            area,
            scroll: 0,
            skin,
            filter: None,
            displayed_rows_count: 0,
            row_order: None,
            selection: None,
            selection_background: gray(5),
        }
    }
    /// set a comparator for row sorting
    #[allow(clippy::type_complexity)]
    pub fn sort(&mut self, sort: Box<dyn Fn(&T, &T) -> Ordering>) {
        self.row_order = Some(sort);
    }
    /// return the height which is available for rows
    #[inline(always)]
    pub const fn tbody_height(&self) -> u16 {
        if self.area.height > 2 {
            self.area.height - 2
        } else {
            self.area.height
        }
    }
    /// return an option which when filled contains
    ///  a tupple with the top and bottom of the vertical
    ///  scrollbar. Return none when the content fits
```

--------------------------------

### move_left

Source: https://docs.rs/termimad/0.34.0/src/termimad/views/input_field_content.rs.html?search=u32+-%3E+bool

Moves the cursor to the left or to the previous line if at the start of the current line.

```APIDOC
## move_left() -> bool

### Description
Moves the cursor left. If at the start of a line, it moves to the end of the previous line if available.

### Returns
- **bool** - Returns true if the cursor moved, false if at the start of the content.
```

--------------------------------

### Move to Boundaries

Source: https://docs.rs/termimad/0.34.0/src/termimad/views/input_field_content.rs.html?search=

Methods to move the cursor to the start, end, or line boundaries.

```rust
pub fn move_to_end(&mut self) -> bool {
        let pos = self.end();
        if pos == self.pos {
            false
        } else {
            self.pos = pos;
            true
        }
    }
```

```rust
pub fn move_to_start(&mut self) -> bool {
        let pos = Pos { x: 0, y: 0 };
        if pos == self.pos {
            false
        } else {
            self.pos = pos;
            true
        }
    }
```

```rust
pub fn move_to_line_end(&mut self) -> bool {
        let line_len = self.lines[self.pos.y].chars.len();
        if self.pos.x < line_len {
            self.pos.x = line_len;
            true
        } else {
            false
        }
    }
```

```rust
pub fn move_to_line_start(&mut self) -> bool {
        if self.pos.x > 0 {
            self.pos.x = 0;
            true
        } else {

```

--------------------------------

### Create and display formatted text

Source: https://docs.rs/termimad/0.34.0/src/termimad/text.rs.html?search=

Initializes a FmtText instance with a default skin and markdown string, then prints it to the console.

```rust
use termimad::*;
let skin = MadSkin::default();
let my_markdown = "#title\n* item 1\n* item 2";
let text = FmtText::from(&skin, &my_markdown, Some(80));
println!("{}", &text);
```

--------------------------------

### Simple Confirmation using ask! Macro

Source: https://docs.rs/termimad/0.34.0/src/termimad/ask.rs.html?search=std%3A%3Avec

Demonstrates a basic yes/no confirmation prompt using the ask! macro.

```rust
let confirmed = termimad::ask!(
    termimad::get_default_skin(),
    "Do you want to erase the disk ?", ('n') {
        ('y', "**Y**es") => { true }
        ('n', "**N**o") => { false }
    }
);
```

--------------------------------

### ListViewColumn Constructor and Configuration

Source: https://docs.rs/termimad/0.34.0/termimad/struct.ListViewColumn.html?search=u32+-%3E+bool

Methods for initializing a new column and setting its alignment.

```rust
pub fn new( title: &str, min_width: usize, max_width: usize, extract: Box<dyn Fn(&T) -> ListViewCell<'t>>, ) -> Self
```

```rust
pub const fn with_align(self, align: Alignment) -> Self
```

--------------------------------

### Get terminal dimensions

Source: https://docs.rs/termimad/0.34.0/termimad/fn.terminal_size.html

Returns a tuple containing the width and height of the terminal in characters.

```rust
pub fn terminal_size() -> (u16, u16)
```

--------------------------------

### Chained Questions using ask! Macro

Source: https://docs.rs/termimad/0.34.0/src/termimad/ask.rs.html?search=std%3A%3Avec

Demonstrates how to nest questions to create complex interactive flows.

```rust
use termimad::*;

let skin = get_default_skin();
let beverage = ask!(skin, "What do I serve you ?", {
    ('b', "**B**eer") => {
        ask!(skin, "Really ? We have wine and orange juice too", (2) {
            ("oj", "**o**range **j**uice") => { "orange juice" }
            ('w' , "ok for some wine") => { "wine" }
            ('b' , "I said **beer**") => { "beer" }
            ( 2  , "Make it **2** beer glasses!") => { "beer x 2" }
        })
    }
    ('w', "**W**ine") => {
        println!("An excellent choice!");
        "wine"
    }
});
```

--------------------------------

### Get default skin signature

Source: https://docs.rs/termimad/0.34.0/termimad/fn.get_default_skin.html

Returns a static reference to the global MadSkin instance.

```rust
pub fn get_default_skin() -> &'static MadSkin
```

--------------------------------

### Build Default Skins

Source: https://docs.rs/termimad/0.34.0/src/termimad/skin.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to initialize a skin with predefined gray levels suitable for dark or light terminal backgrounds.

```rust
pub fn default_dark() -> Self {
    let mut skin = Self::default();
    skin.code_block.set_fgbg(gray(20), gray(5));
    skin.inline_code.set_fgbg(gray(20), gray(5));
    skin.headers[0].set_fg(gray(22));
    skin.headers[1].set_fg(gray(21));
    skin.headers[2].set_fg(gray(20));
    skin
}
```

```rust
pub fn default_light() -> Self {
    let mut skin = Self::default();
    skin.code_block.set_fgbg(gray(3), gray(20));
    skin.inline_code.set_fgbg(gray(4), gray(20));
    skin.headers[0].set_fg(gray(0));
    skin.headers[1].set_fg(gray(2));
    skin.headers[2].set_fg(gray(4));
    skin
}
```

--------------------------------

### Question::ask

Source: https://docs.rs/termimad/0.34.0/termimad/struct.Question.html

Executes the prompt and returns the user's input.

```APIDOC
## pub fn ask(&self, skin: &MadSkin) -> Result<String>

### Description
Does the asking and returns the inputted string, unless the user just typed enter and there was a default value. If the user types something not recognized, they are asked to try again.

### Parameters
- **skin** (&MadSkin) - Required - The MadSkin used for rendering the question.
```

--------------------------------

### Define Sequence Detection Helpers

Source: https://docs.rs/termimad/0.34.0/src/termimad/events/event_source.rs.html

Helper functions to identify the start and end of escape sequences.

```rust
fn is_seq_start(key: KeyEvent) -> bool {
    key.code == KeyCode::Char('_') && key.modifiers == KeyModifiers::ALT
}
fn is_seq_end(key: KeyEvent) -> bool {
    key.code == KeyCode::Char('\\') && key.modifiers == KeyModifiers::ALT
}
```

--------------------------------

### Implement EventSource Methods

Source: https://docs.rs/termimad/0.34.0/src/termimad/events/event_source.rs.html

Methods for initializing the EventSource and checking configuration capabilities.

```rust
impl EventSource {
    /// create a new source with default options
    ///
    /// If desired, mouse support must be enabled and disabled in crossterm.
    pub fn new() -> Result<Self, Error> {
        Self::with_options(EventSourceOptions::default())
    }
    /// return true if the source is configured to combine standard keys
    /// and the terminal supports it (it requires the 'kitty keyboard
    /// protocol').
    ///
    /// If true, you may receive events with multiple non-modifier keys,
    /// eg `ctrl-a-b`. If not, the same sequence of keys will be received
    /// as two successive combinations: `ctrl-a` and `ctrl-b`.
    ///
    /// Combining is not delay-based: you receive the combination as soon
    /// as the keys are released (or as soon as the key is pressed in
    /// most cases when `mandate_modifier_for_multiple_keys` is true).
    pub fn supports_multi_key_combinations(&self) -> bool {
        self.is_combining_keys
    }
    /// create a new source
    ///
    /// If desired, mouse support must be enabled and disabled in crossterm.
}
```

--------------------------------

### Jump to document or line boundaries

Source: https://docs.rs/termimad/0.34.0/src/termimad/views/input_field_content.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to move the cursor to the start or end of the document or the current line.

```rust
pub fn move_to_end(&mut self) -> bool {
    let pos = self.end();
    if pos == self.pos {
        false
    } else {
        self.pos = pos;
        true
    }
}
```

```rust
pub fn move_to_start(&mut self) -> bool {
    let pos = Pos { x: 0, y: 0 };
    if pos == self.pos {
        false
    } else {
        self.pos = pos;
        true
    }
}
```

```rust
pub fn move_to_line_end(&mut self) -> bool {
    let line_len = self.lines[self.pos.y].chars.len();
    if self.pos.x < line_len {
        self.pos.x = line_len;
        true
    } else {
        false
    }
}
```

```rust
pub fn move_to_line_start(&mut self) -> bool {
    if self.pos.x > 0 {
        self.pos.x = 0;
        true
    } else {
        false
    }
}
```

--------------------------------

### MadSkin Initialization

Source: https://docs.rs/termimad/0.34.0/termimad/struct.MadSkin.html?search=u32+-%3E+bool

Methods to create and configure a MadSkin instance.

```APIDOC
## pub fn no_style() -> Self
Build a customizable skin with no style.

## pub fn default_dark() -> Self
Build a customizable skin with gray levels suitable for dark backgrounds.

## pub fn default_light() -> Self
Build a customizable skin with gray levels suitable for light backgrounds.
```

--------------------------------

### Delete Character Left of Cursor

Source: https://docs.rs/termimad/0.34.0/src/termimad/views/input_field_content.rs.html

Removes the character to the left of the cursor, handling line merges if at the start of a line.

```rust
pub fn del_char_left(&mut self) -> bool {
        if self.pos.x > 0 {
            self.pos.x -= 1;
            if !self.lines[self.pos.y].chars.is_empty() {
                self.lines[self.pos.y].chars.remove(self.pos.x);
            }
            self.fix_selection();
            true
        } else if self.pos.y > 0 && self.lines.len() > 1 {
            let mut removed_line = self.lines.remove(self.pos.y);
            self.pos.y -= 1;
            self.pos.x = self.lines[self.pos.y].chars.len();
            self.lines[self.pos.y].chars.append(&mut removed_line.chars);
            self.fix_selection();
            true
        } else {
            false
        }
    }
```

--------------------------------

### default_light()

Source: https://docs.rs/termimad/0.34.0/src/termimad/skin.rs.html?search=std%3A%3Avec

Builds a customizable skin with gray levels suitable for terminals with a light background.

```APIDOC
## fn default_light()

### Description
Builds a customizable skin with gray levels suitable when the terminal has a light background.

### Signature
`pub fn default_light() -> Self`
```

--------------------------------

### Delete Character Left of Cursor

Source: https://docs.rs/termimad/0.34.0/src/termimad/views/input_field_content.rs.html?search=u32+-%3E+bool

Removes the character to the left of the cursor, potentially merging lines if at the start of a line.

```rust
pub fn del_char_left(&mut self) -> bool {
    if self.pos.x > 0 {
        self.pos.x -= 1;
        if !self.lines[self.pos.y].chars.is_empty() {
            self.lines[self.pos.y].chars.remove(self.pos.x);
        }
        self.fix_selection();
        true
    } else if self.pos.y > 0 && self.lines.len() > 1 {
        let mut removed_line = self.lines.remove(self.pos.y);
        self.pos.y -= 1;
        self.pos.x = self.lines[self.pos.y].chars.len();
        self.lines[self.pos.y].chars.append(&mut removed_line.chars);
        self.fix_selection();
        true
    } else {
        false
    }
}
```

--------------------------------

### ListView Write Method

Source: https://docs.rs/termimad/0.34.0/src/termimad/views/list_view.rs.html

Displays the entire list content to standard output.

```rust
339    /// display the whole list in its area
340    pub fn write(&self) -> Result<()> {
341        let mut stdout = stdout();
342        self.write_on(&mut stdout)?;
343        stdout.flush()?;
344        Ok(())
345    }
```

--------------------------------

### Cursor positioning methods

Source: https://docs.rs/termimad/0.34.0/src/termimad/views/input_field_content.rs.html?search=std%3A%3Avec

Methods to move the cursor to specific boundaries like start, end, or line ends.

```rust
    pub fn move_to_end(&mut self) -> bool {
        let pos = self.end();
        if pos == self.pos {
            false
        } else {
            self.pos = pos;
            true
        }
    }
    pub fn move_to_start(&mut self) -> bool {
        let pos = Pos { x: 0, y: 0 };
        if pos == self.pos {
            false
        } else {
            self.pos = pos;
            true
        }
    }
    pub fn move_to_line_end(&mut self) -> bool {
        let line_len = self.lines[self.pos.y].chars.len();
        if self.pos.x < line_len {
            self.pos.x = line_len;
            true
        } else {
            false
        }
    }
    pub fn move_to_line_start(&mut self) -> bool {
        if self.pos.x > 0 {
            self.pos.x = 0;
            true
        } else {

```

--------------------------------

### ask!

Source: https://docs.rs/termimad/0.34.0/src/termimad/ask.rs.html?search=std%3A%3Avec

Macro for creating interactive questions with branching logic.

```APIDOC
## ask!(skin, question, [default], { ... })

### Description
A macro to simplify creating questions with multiple choices and optional default values. It supports executing code blocks based on the user's selection.

### Usage
- **skin**: The MadSkin instance.
- **question**: The question text.
- **default**: (Optional) The default answer key.
- **{ ... }**: A block defining mappings of (key, description) to return values.
```

--------------------------------

### FmtComposite::new

Source: https://docs.rs/termimad/0.34.0/src/termimad/composite.rs.html?search=u32+-%3E+bool

Creates a new, empty FmtComposite instance.

```APIDOC
## pub fn new() -> Self

### Description
Creates a new FmtComposite with default values (Paragraph kind, empty compounds, 0 length, no spacing).
```

--------------------------------

### Implement Default for MadSkin

Source: https://docs.rs/termimad/0.34.0/src/termimad/skin.rs.html?search=std%3A%3Avec

Initializes a MadSkin with sensible default gray-level settings.

```rust
impl Default for MadSkin {
    /// Build a customizable skin.
    ///
    /// It's initialized with sensible gray level settings which should work
    /// whatever the terminal colors.
    ///
    /// If you want a default skin and you already know if your terminal
    /// is light or dark, you may use [MadSkin::default_light]
    /// or [MadSkin::default_dark].
    fn default() -> Self {
        let mut skin = Self {
            paragraph: LineStyle::default(),
            bold: CompoundStyle::with_attr(Attribute::Bold),
            italic: CompoundStyle::with_attr(Attribute::Italic),
            strikeout: CompoundStyle::with_attr(Attribute::CrossedOut),
            inline_code: CompoundStyle::with_fgbg(gray(17), gray(3)),
            code_block: LineStyle::default(),
            headers: Default::default(),
            scrollbar: ScrollBarStyle::new(),
            table: CompoundStyle::with_fg(gray(7)).into(),
            bullet: StyledChar::from_fg_char(gray(8), '•'),
            quote_mark: StyledChar::new(
                CompoundStyle::new(Some(gray(12)), None, Attribute::Bold.into()),
                '▐',
            ),
            horizontal_rule: StyledChar::from_fg_char(gray(6), '―'),
            ellipsis: CompoundStyle::default(),
            table_border_chars: STANDARD_TABLE_BORDER_CHARS,
            list_items_indentation_mode: Default::default(),

            #[cfg(feature = "special-renders")]
            special_chars: std::collections::HashMap::new(),
        };
        skin.code_block.set_fgbg(gray(17), gray(3));
        for h in &mut skin.headers {
            h.add_attr(Attribute::Underlined);
        }
        skin.headers[0].add_attr(Attribute::Bold);
        skin.headers[0].align = Alignment::Center;
        skin
    }
}
```

--------------------------------

### Ticker::start_beam

Source: https://docs.rs/termimad/0.34.0/src/termimad/events/tick_beam.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts a new tick beam based on the provided TickBeam configuration and returns a unique identifier for the beam.

```APIDOC
pub fn start_beam(&mut self, mission: TickBeam<P>) -> TickBeamId
```

--------------------------------

### Get Input Field Position

Source: https://docs.rs/termimad/0.34.0/src/termimad/views/input_field.rs.html?search=

Calculates the internal position (Pos) within the input field based on row and column coordinates.

```rust
pub fn get_pos(&self, row: u16, column: u16) -> Option<Pos> {
        if self.area.contains(column, row) {
            let y = ((row - self.area.top) as usize + self.scroll.y)
                .min(self.content.line_count() - 1);
            let line = &self.content.lines()[y];
            let x = line
                .col_to_char_idx((column - self.area.left) as usize + self.scroll.x)
                .unwrap_or(line.chars.len());
            Some(Pos { x, y })
        } else {
            None
        }
    }
```

--------------------------------

### MadSkin Initialization

Source: https://docs.rs/termimad/0.34.0/termimad/struct.MadSkin.html?search=std%3A%3Avec

Methods to initialize a MadSkin instance with predefined styles.

```APIDOC
## pub fn no_style() -> Self
Build a customizable skin with no style, most useful when your application must run in no-color mode.

## pub fn default_dark() -> Self
Build a customizable skin with gray levels suitable when the terminal has a dark background.

## pub fn default_light() -> Self
Build a customizable skin with gray levels suitable when the terminal has a light background.
```

--------------------------------

### Question::new

Source: https://docs.rs/termimad/0.34.0/src/termimad/ask.rs.html?search=std%3A%3Avec

Creates a new Question instance with the specified markdown text.

```APIDOC
## Question::new(md: S)

### Description
Initializes a new question with the provided markdown text.

### Parameters
- **md** (S: Into<String>) - Required - The markdown text to display for the question.
```

--------------------------------

### List View Utility Methods

Source: https://docs.rs/termimad/0.34.0/src/termimad/views/list_view.rs.html?search=std%3A%3Avec

Methods for writing the list to stdout, managing scroll position, and handling row selection.

```rust
    /// display the whole list in its area
    pub fn write(&self) -> Result<()> {
        let mut stdout = stdout();
        self.write_on(&mut stdout)?;
        stdout.flush()?;
        Ok(())
    }
    /// return true if the last line of the list is visible
    pub const fn do_scroll_show_bottom(&self) -> bool {
        self.scroll + self.tbody_height() as usize >= self.displayed_rows_count
    }
    /// ensure the last line is visible
    pub fn scroll_to_bottom(&mut self) {
        let body_height = self.tbody_height() as usize;
        self.scroll = self.displayed_rows_count.saturating_sub(body_height);
    }
    /// set the scroll amount.
    /// lines_count can be negative
    pub fn try_scroll_lines(&mut self, lines_count: i32) {
        if lines_count < 0 {
            let lines_count = -lines_count as usize;
            self.scroll = self.scroll.saturating_sub(lines_count);
        } else {
            self.scroll = (self.scroll + lines_count as usize)
                .min(self.displayed_rows_count - self.tbody_height() as usize + 1);
        }
        self.make_selection_visible();
    }
    /// set the scroll amount.
    /// pages_count can be negative
    pub fn try_scroll_pages(&mut self, pages_count: i32) {
        self.try_scroll_lines(pages_count * self.tbody_height() as i32)
    }
    /// try to select the next visible line
    pub fn try_select_next(&mut self, up: bool) {
        if self.displayed_rows_count == 0 {
            return;
        }
        if self.displayed_rows_count == 1 || self.selection.is_none() {
            for i in 0..self.rows.len() {
                let i = (i + self.scroll) % self.rows.len();
                if self.rows[i].displayed {
                    self.selection = Some(i);
                    self.make_selection_visible();
                    return;
                }
            }
        }
        for i in 0..self.rows.len() {
            let delta_idx = if up { self.rows.len() - 1 - i } else { i + 1 };
            let row_idx = (delta_idx + self.selection.unwrap()) % self.rows.len();
            if self.rows[row_idx].displayed {
                self.selection = Some(row_idx);
                self.make_selection_visible();
                return;
            }
        }
    }
    /// select the first visible line (unless there's nothing).
    pub fn select_first_line(&mut self) {
        for i in 0..self.rows.len() {
```

--------------------------------

### Initialize EventSource with Options

Source: https://docs.rs/termimad/0.34.0/src/termimad/events/event_source.rs.html

Configures the terminal raw mode and initializes communication channels for events and escape sequences.

```rust
pub fn with_options(options: EventSourceOptions) -> Result<Self, Error> {
        let mut combiner = Combiner::default();
        terminal::enable_raw_mode()?;
        let is_combining_keys = if options.combine_keys {
            combiner.enable_combining()?
        } else {
            false
        };
        combiner.set_mandate_modifier_for_multiple_keys(options.mandate_modifier_for_multiple_keys);
        let (tx_events, rx_events) = unbounded();
        let (tx_seqs, rx_seqs) = bounded(ESCAPE_SEQUENCE_CHANNEL_SIZE);
        let (tx_quit, rx_quit) = unbounded();
        let event_count = Arc::new(AtomicUsize::new(0));
        let internal_event_count = Arc::clone(&event_count);
        thread::spawn(move || {
            let mut last_up: Option<TimedClick> = None;
            let mut current_escape_sequence: Option<EscapeSequence> = None;
            // return true when we must close the source
            let send_and_wait = |event| {
                internal_event_count.fetch_add(1, Ordering::SeqCst);
                if tx_events.send(event).is_err() {
                    true // broken channel
                } else {
                    match rx_quit.recv() {
                        Ok(false) => false,
                        _ => true,
                    }
                }
            };
            loop {
                let ct_event = match crossterm::event::read() {
                    Ok(e) => e,
                    _ => {
                        continue;
                    }
                };
                let in_seq = current_escape_sequence.is_some();
                if in_seq {
                    if let crossterm::event::Event::Key(key) = ct_event {
                        if is_seq_end(key) {
                            // it's a proper sequence ending, we send it as such
                            let mut seq = current_escape_sequence.take().unwrap();
                            seq.keys.push(key);
                            if tx_seqs.try_send(seq).is_err() {
                                // there's probably just nobody listening on
                                // this zero size bounded channel
                            }
                            continue;
                        } else if !key
                            .modifiers
                            .intersects(KeyModifiers::ALT | KeyModifiers::CONTROL)
                        {
                            // adding to the current escape sequence
                            current_escape_sequence.as_mut().unwrap().keys.push(key);
                            continue;
                        }
                    }
                    // it's neither part of a proper sequence, nor the end
                    // we send all previous events independently before sending this one
                    let seq = current_escape_sequence.take().unwrap();
                    for key in seq.keys {
                        let mut timed_event = TimedEvent::new(Event::Key(key));
                        timed_event.key_combination = combiner.transform(key);
                        if options.discard_raw_key_events && timed_event.key_combination.is_none() {
                            continue;
                        }
                        if send_and_wait(timed_event) {
                            return;
                        }
                    }
                    // the current event will be sent normally
                } else if let crossterm::event::Event::Key(key) = ct_event {
                    if is_seq_start(key) {
                        // starting a new sequence
                        current_escape_sequence = Some(EscapeSequence { keys: vec![key] });
                        continue;
                    }
                }
                if let Event::Mouse(mouse_event) = ct_event {
                    if options.discard_mouse_move && mouse_event.kind == MouseEventKind::Moved {
                        continue;
                    }
                    if options.discard_mouse_drag
                        && matches!(mouse_event.kind, MouseEventKind::Drag(_))
                    {
                        continue;
                    }
                }
                let mut timed_event = TimedEvent::new(ct_event);
                if let Event::Key(key) = &timed_event.event {
                    timed_event.key_combination = combiner.transform(*key);
                    if options.discard_raw_key_events && timed_event.key_combination.is_none() {
                        continue;
                    }
                }
                if let Event::Mouse(MouseEvent {

```

--------------------------------

### Configure Newline Keys for InputField

Source: https://docs.rs/termimad/0.34.0/src/termimad/views/input_field.rs.html?search=

Demonstrates how to enable multiline input by defining specific key combinations that trigger a new line.

```rust
use termimad::*;
let mut textarea = InputField::new(Area::new(5, 5, 20, 10));
textarea.new_line_on(InputField::ALT_ENTER);
```

--------------------------------

### Initialize Event Source and Processing Loop

Source: https://docs.rs/termimad/0.34.0/src/termimad/events/event_source.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Sets up channels for events, sequences, and quit signals, then spawns a thread to process crossterm events.

```rust
        let mut combiner = Combiner::default();
        terminal::enable_raw_mode()?;
        let is_combining_keys = if options.combine_keys {
            combiner.enable_combining()?
        } else {
            false
        };
        combiner.set_mandate_modifier_for_multiple_keys(options.mandate_modifier_for_multiple_keys);
        let (tx_events, rx_events) = unbounded();
        let (tx_seqs, rx_seqs) = bounded(ESCAPE_SEQUENCE_CHANNEL_SIZE);
        let (tx_quit, rx_quit) = unbounded();
        let event_count = Arc::new(AtomicUsize::new(0));
        let internal_event_count = Arc::clone(&event_count);
        thread::spawn(move || {
            let mut last_up: Option<TimedClick> = None;
            let mut current_escape_sequence: Option<EscapeSequence> = None;
            // return true when we must close the source
            let send_and_wait = |event| {
                internal_event_count.fetch_add(1, Ordering::SeqCst);
                if tx_events.send(event).is_err() {
                    true // broken channel
                } else {
                    match rx_quit.recv() {
                        Ok(false) => false,
                        _ => true,
                    }
                }
            };
            loop {
                let ct_event = match crossterm::event::read() {
                    Ok(e) => e,
                    _ => {
                        continue;
                    }
                };
                let in_seq = current_escape_sequence.is_some();
                if in_seq {
                    if let crossterm::event::Event::Key(key) = ct_event {
                        if is_seq_end(key) {
                            // it's a proper sequence ending, we send it as such
                            let mut seq = current_escape_sequence.take().unwrap();
                            seq.keys.push(key);
                            if tx_seqs.try_send(seq).is_err() {
                                // there's probably just nobody listening on
                                // this zero size bounded channel
                            }
                            continue;
                        } else if !key
                            .modifiers
                            .intersects(KeyModifiers::ALT | KeyModifiers::CONTROL)
                        {
                            // adding to the current escape sequence
                            current_escape_sequence.as_mut().unwrap().keys.push(key);
                            continue;
                        }
                    }
                    // it's neither part of a proper sequence, nor the end
                    // we send all previous events independently before sending this one
                    let seq = current_escape_sequence.take().unwrap();
                    for key in seq.keys {
                        let mut timed_event = TimedEvent::new(Event::Key(key));
                        timed_event.key_combination = combiner.transform(key);
                        if options.discard_raw_key_events && timed_event.key_combination.is_none() {
                            continue;
                        }
                        if send_and_wait(timed_event) {
                            return;
                        }
                    }
                    // the current event will be sent normally
                } else if let crossterm::event::Event::Key(key) = ct_event {
                    if is_seq_start(key) {
                        // starting a new sequence
                        current_escape_sequence = Some(EscapeSequence { keys: vec![key] });
                        continue;
                    }
                }
                if let Event::Mouse(mouse_event) = ct_event {
                    if options.discard_mouse_move && mouse_event.kind == MouseEventKind::Moved {
                        continue;
                    }
                    if options.discard_mouse_drag
                        && matches!(mouse_event.kind, MouseEventKind::Drag(_))
                    {
                        continue;
                    }
                }
                let mut timed_event = TimedEvent::new(ct_event);
                if let Event::Key(key) = &timed_event.event {
                    timed_event.key_combination = combiner.transform(*key);
                    if options.discard_raw_key_events && timed_event.key_combination.is_none() {
                        continue;
                    }
                }
                if let Event::Mouse(MouseEvent {
                    kind, column, row, ..
                }) = timed_event.event
                {
```

--------------------------------

### ListView::new

Source: https://docs.rs/termimad/0.34.0/termimad/struct.ListView.html?search=std%3A%3Avec

Creates a new list view with the specified area, columns, and skin.

```APIDOC
## pub fn new(area: Area, columns: Vec<ListViewColumn<'t, T>>, skin: &'t MadSkin) -> Self

### Description
Creates a new list view with the passed columns. The columns cannot be changed afterwards, but the area can be modified.
```

--------------------------------

### ProgressBar::new

Source: https://docs.rs/termimad/0.34.0/src/termimad/views/progress.rs.html?search=std%3A%3Avec

Creates a new ProgressBar instance with a specified completion ratio and character width.

```APIDOC
## ProgressBar::new

### Description
Creates a new pixel-precise horizontal progress bar.

### Signature
`pub const fn new(part: f32, chars_len: usize) -> Self`

### Parameters
- **part** (f32) - Required - The completion ratio of the bar, must be in the range [0, 1].
- **chars_len** (usize) - Required - The maximum width of the bar in characters.
```

--------------------------------

### ProgressBar::new

Source: https://docs.rs/termimad/0.34.0/src/termimad/views/progress.rs.html?search=u32+-%3E+bool

Creates a new ProgressBar instance with a specified completion ratio and character width.

```APIDOC
## ProgressBar::new

### Description
Creates a new pixel-precise horizontal bar.

### Signature
`pub const fn new(part: f32, chars_len: usize) -> Self`

### Parameters
- **part** (f32) - Required - The completion ratio of the bar, must be in the range [0, 1].
- **chars_len** (usize) - Required - The maximum width of the bar in characters.
```

--------------------------------

### Initialize Event Source and Processing Loop

Source: https://docs.rs/termimad/0.34.0/src/termimad/events/event_source.rs.html?search=

Sets up the terminal raw mode, event channels, and spawns a thread to process incoming crossterm events.

```rust
let mut combiner = Combiner::default();
        terminal::enable_raw_mode()?;
        let is_combining_keys = if options.combine_keys {
            combiner.enable_combining()?
        } else {
            false
        };
        combiner.set_mandate_modifier_for_multiple_keys(options.mandate_modifier_for_multiple_keys);
        let (tx_events, rx_events) = unbounded();
        let (tx_seqs, rx_seqs) = bounded(ESCAPE_SEQUENCE_CHANNEL_SIZE);
        let (tx_quit, rx_quit) = unbounded();
        let event_count = Arc::new(AtomicUsize::new(0));
        let internal_event_count = Arc::clone(&event_count);
        thread::spawn(move || {
            let mut last_up: Option<TimedClick> = None;
            let mut current_escape_sequence: Option<EscapeSequence> = None;
            // return true when we must close the source
            let send_and_wait = |event| {
                internal_event_count.fetch_add(1, Ordering::SeqCst);
                if tx_events.send(event).is_err() {
                    true // broken channel
                } else {
                    match rx_quit.recv() {
                        Ok(false) => false,
                        _ => true,
                    }
                }
            };
            loop {
                let ct_event = match crossterm::event::read() {
                    Ok(e) => e,
                    _ => {
                        continue;
                    }
                };
                let in_seq = current_escape_sequence.is_some();
                if in_seq {
                    if let crossterm::event::Event::Key(key) = ct_event {
                        if is_seq_end(key) {
                            // it's a proper sequence ending, we send it as such
                            let mut seq = current_escape_sequence.take().unwrap();
                            seq.keys.push(key);
                            if tx_seqs.try_send(seq).is_err() {
                                // there's probably just nobody listening on
                                // this zero size bounded channel
                            }
                            continue;
                        } else if !key
                            .modifiers
                            .intersects(KeyModifiers::ALT | KeyModifiers::CONTROL)
                        {
                            // adding to the current escape sequence
                            current_escape_sequence.as_mut().unwrap().keys.push(key);
                            continue;
                        }
                    }
                    // it's neither part of a proper sequence, nor the end
                    // we send all previous events independently before sending this one
                    let seq = current_escape_sequence.take().unwrap();
                    for key in seq.keys {
                        let mut timed_event = TimedEvent::new(Event::Key(key));
                        timed_event.key_combination = combiner.transform(key);
                        if options.discard_raw_key_events && timed_event.key_combination.is_none() {
                            continue;
                        }
                        if send_and_wait(timed_event) {
                            return;
                        }
                    }
                    // the current event will be sent normally
                } else if let crossterm::event::Event::Key(key) = ct_event {
                    if is_seq_start(key) {
                        // starting a new sequence
                        current_escape_sequence = Some(EscapeSequence { keys: vec![key] });
                        continue;
                    }
                }
                if let Event::Mouse(mouse_event) = ct_event {
                    if options.discard_mouse_move && mouse_event.kind == MouseEventKind::Moved {
                        continue;
                    }
                    if options.discard_mouse_drag
                        && matches!(mouse_event.kind, MouseEventKind::Drag(_))
                    {
                        continue;
                    }
                }
                let mut timed_event = TimedEvent::new(ct_event);
                if let Event::Key(key) = &timed_event.event {
                    timed_event.key_combination = combiner.transform(*key);
                    if options.discard_raw_key_events && timed_event.key_combination.is_none() {
                        continue;
                    }
                }
                if let Event::Mouse(MouseEvent {
                    kind, column, row, ..
                }) = timed_event.event
                {
```

--------------------------------

### Initialize MadSkin

Source: https://docs.rs/termimad/0.34.0/src/termimad/skin.rs.html

Methods to initialize a MadSkin instance with default settings or no styling.

```rust
impl Default for MadSkin {
63    /// Build a customizable skin.
64    ///
65    /// It's initialized with sensible gray level settings which should work
66    /// whatever the terminal colors.
67    ///
68    /// If you want a default skin and you already know if your terminal
69    /// is light or dark, you may use [MadSkin::default_light]
70    /// or [MadSkin::default_dark].
71    fn default() -> Self {
72        let mut skin = Self {
73            paragraph: LineStyle::default(),
74            bold: CompoundStyle::with_attr(Attribute::Bold),
75            italic: CompoundStyle::with_attr(Attribute::Italic),
76            strikeout: CompoundStyle::with_attr(Attribute::CrossedOut),
77            inline_code: CompoundStyle::with_fgbg(gray(17), gray(3)),
78            code_block: LineStyle::default(),
79            headers: Default::default(),
80            scrollbar: ScrollBarStyle::new(),
81            table: CompoundStyle::with_fg(gray(7)).into(),
82            bullet: StyledChar::from_fg_char(gray(8), '•'),
83            quote_mark: StyledChar::new(
84                CompoundStyle::new(Some(gray(12)), None, Attribute::Bold.into()),
85                '▐',
86            ),
87            horizontal_rule: StyledChar::from_fg_char(gray(6), '―'),
88            ellipsis: CompoundStyle::default(),
89            table_border_chars: STANDARD_TABLE_BORDER_CHARS,
90            list_items_indentation_mode: Default::default(),
91
92            #[cfg(feature = "special-renders")]
93            special_chars: std::collections::HashMap::new(),
94        };
95        skin.code_block.set_fgbg(gray(17), gray(3));
96        for h in &mut skin.headers {
97            h.add_attr(Attribute::Underlined);
98        }
99        skin.headers[0].add_attr(Attribute::Bold);
100        skin.headers[0].align = Alignment::Center;
101        skin
102    }
103}
```

```rust
impl MadSkin {
106    /// Build a customizable skin with no style, most useful
107    /// when your application must run in no-color mode, for
108    /// example when piped to a file.
109    ///
110    /// Note that without style you have no underline, no
111    /// strikeout, etc.
112    pub fn no_style() -> Self {
113        Self {
114            paragraph: LineStyle::default(),
115            bold: CompoundStyle::default(),
116            italic: CompoundStyle::default(),
117            strikeout: CompoundStyle::default(),
118            inline_code: CompoundStyle::default(),
119            code_block: LineStyle::default(),
120            headers: Default::default(),
121            scrollbar: ScrollBarStyle::new(),
122            table: LineStyle::default(),
123            bullet: StyledChar::nude('•'),
124            quote_mark: StyledChar::nude('▐'),
125            horizontal_rule: StyledChar::nude('―'),
126            ellipsis: CompoundStyle::default(),
127            list_items_indentation_mode: Default::default(),
128            #[cfg(feature = "special-renders")]
129            special_chars: std::collections::HashMap::new(),
130        }
131    }
```

--------------------------------

### Initialize ListViewCell

Source: https://docs.rs/termimad/0.34.0/termimad/struct.ListViewCell.html?search=

Constructor for creating a new instance of ListViewCell.

```rust
pub fn new(con: String, style: &'t CompoundStyle) -> Self
```

--------------------------------

### ProgressBar::new

Source: https://docs.rs/termimad/0.34.0/src/termimad/views/progress.rs.html?search=

Creates a new ProgressBar instance with a specified completion percentage and character width.

```APIDOC
## ProgressBar::new(part: f32, chars_len: usize) -> ProgressBar

### Description
Creates a new pixel-precise horizontal bar. The `part` parameter represents the completion percentage (must be between 0.0 and 1.0), and `chars_len` defines the maximum width of the bar in characters.

### Parameters
- **part** (f32) - Required - The completion ratio of the bar, expected in the range [0, 1].
- **chars_len** (usize) - Required - The maximum width of the bar in characters.
```

--------------------------------

### LineStyle::new

Source: https://docs.rs/termimad/0.34.0/termimad/struct.LineStyle.html?search=u32+-%3E+bool

Creates a new instance of LineStyle.

```APIDOC
### pub fn new(compound_style: CompoundStyle, align: Alignment) -> Self

Initializes a new LineStyle with the specified compound style and alignment.
```
Tokens:
Raw