Ratatui Crossterm

https://docs.rs/ratatui-crossterm/latest/
Admin
This crate provides `CrosstermBackend`, an implementation of the `Backend` trait for the Ratatui...
Tokens:13,152
Snippets:78
Trust Score:9.1
Update:2 months ago
Show doc for...
Tokens:
Raw
### Initialize and use CrosstermBackend

Source: https://docs.rs/ratatui-crossterm/latest/ratatui_crossterm/struct.CrosstermBackend.html

Demonstrates the standard setup for a terminal application, including enabling raw mode, entering alternate screen, and initializing the backend.

```rust
use std::io::{stderr, stdout};

use crossterm::ExecutableCommand;
use crossterm::terminal::(
    EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode,
);
use ratatui::Terminal;
use ratatui::backend::CrosstermBackend;

let mut backend = CrosstermBackend::new(stdout());
// or
let backend = CrosstermBackend::new(stderr());
let mut terminal = Terminal::new(backend)?;

enable_raw_mode()?;
stdout().execute(EnterAlternateScreen)?;

terminal.clear()?;
terminal.draw(|frame| {
    // -- snip --
})?;

stdout().execute(LeaveAlternateScreen)?;
disable_raw_mode()?;
```

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

### Queueing commands with QueueableCommand

Source: https://docs.rs/ratatui-crossterm/latest/ratatui_crossterm/struct.CrosstermBackend.html

Demonstrates how to queue multiple commands and execute them simultaneously by calling flush on the writer.

```rust
use std::io::{self, Write};
use crossterm::{QueueableCommand, style::Print};

 fn main() -> io::Result<()> {
    let mut stdout = io::stdout();

    // `Print` will executed executed when `flush` is called.
    stdout
        .queue(Print("foo 1\n".to_string()))?
        .queue(Print("foo 2".to_string()))?;

    // some other code (no execution happening here) ...

    // when calling `flush` on `stdout`, all commands will be written to the stdout and therefore executed.
    stdout.flush()?;

    Ok(())

    // ==== Output ====
    // foo 1
    // foo 2
}
```

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

### Create a new CrosstermBackend

Source: https://docs.rs/ratatui-crossterm/latest/ratatui_crossterm/struct.CrosstermBackend.html

Shows how to instantiate a new backend using standard output.

```rust
use std::io::stdout;

use ratatui::backend::CrosstermBackend;

let backend = CrosstermBackend::new(stdout());
```

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

### Crate Configuration and Metadata

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Initial crate configuration including documentation settings and feature flag handling.

```rust
1// show the feature flags in the generated documentation
2#![cfg_attr(docsrs, feature(doc_cfg))]
3#![doc(
4    html_logo_url = "https://raw.githubusercontent.com/ratatui/ratatui/main/assets/logo.png",
5    html_favicon_url = "https://raw.githubusercontent.com/ratatui/ratatui/main/assets/favicon.ico"
6)]
7#![warn(missing_docs)]
```

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

### Execute a command directly using ExecutableCommand

Source: https://docs.rs/ratatui-crossterm/latest/ratatui_crossterm/struct.CrosstermBackend.html

Demonstrates how to execute a command directly on a writer, such as stdout, using the ExecutableCommand trait.

```rust
use std::io;
use crossterm::{ExecutableCommand, style::Print};

fn main() -> io::Result<()> {
     // will be executed directly
      io::stdout()
        .execute(Print("sum:\n".to_string()))?
        .execute(Print(format!("1 + 1= {} ", 1 + 1)))?;

      Ok(())

     // ==== Output ====
     // sum:
     // 1 + 1 = 2
}
```

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

### Handle WinAPI execution for ScrollUpInRegion

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Returns an unsupported error for WinAPI execution as scrolling regions are not supported on Windows.

```rust
#[cfg(windows)]
    fn execute_winapi(&self) -> io::Result<()> {
        Err(io::Error::new(
            io::ErrorKind::Unsupported,
            "ScrollUpInRegion command not supported for winapi",
        ))
    }
```

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

### Implement Style conversion from ContentStyle

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Maps Crossterm ContentStyle to Ratatui Style, including foreground, background, and modifier flags.

```rust
impl FromCrossterm<ContentStyle> for Style {
    fn from_crossterm(value: ContentStyle) -> Self {
        let mut sub_modifier = Modifier::empty();
        if value.attributes.has(CrosstermAttribute::NoBold) {
            sub_modifier |= Modifier::BOLD;
        }
        if value.attributes.has(CrosstermAttribute::NoItalic) {
            sub_modifier |= Modifier::ITALIC;
        }
        if value.attributes.has(CrosstermAttribute::NotCrossedOut) {
            sub_modifier |= Modifier::CROSSED_OUT;
        }
        if value.attributes.has(CrosstermAttribute::NoUnderline) {
            sub_modifier |= Modifier::UNDERLINED;
        }
        if value.attributes.has(CrosstermAttribute::NoHidden) {
            sub_modifier |= Modifier::HIDDEN;
        }
        if value.attributes.has(CrosstermAttribute::NoBlink) {
            sub_modifier |= Modifier::RAPID_BLINK | Modifier::SLOW_BLINK;
        }
        if value.attributes.has(CrosstermAttribute::NoReverse) {
            sub_modifier |= Modifier::REVERSED;
        }

        Self {
            fg: value.foreground_color.map(FromCrossterm::from_crossterm),
            bg: value.background_color.map(FromCrossterm::from_crossterm),
            #[cfg(feature = "underline-color")]
            underline_color: value.underline_color.map(FromCrossterm::from_crossterm),
            add_modifier: Modifier::from_crossterm(value.attributes),
            sub_modifier,
        }
    }
}
```

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

### Handle WinAPI execution for ScrollDownInRegion

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Returns an unsupported error for WinAPI execution for the scroll down command.

```rust
#[cfg(windows)]
    fn execute_winapi(&self) -> io::Result<()> {
        Err(io::Error::new(
            io::ErrorKind::Unsupported,
            "ScrollDownInRegion command not supported for winapi",
        ))
    }
```

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

### CrosstermBackend::new

Source: https://docs.rs/ratatui-crossterm/latest/ratatui_crossterm/struct.CrosstermBackend.html

Creates a new CrosstermBackend instance using the provided writer, typically stdout or stderr.

```APIDOC
## pub const fn new(writer: W) -> Self

### Description
Creates a new `CrosstermBackend` with the given writer. Most applications will use either `stdout` or `stderr` as the writer.

### Parameters
- **writer** (W: Write) - Required - The writer to use for terminal output.

### Example
```rust
use std::io::stdout;
use ratatui::backend::CrosstermBackend;

let backend = CrosstermBackend::new(stdout());
```
```

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

### Implement Style conversion

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Implementation of IntoCrossterm for Style to map Ratatui modifiers to Crossterm attributes.

```rust
impl IntoCrossterm<ContentStyle> for Style {
    fn into_crossterm(self) -> ContentStyle {
        let mut attributes = CrosstermAttributes::default();

        // Add modifiers
        if self.add_modifier.contains(Modifier::BOLD) {
            attributes.set(CrosstermAttribute::Bold);
        }
        if self.add_modifier.contains(Modifier::DIM) {
            attributes.set(CrosstermAttribute::Dim);
        }
        if self.add_modifier.contains(Modifier::ITALIC) {
            attributes.set(CrosstermAttribute::Italic);
        }
        if self.add_modifier.contains(Modifier::UNDERLINED) {
            attributes.set(CrosstermAttribute::Underlined);
        }
        if self.add_modifier.contains(Modifier::SLOW_BLINK) {
            attributes.set(CrosstermAttribute::SlowBlink);
        }
        if self.add_modifier.contains(Modifier::RAPID_BLINK) {
            attributes.set(CrosstermAttribute::RapidBlink);
        }
        if self.add_modifier.contains(Modifier::REVERSED) {
            attributes.set(CrosstermAttribute::Reverse);
        }
        if self.add_modifier.contains(Modifier::HIDDEN) {
            attributes.set(CrosstermAttribute::Hidden);
        }
        if self.add_modifier.contains(Modifier::CROSSED_OUT) {
            attributes.set(CrosstermAttribute::CrossedOut);
        }

        // Sub modifiers (remove modifiers)
        if self.sub_modifier.contains(Modifier::BOLD) {
            attributes.set(CrosstermAttribute::NoBold);
        }
        if self.sub_modifier.contains(Modifier::DIM) {
            attributes.set(CrosstermAttribute::NormalIntensity);
        }
        if self.sub_modifier.contains(Modifier::ITALIC) {
            attributes.set(CrosstermAttribute::NoItalic);
        }
        if self.sub_modifier.contains(Modifier::UNDERLINED) {
            attributes.set(CrosstermAttribute::NoUnderline);
        }
        if self.sub_modifier.contains(Modifier::SLOW_BLINK) {
            attributes.set(CrosstermAttribute::SlowBlink);
        }
```

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

### Implement Color conversion

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Implementation of IntoCrossterm for Color to map Ratatui colors to Crossterm colors.

```rust
impl IntoCrossterm<CrosstermColor> for Color {
    fn into_crossterm(self) -> CrosstermColor {
        match self {
            Self::Reset => CrosstermColor::Reset,
            Self::Black => CrosstermColor::Black,
            Self::Red => CrosstermColor::DarkRed,
            Self::Green => CrosstermColor::DarkGreen,
            Self::Yellow => CrosstermColor::DarkYellow,
            Self::Blue => CrosstermColor::DarkBlue,
            Self::Magenta => CrosstermColor::DarkMagenta,
            Self::Cyan => CrosstermColor::DarkCyan,
            Self::Gray => CrosstermColor::Grey,
            Self::DarkGray => CrosstermColor::DarkGrey,
            Self::LightRed => CrosstermColor::Red,
            Self::LightGreen => CrosstermColor::Green,
            Self::LightBlue => CrosstermColor::Blue,
            Self::LightYellow => CrosstermColor::Yellow,
            Self::LightMagenta => CrosstermColor::Magenta,
            Self::LightCyan => CrosstermColor::Cyan,
            Self::White => CrosstermColor::White,
            Self::Indexed(i) => CrosstermColor::AnsiValue(i),
            Self::Rgb(r, g, b) => CrosstermColor::Rgb { r, g, b },
        }
    }
}
```

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

### QueueableCommand::queue

Source: https://docs.rs/ratatui-crossterm/latest/ratatui_crossterm/struct.CrosstermBackend.html

Queues a command for later execution. The command is executed when the writer is flushed or the buffer is full.

```APIDOC
## fn queue(&mut self, command: impl Command) -> Result<&mut T, Error>

### Description
Queues the given command for further execution. Queued commands are executed when `flush` is called on the writer, or automatically if the buffer fills up.

### Parameters
- **command** (impl Command) - Required - The command to queue for later execution.
```

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

### Test Style to Crossterm ContentStyle conversion

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Uses rstest to verify that various Ratatui Style configurations correctly map to their corresponding Crossterm ContentStyle representations.

```rust
    #[case(
        Style::default().fg(Color::Yellow),
        ContentStyle {
            foreground_color: Some(CrosstermColor::DarkYellow),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().bg(Color::Yellow),
        ContentStyle {
            background_color: Some(CrosstermColor::DarkYellow),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().add_modifier(Modifier::BOLD),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::Bold),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().remove_modifier(Modifier::BOLD),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::NoBold),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().add_modifier(Modifier::ITALIC),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::Italic),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().remove_modifier(Modifier::ITALIC),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::NoItalic),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().add_modifier(Modifier::UNDERLINED),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::Underlined),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().remove_modifier(Modifier::UNDERLINED),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::NoUnderline),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().add_modifier(Modifier::DIM),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::Dim),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().remove_modifier(Modifier::DIM),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::NoDim),
            ..Default::default()
        }
    )]
```

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

### CrosstermBackend Methods

Source: https://docs.rs/ratatui-crossterm/latest/ratatui_crossterm/struct.CrosstermBackend.html

The primary methods available on the CrosstermBackend for interacting with the terminal display.

```APIDOC
## fn draw<'a, I>(&mut self, content: I) -> Result<()> 

### Description
Draws the provided content to the terminal screen.

### Parameters
- **content** (Iterator<Item = (u16, u16, &'a Cell)>) - The iterator of cells to be drawn.

## fn hide_cursor(&mut self) -> Result<()> 

### Description
Hides the terminal cursor.

## fn show_cursor(&mut self) -> Result<()> 

### Description
Shows the terminal cursor.

## fn get_cursor_position(&mut self) -> Result<Position> 

### Description
Retrieves the current cursor position.

## fn set_cursor_position<P: Into<Position>>(&mut self, position: P) -> Result<()> 

### Description
Sets the cursor position to the specified coordinates.

## fn clear(&mut self) -> Result<()> 

### Description
Clears all character cells in the visible display area.

## fn clear_region(&mut self, clear_type: ClearType) -> Result<()> 

### Description
Clears a specific region of the terminal based on the provided ClearType.

## fn size(&self) -> Result<Size> 

### Description
Returns the terminal screen size in columns and rows.

## fn flush(&mut self) -> Result<()> 

### Description
Flushes any buffered output to the terminal screen.
```

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

### Crossterm Backend Imports

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Core imports for interacting with the Crossterm library within the backend implementation.

```rust
74use std::io::{self, Write};
75
76use crossterm::cursor::{Hide, MoveTo, Show};
77#[cfg(feature = "underline-color")]
78use crossterm::style::SetUnderlineColor;
79use crossterm::style::{
80    Attribute as CrosstermAttribute, Attributes as CrosstermAttributes, Color as CrosstermColor,
81    Colors as CrosstermColors, ContentStyle, Print, SetAttribute, SetBackgroundColor, SetColors,
82    SetForegroundColor,
83};
84use crossterm::terminal::{self, Clear};
85use crossterm::{execute, queue};
86cfg_if::cfg_if! {
87    // Re-export the selected Crossterm crate making sure to choose the latest version. We do this
```

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

### Test Underline Color conversion

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Verifies that underline color settings are correctly translated when the underline-color feature is enabled.

```rust
    #[test]
    #[cfg(feature = "underline-color")]
    fn into_crossterm_content_style_underline() {
        let style = Style::default().underline_color(Color::Red);
        let content_style = ContentStyle {
            underline_color: Some(CrosstermColor::DarkRed),
            ..Default::default()
        };
        assert_eq!(style.into_crossterm(), content_style);
    }
```

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

### Document Features Macro

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Conditional inclusion of the document-features macro for generating feature documentation.

```rust
71#![cfg_attr(feature = "document-features", doc = "\n## Features")]
72#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
```

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

### Test Crossterm ContentStyle to Style conversion

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Verifies that Crossterm ContentStyle objects are correctly converted into Ratatui Style objects.

```rust
    #[case(
        ContentStyle {
            background_color: Some(CrosstermColor::DarkYellow),
            ..Default::default()
        },
        Style::default().bg(Color::Yellow)
    )]
    #[case(
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::Bold),
            ..Default::default()
        },
        Style::default().add_modifier(Modifier::BOLD)
    )]
    #[case(
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::NoBold),
            ..Default::default()
        },
        Style::default().remove_modifier(Modifier::BOLD)
    )]
    #[case(
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::Italic),
            ..Default::default()
        },
        Style::default().add_modifier(Modifier::ITALIC)
    )]
    #[case(
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::NoItalic),
            ..Default::default()
        },
        Style::default().remove_modifier(Modifier::ITALIC)
    )]
    #[case(
        ContentStyle {
            attributes: CrosstermAttributes::from(
                [CrosstermAttribute::Bold, CrosstermAttribute::Italic].as_ref()
            ),
            ..Default::default()
        },
        Style::default()
            .add_modifier(Modifier::BOLD)
            .add_modifier(Modifier::ITALIC)
    )]
    #[case(
        ContentStyle {
            attributes: CrosstermAttributes::from(
                [CrosstermAttribute::NoBold, CrosstermAttribute::NoItalic].as_ref()
            ),
            ..Default::default()
        },
        Style::default()
            .remove_modifier(Modifier::BOLD)
            .remove_modifier(Modifier::ITALIC)
    )]
    fn from_crossterm_content_style(#[case] content_style: ContentStyle, #[case] style: Style) {
        assert_eq!(Style::from_crossterm(content_style), style);
    }
```

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

### Define ScrollUpInRegion command structure

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

A temporary structure for scrolling terminal regions, intended for future replacement by native Crossterm commands.

```rust
#[cfg(feature = "scrolling-regions")]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct ScrollUpInRegion {
    /// The first row of the scrolling region.
    pub first_row: u16,

    /// The last row of the scrolling region.
    pub last_row: u16,

    /// The number of lines to scroll up by.
    pub lines_to_scroll: u16,
}
```

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

### Test Underline Color conversion

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Specific test case for underline color conversion, gated by the underline-color feature flag.

```rust
    #[test]
    #[cfg(feature = "underline-color")]
    fn from_crossterm_content_style_underline() {
        let content_style = ContentStyle {
            underline_color: Some(CrosstermColor::DarkRed),
            ..Default::default()
        };
        assert_eq!(
            Style::from_crossterm(content_style),
            Style::default().underline_color(Color::Red)
        );
    }
```

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

### Test Style to Crossterm ContentStyle conversion

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Uses parameterized test cases to verify that various Ratatui modifiers correctly map to Crossterm attributes.

```rust
    #[case(
        Style::default().add_modifier(Modifier::SLOW_BLINK),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::SlowBlink),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().add_modifier(Modifier::RAPID_BLINK),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::RapidBlink),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().remove_modifier(Modifier::SLOW_BLINK),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::NoBlink),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().add_modifier(Modifier::REVERSED),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::Reverse),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().remove_modifier(Modifier::REVERSED),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::NoReverse),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().add_modifier(Modifier::HIDDEN),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::Hidden),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().remove_modifier(Modifier::HIDDEN),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::NoHidden),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().add_modifier(Modifier::CROSSED_OUT),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::CrossedOut),
            ..Default::default()
        }
    )]
    #[case(
        Style::default().remove_modifier(Modifier::CROSSED_OUT),
        ContentStyle {
            attributes: CrosstermAttributes::from(CrosstermAttribute::NotCrossedOut),
            ..Default::default()
        }
    )]
    #[case(
        Style::default()
            .add_modifier(Modifier::BOLD)
            .add_modifier(Modifier::ITALIC),
        ContentStyle {
            attributes: CrosstermAttributes::from(
                [CrosstermAttribute::Bold, CrosstermAttribute::Italic].as_ref()
            ),
            ..Default::default()
        }
    )]
    #[case(
        Style::default()
            .remove_modifier(Modifier::BOLD)
            .remove_modifier(Modifier::ITALIC),
        ContentStyle {
            attributes: CrosstermAttributes::from(
                [CrosstermAttribute::NoBold, CrosstermAttribute::NoItalic].as_ref()
            ),
            ..Default::default()
        }
    )]
    fn into_crossterm_content_style(#[case] style: Style, #[case] content_style: ContentStyle) {
        assert_eq!(style.into_crossterm(), content_style);
    }
```

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

### CrosstermBackend Implementation

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Implementation of the Backend trait for CrosstermBackend, handling terminal drawing, cursor manipulation, and state management.

```rust
fn flush(&mut self) -> io::Result<()> {
        self.writer.flush()
    }
}

impl<W> Backend for CrosstermBackend<W>
where
    W: Write,
{
    type Error = io::Error;

    fn draw<'a, I>(&mut self, content: I) -> io::Result<()>
    where
        I: Iterator<Item = (u16, u16, &'a Cell)>,
    {
        let mut fg = Color::Reset;
        let mut bg = Color::Reset;
        #[cfg(feature = "underline-color")]
        let mut underline_color = Color::Reset;
        let mut modifier = Modifier::empty();
        let mut last_pos: Option<Position> = None;
        for (x, y, cell) in content {
            // Move the cursor if the previous location was not (x - 1, y)
            if !matches!(last_pos, Some(p) if x == p.x + 1 && y == p.y) {
                queue!(self.writer, MoveTo(x, y))?;
            }
            last_pos = Some(Position { x, y });
            if cell.modifier != modifier {
                let diff = ModifierDiff {
                    from: modifier,
                    to: cell.modifier,
                };
                diff.queue(&mut self.writer)?;
                modifier = cell.modifier;
            }
            if cell.fg != fg || cell.bg != bg {
                queue!(
                    self.writer,
                    SetColors(CrosstermColors::new(
                        cell.fg.into_crossterm(),
                        cell.bg.into_crossterm(),
                    ))
                )?;
                fg = cell.fg;
                bg = cell.bg;
            }
            #[cfg(feature = "underline-color")]
            if cell.underline_color != underline_color {
                let color = cell.underline_color.into_crossterm();
                queue!(self.writer, SetUnderlineColor(color))?;
                underline_color = cell.underline_color;
            }

            queue!(self.writer, Print(cell.symbol()))?;
        }

        #[cfg(feature = "underline-color")]
        return queue!(
            self.writer,
            SetForegroundColor(CrosstermColor::Reset),
            SetBackgroundColor(CrosstermColor::Reset),
            SetUnderlineColor(CrosstermColor::Reset),
            SetAttribute(CrosstermAttribute::Reset),
        );
        #[cfg(not(feature = "underline-color"))]
        return queue!(
            self.writer,
            SetForegroundColor(CrosstermColor::Reset),
            SetBackgroundColor(CrosstermColor::Reset),
            SetAttribute(CrosstermAttribute::Reset),
        );
    }

    fn hide_cursor(&mut self) -> io::Result<()> {
        execute!(self.writer, Hide)
    }

    fn show_cursor(&mut self) -> io::Result<()> {
        execute!(self.writer, Show)
    }

    fn get_cursor_position(&mut self) -> io::Result<Position> {
        crossterm::cursor::position()
            .map(|(x, y)| Position { x, y })
            .map_err(io::Error::other)
    }

    fn set_cursor_position<P: Into<Position>>(&mut self, position: P) -> io::Result<()> {
        let Position { x, y } = position.into();
        execute!(self.writer, MoveTo(x, y))
    }

    fn clear(&mut self) -> io::Result<()> {
        self.clear_region(ClearType::All)
    }

    fn clear_region(&mut self, clear_type: ClearType) -> io::Result<()> {
        execute!(
            self.writer,
            Clear(match clear_type {
                ClearType::All => crossterm::terminal::ClearType::All,
                ClearType::AfterCursor => crossterm::terminal::ClearType::FromCursorDown,
                ClearType::BeforeCursor => crossterm::terminal::ClearType::FromCursorUp,
                ClearType::CurrentLine => crossterm::terminal::ClearType::CurrentLine,
                ClearType::UntilNewLine => crossterm::terminal::ClearType::UntilNewLine,
            })
        )
    }

    fn append_lines(&mut self, n: u16) -> io::Result<()> {
        for _ in 0..n {
            queue!(self.writer, Print("\n"))?;
        }
        self.writer.flush()
    }

    fn size(&self) -> io::Result<Size> {
        let (width, height) = terminal::size()?;
        Ok(Size { width, height })
    }

    fn window_size(&mut self) -> io::Result<WindowSize> {
        let crossterm::terminal::WindowSize {
            columns,
            rows,
            width,
            height,
        } = terminal::window_size()?;
        Ok(WindowSize {
            columns_rows: Size {
                width: columns,
                height: rows,
            },
            pixels: Size { width, height },
        })
    }

    fn flush(&mut self) -> io::Result<()> {
        self.writer.flush()
    }
```

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

### Test Crossterm to Ratatui color conversion

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Unit tests verifying that various Crossterm color variants map correctly to Ratatui Color types.

```rust
#[rstest]
    #[case(CrosstermColor::Reset, Color::Reset)]
    #[case(CrosstermColor::Black, Color::Black)]
    #[case(CrosstermColor::DarkGrey, Color::DarkGray)]
    #[case(CrosstermColor::Red, Color::LightRed)]
    #[case(CrosstermColor::DarkRed, Color::Red)]
    #[case(CrosstermColor::Green, Color::LightGreen)]
    #[case(CrosstermColor::DarkGreen, Color::Green)]
    #[case(CrosstermColor::Yellow, Color::LightYellow)]
    #[case(CrosstermColor::DarkYellow, Color::Yellow)]
    #[case(CrosstermColor::Blue, Color::LightBlue)]
    #[case(CrosstermColor::DarkBlue, Color::Blue)]
    #[case(CrosstermColor::Magenta, Color::LightMagenta)]
    #[case(CrosstermColor::DarkMagenta, Color::Magenta)]
    #[case(CrosstermColor::Cyan, Color::LightCyan)]
    #[case(CrosstermColor::DarkCyan, Color::Cyan)]
    #[case(CrosstermColor::White, Color::White)]
    #[case(CrosstermColor::Grey, Color::Gray)]
    #[case(CrosstermColor::Rgb { r: 0, g: 0, b: 0 }, Color::Rgb(0, 0, 0) )]
    #[case(CrosstermColor::Rgb { r: 10, g: 20, b: 30 }, Color::Rgb(10, 20, 30) )]
    #[case(CrosstermColor::AnsiValue(32), Color::Indexed(32))]
    #[case(CrosstermColor::AnsiValue(37), Color::Indexed(37))]
    fn from_crossterm_color(#[case] crossterm_color: CrosstermColor, #[case] color: Color) {
        assert_eq!(Color::from_crossterm(crossterm_color), color);
    }
```

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

### into_crossterm

Source: https://docs.rs/ratatui-crossterm/latest/ratatui_crossterm/trait.IntoCrossterm.html

Converts a Ratatui type into a Crossterm type.

```APIDOC
## fn into_crossterm(self) -> C

### Description
Converts the Ratatui type to a Crossterm type. This trait is designed to avoid the orphan rule when implementing conversions between these libraries.

### Signature
`fn into_crossterm(self) -> C`

### Dyn Compatibility
This trait is dyn compatible.
```

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

### IntoCrossterm<C>

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

A trait for converting a Ratatui type into a Crossterm type.

```APIDOC
## trait IntoCrossterm<C>

### Description
This trait defines a method to convert a Ratatui type into a corresponding Crossterm type. It is primarily used to bypass the orphan rule when implementing conversions for types defined in external crates.

### Method
- **into_crossterm(self) -> C**: Consumes the Ratatui type and returns the converted Crossterm type.
```

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

### Performing synchronized updates

Source: https://docs.rs/ratatui-crossterm/latest/ratatui_crossterm/struct.CrosstermBackend.html

Uses sync_update to execute a block of commands without immediate terminal rendering, helping to mitigate screen tearing.

```rust
use std::io;
use crossterm::{ExecutableCommand, SynchronizedUpdate, style::Print};

fn main() -> io::Result<()> {
    let mut stdout = io::stdout();

    stdout.sync_update(|stdout| {
        stdout.execute(Print("foo 1\n".to_string()))?;
        stdout.execute(Print("foo 2".to_string()))?;
        // The effects of the print command will not be present in the terminal
        // buffer, but not visible in the terminal.
        std::io::Result::Ok(())
    })?;

    // The effects of the commands will be visible.

    Ok(())

    // ==== Output ====
    // foo 1
    // foo 2
}
```

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

### FromCrossterm<C>

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

A trait for converting a Crossterm type into a Ratatui type.

```APIDOC
## trait FromCrossterm<C>

### Description
This trait defines a method to convert a Crossterm type into a corresponding Ratatui type. It is primarily used to bypass the orphan rule when implementing conversions for types defined in external crates.

### Method
- **from_crossterm(value: C) -> Self**: Takes a Crossterm type and returns the converted Ratatui type.
```

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

### Define ScrollDownInRegion command

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Struct representing a command to scroll the terminal screen down within a defined region.

```rust
#[cfg(feature = "scrolling-regions")]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct ScrollDownInRegion {
    /// The first row of the scrolling region.
    pub first_row: u16,

    /// The last row of the scrolling region.
    pub last_row: u16,

    /// The number of lines to scroll down by.
    pub lines_to_scroll: u16,
}
```

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

### from_crossterm

Source: https://docs.rs/ratatui-crossterm/latest/ratatui_crossterm/trait.FromCrossterm.html

Converts a Crossterm type into a Ratatui type.

```APIDOC
## fn from_crossterm(value: C) -> Self

### Description
Converts the provided crossterm type into the corresponding ratatui type.

### Signature
`fn from_crossterm(value: C) -> Self`

### Parameters
- **value** (C) - The crossterm type instance to be converted.

### Returns
- **Self** - The converted ratatui type instance.
```

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

### Implement ANSI scrolling for ScrollDownInRegion

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Generates the ANSI escape sequence to scroll a specific region downwards.

```rust
fn write_ansi(&self, f: &mut impl std::fmt::Write) -> std::fmt::Result {
        if self.lines_to_scroll != 0 {
            // Set a scrolling region that contains just the desired lines.
            write!(
                f,
                crate::crossterm::csi!("{};{}r"),
                self.first_row.saturating_add(1),
                self.last_row.saturating_add(1)
            )?;
            // Scroll the region by the desired count.
            write!(f, crate::crossterm::csi!("{}T"), self.lines_to_scroll)?;
            // Reset the scrolling region to be the whole screen.
            write!(f, crate::crossterm::csi!("r"))?;
        }
        Ok(())
    }
```

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

### Implement ANSI scrolling for ScrollUpInRegion

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Defines the ANSI escape sequence generation for scrolling a specific terminal region upwards.

```rust
fn write_ansi(&self, f: &mut impl std::fmt::Write) -> std::fmt::Result {
        if self.lines_to_scroll != 0 {
            // Set a scrolling region that contains just the desired lines.
            write!(
                f,
                crate::crossterm::csi!("{};{}r"),
                self.first_row.saturating_add(1),
                self.last_row.saturating_add(1)
            )?;
            // Scroll the region by the desired count.
            write!(f, crate::crossterm::csi!("{}S"), self.lines_to_scroll)?;
            // Reset the scrolling region to be the whole screen.
            write!(f, crate::crossterm::csi!("r"))?;
        }
        Ok(())
    }
```

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

### Test Modifier Diff Queueing

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Verifies that ModifierDiff correctly queues the necessary Crossterm attributes to transition between two states.

```rust
#[case(Modifier::HIDDEN | Modifier::DIM, Modifier::BOLD | Modifier::DIM, &[CrosstermAttribute::NoHidden, CrosstermAttribute::Bold])]
    #[case(Modifier::HIDDEN, Modifier::HIDDEN, &[])]
    #[case(Modifier::HIDDEN, Modifier::empty(), &[CrosstermAttribute::NoHidden])]
    #[case(Modifier::REVERSED, Modifier::empty(), &[CrosstermAttribute::NoReverse])]
    #[case(Modifier::SLOW_BLINK, Modifier::RAPID_BLINK, &[CrosstermAttribute::NoBlink, CrosstermAttribute::RapidBlink])]
    #[case(Modifier::empty(), Modifier::CROSSED_OUT, &[CrosstermAttribute::CrossedOut])]
    #[case(Modifier::empty(), Modifier::HIDDEN, &[CrosstermAttribute::Hidden])]
    #[case(Modifier::empty(), Modifier::REVERSED, &[CrosstermAttribute::Reverse])]
    fn queue_modifier_diff(
        #[case] from: Modifier,
        #[case] to: Modifier,
        #[case] expected_attributes: &[CrosstermAttribute],
    ) -> io::Result<()> {
        let mut actual = Vec::new();
        ModifierDiff { from, to }.queue(&mut actual)?;

        let mut expected = Vec::new();
        for attribute in expected_attributes {
            queue!(&mut expected, SetAttribute(*attribute))?;
        }

        assert_eq!(actual, expected);

        Ok(())
    }
```

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

### Define conversion traits

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Traits for converting between Ratatui and Crossterm types to avoid orphan rule restrictions.

```rust
pub trait IntoCrossterm<C> {
    /// Converts the ratatui type to a crossterm type.
    fn into_crossterm(self) -> C;
}

/// A trait for converting a Crossterm type to a Ratatui type.
///
/// This trait is needed for avoiding the orphan rule when implementing `From` for crossterm types
/// once these are moved to a separate crate.
pub trait FromCrossterm<C> {
    /// Converts the crossterm type to a ratatui type.
    fn from_crossterm(value: C) -> Self;
}
```

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

### Convert Crossterm Color to Ratatui Color

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Implements the FromCrossterm trait to map Crossterm color variants to their corresponding Ratatui color types.

```rust
impl FromCrossterm<CrosstermColor> for Color {
    fn from_crossterm(value: CrosstermColor) -> Self {
        match value {
            CrosstermColor::Reset => Self::Reset,
            CrosstermColor::Black => Self::Black,
            CrosstermColor::DarkRed => Self::Red,
            CrosstermColor::DarkGreen => Self::Green,
            CrosstermColor::DarkYellow => Self::Yellow,
            CrosstermColor::DarkBlue => Self::Blue,
            CrosstermColor::DarkMagenta => Self::Magenta,
            CrosstermColor::DarkCyan => Self::Cyan,
            CrosstermColor::Grey => Self::Gray,
            CrosstermColor::DarkGrey => Self::DarkGray,
            CrosstermColor::Red => Self::LightRed,
            CrosstermColor::Green => Self::LightGreen,
            CrosstermColor::Blue => Self::LightBlue,
            CrosstermColor::Yellow => Self::LightYellow,
            CrosstermColor::Magenta => Self::LightMagenta,
            CrosstermColor::Cyan => Self::LightCyan,
            CrosstermColor::White => Self::White,
            CrosstermColor::Rgb { r, g, b } => Self::Rgb(r, g, b),
            CrosstermColor::AnsiValue(v) => Self::Indexed(v),
        }
    }
}
```

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

### SynchronizedUpdate::sync_update

Source: https://docs.rs/ratatui-crossterm/latest/ratatui_crossterm/struct.CrosstermBackend.html

Performs a set of operations within a synchronized update block to prevent screen tearing.

```APIDOC
## fn sync_update<T>(&mut self, operations: impl FnOnce(&mut W) -> T) -> Result<T, Error>

### Description
Performs a set of actions within a synchronous update. This suspends terminal updates, executes the provided function, resumes updates, and performs a flush to minimize tearing.

### Parameters
- **operations** (impl FnOnce(&mut W) -> T) - Required - A function containing the operations to execute during the synchronized update.
```

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

### IntoCrossterm Trait Definition

Source: https://docs.rs/ratatui-crossterm/latest/ratatui_crossterm/trait.IntoCrossterm.html

The core trait definition for converting types between Ratatui and Crossterm.

```rust
pub trait IntoCrossterm<C> {
    // Required method
    fn into_crossterm(self) -> C;
}
```

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

### CrosstermBackend::writer_mut

Source: https://docs.rs/ratatui-crossterm/latest/ratatui_crossterm/struct.CrosstermBackend.html

Retrieves a mutable reference to the underlying writer. This method is unstable and requires the 'unstable-backend-writer' feature.

```APIDOC
## pub const fn writer_mut(&mut self) -> &mut W

### Description
Gets the writer as a mutable reference. Note that writing directly to the writer may cause incorrect output due to internal terminal buffering. This API is marked as unstable and is only available when the `unstable-backend-writer` crate feature is enabled.
```

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

### Test modifier attribute mapping

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Unit tests for mapping Ratatui modifiers to corresponding Crossterm attributes.

```rust
#[rstest]
    #[case(Modifier::BOLD, Modifier::BOLD | Modifier::HIDDEN, &[CrosstermAttribute::Hidden])]
    #[case(Modifier::BOLD, Modifier::DIM, &[CrosstermAttribute::NormalIntensity, CrosstermAttribute::Dim])]
    #[case(Modifier::CROSSED_OUT, Modifier::empty(), &[CrosstermAttribute::NotCrossedOut])]
    #[case(Modifier::DIM, Modifier::BOLD, &[CrosstermAttribute::NormalIntensity, CrosstermAttribute::Bold])]
    #[case(Modifier::HIDDEN | Modifier::CROSSED_OUT, Modifier::CROSSED_OUT, &[CrosstermAttribute::NoHidden])]
```

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

### Calculate and Queue Modifier Differences

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

The ModifierDiff struct calculates changes between two modifiers and queues the necessary Crossterm commands to update the terminal state.

```rust
struct ModifierDiff {
    pub from: Modifier,
    pub to: Modifier,
}

impl ModifierDiff {
    fn queue<W>(self, mut w: W) -> io::Result<()>
    where
        W: io::Write,
    {
        let removed = self.from - self.to;
        if removed.contains(Modifier::REVERSED) {
            queue!(w, SetAttribute(CrosstermAttribute::NoReverse))?;
        }

        let reset_intensity = removed.contains(Modifier::BOLD) || removed.contains(Modifier::DIM);
        if reset_intensity {
            // Bold and Dim are both reset by applying the Normal intensity
            queue!(w, SetAttribute(CrosstermAttribute::NormalIntensity))?;

            // The remaining Bold and Dim attributes must be
            // reapplied after the intensity reset above.
            if self.to.contains(Modifier::DIM) {
                queue!(w, SetAttribute(CrosstermAttribute::Dim))?;
            }

            if self.to.contains(Modifier::BOLD) {
                queue!(w, SetAttribute(CrosstermAttribute::Bold))?;
            }
        }

        if removed.contains(Modifier::ITALIC) {
            queue!(w, SetAttribute(CrosstermAttribute::NoItalic))?;
        }
        if removed.contains(Modifier::UNDERLINED) {
            queue!(w, SetAttribute(CrosstermAttribute::NoUnderline))?;
        }
        if removed.contains(Modifier::CROSSED_OUT) {
            queue!(w, SetAttribute(CrosstermAttribute::NotCrossedOut))?;
        }
        if removed.contains(Modifier::HIDDEN) {
            queue!(w, SetAttribute(CrosstermAttribute::NoHidden))?;
        }
        if removed.contains(Modifier::SLOW_BLINK) || removed.contains(Modifier::RAPID_BLINK) {
            queue!(w, SetAttribute(CrosstermAttribute::NoBlink))?;
        }

        let added = self.to - self.from;
        if added.contains(Modifier::REVERSED) {
            queue!(w, SetAttribute(CrosstermAttribute::Reverse))?;
        }
        if added.contains(Modifier::BOLD) && !reset_intensity {
            queue!(w, SetAttribute(CrosstermAttribute::Bold))?;
        }
        if added.contains(Modifier::ITALIC) {
            queue!(w, SetAttribute(CrosstermAttribute::Italic))?;
        }
        if added.contains(Modifier::UNDERLINED) {
            queue!(w, SetAttribute(CrosstermAttribute::Underlined))?;
        }
```

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

### CrosstermBackend::writer

Source: https://docs.rs/ratatui-crossterm/latest/ratatui_crossterm/struct.CrosstermBackend.html

Retrieves a reference to the underlying writer. This method is unstable and requires the 'unstable-backend-writer' feature.

```APIDOC
## pub const fn writer(&self) -> &W

### Description
Gets the writer. This API is marked as unstable and is only available when the `unstable-backend-writer` crate feature is enabled.
```

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

### Implement Modifier conversion from Crossterm attributes

Source: https://docs.rs/ratatui-crossterm/latest/src/ratatui_crossterm/lib.rs.html

Converts Crossterm attribute types into Ratatui Modifier bitflags.

```rust
impl FromCrossterm<CrosstermAttribute> for Modifier {
    fn from_crossterm(value: CrosstermAttribute) -> Self {
        // `Attribute*s*` (note the *s*) contains multiple `Attribute` We convert `Attribute` to
        // `Attribute*s*` (containing only 1 value) to avoid implementing the conversion again
        Self::from_crossterm(CrosstermAttributes::from(value))
    }
}
```

```rust
impl FromCrossterm<CrosstermAttributes> for Modifier {
    fn from_crossterm(value: CrosstermAttributes) -> Self {
        let mut res = Self::empty();
        if value.has(CrosstermAttribute::Bold) {
            res |= Self::BOLD;
        }
        if value.has(CrosstermAttribute::Dim) {
            res |= Self::DIM;
        }
        if value.has(CrosstermAttribute::Italic) {
            res |= Self::ITALIC;
        }
        if value.has(CrosstermAttribute::Underlined)
            || value.has(CrosstermAttribute::DoubleUnderlined)
            || value.has(CrosstermAttribute::Undercurled)
            || value.has(CrosstermAttribute::Underdotted)
            || value.has(CrosstermAttribute::Underdashed)
        {
            res |= Self::UNDERLINED;
        }
        if value.has(CrosstermAttribute::SlowBlink) {
            res |= Self::SLOW_BLINK;
        }
        if value.has(CrosstermAttribute::RapidBlink) {
            res |= Self::RAPID_BLINK;
        }
        if value.has(CrosstermAttribute::Reverse) {
            res |= Self::REVERSED;
        }
        if value.has(CrosstermAttribute::Hidden) {
            res |= Self::HIDDEN;
        }
        if value.has(CrosstermAttribute::CrossedOut) {
            res |= Self::CROSSED_OUT;
        }
        res
    }
}
```

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

### Define FromCrossterm Trait

Source: https://docs.rs/ratatui-crossterm/latest/ratatui_crossterm/trait.FromCrossterm.html

The trait definition requiring a conversion method from a Crossterm type C to the implementing type.

```rust
pub trait FromCrossterm<C> {
    // Required method
    fn from_crossterm(value: C) -> Self;
}
```
Tokens:
Raw