Struct Cursor 

#[non_exhaustive]
pub struct Cursor { /* private fields */ }

Implementations

impl Cursor

pub fn symbol(self, symbol: &str) -> Self

Sets the symbol for the cursor.

Arguments

• symbol: The symbol to set as the cursor.

Example

use ratatui_core::style::Style;
use tui_term::widget::Cursor;

let cursor = Cursor::default().symbol("|");

pub const fn style(self, style: Style) -> Self

Sets the style for the cursor.

Arguments

• style: The Style to set for the cursor.

Example

use ratatui_core::style::Style;
use tui_term::widget::Cursor;

let cursor = Cursor::default().style(Style::default());

pub const fn overlay_style(self, overlay_style: Style) -> Self

Sets the overlay style for the cursor.

The overlay style is used when the cursor overlaps with existing content on the screen.

Arguments

• overlay_style: The Style to set as the overlay style for the cursor.

Example

use ratatui_core::style::Style;
use tui_term::widget::Cursor;

let cursor = Cursor::default().overlay_style(Style::default());

pub const fn visibility(self, show: bool) -> Self

Set the visibility of the cursor (default = shown)

Examples found in repository

examples/simple_ls_controller.rs (line 78)

fn ui(f: &mut Frame, screen: &Screen) {
    let chunks = ratatui::layout::Layout::default()
        .direction(ratatui::layout::Direction::Vertical)
        .margin(1)
        .constraints(
            [
                ratatui::layout::Constraint::Percentage(100),
                ratatui::layout::Constraint::Min(1),
            ]
            .as_ref(),
        )
        .split(f.area());
    let title = Line::from("[ Running: ls ]");
    let block = Block::default()
        .borders(Borders::ALL)
        .title(title)
        .style(Style::default().add_modifier(Modifier::BOLD));
    let pseudo_term = PseudoTerminal::new(screen)
        .cursor(tui_term::widget::Cursor::default().visibility(false))
        .block(block.clone());
    f.render_widget(pseudo_term, chunks[0]);
    let explanation = "Press q to exit";
    let explanation = Paragraph::new(explanation)
        .style(Style::default().add_modifier(Modifier::BOLD | Modifier::REVERSED))
        .alignment(Alignment::Center);
    f.render_widget(explanation, chunks[1]);
}

pub fn show(&mut self)

Show the cursor (default)

pub fn hide(&mut self)

Hide the cursor

Examples found in repository

examples/smux.rs (line 86)

async fn run_smux(terminal: &mut DefaultTerminal) -> io::Result<()> {
    let mut size = Size {
        rows: terminal.size()?.height,
        cols: terminal.size()?.width,
    };

    let cwd = std::env::current_dir().unwrap();
    let mut cmd = CommandBuilder::new_default_prog();
    cmd.cwd(cwd);

    let mut panes: Vec<PtyPane> = Vec::new();
    let mut active_pane: Option<usize> = None;

    let pane_size = calc_pane_size(size, 1);
    open_new_pane(&mut panes, &mut active_pane, &cmd, pane_size)?;

    loop {
        terminal.draw(|f| {
            let chunks = Layout::default()
                .direction(Direction::Vertical)
                .margin(1)
                .constraints([Constraint::Percentage(100), Constraint::Min(1)].as_ref())
                .split(f.area());

            let pane_height = if panes.is_empty() {
                chunks[0].height
            } else {
                (chunks[0].height.saturating_sub(1)) / panes.len() as u16
            };

            for (index, pane) in panes.iter().enumerate() {
                let block = Block::default()
                    .borders(Borders::ALL)
                    .style(Style::default().add_modifier(Modifier::BOLD));
                let mut cursor = Cursor::default();
                let block = if Some(index) == active_pane {
                    block.style(
                        Style::default()
                            .add_modifier(Modifier::BOLD)
                            .fg(Color::LightMagenta),
                    )
                } else {
                    cursor.hide();
                    block
                };
                let parser = pane.parser.read().unwrap();
                let screen = parser.screen();
                let pseudo_term = PseudoTerminal::new(screen).block(block).cursor(cursor);
                let pane_chunk = Rect {
                    x: chunks[0].x,
                    y: chunks[0].y + (index as u16 * pane_height), /* Adjust the y coordinate for
                                                                    * each pane */
                    width: chunks[0].width,
                    height: pane_height, // Use the calculated pane height directly
                };
                f.render_widget(pseudo_term, pane_chunk);
            }

            let explanation =
                "Ctrl+n to open a new pane | Ctrl+x to close the active pane | Ctrl+q to quit";
            let explanation = Paragraph::new(explanation)
                .style(Style::default().add_modifier(Modifier::BOLD | Modifier::REVERSED))
                .alignment(Alignment::Center);
            f.render_widget(explanation, chunks[1]);
        })?;

        if event::poll(Duration::from_millis(10))? {
            tracing::info!("Terminal Size: {:?}", terminal.size());
            match event::read()? {
                Event::Key(key) => match key.code {
                    KeyCode::Char('q') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        return Ok(());
                    }
                    KeyCode::Char('n') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        let pane_size = calc_pane_size(size, panes.len() + 1);
                        tracing::info!("Opened new pane with size: {size:?}");
                        resize_all_panes(&mut panes, pane_size);
                        open_new_pane(&mut panes, &mut active_pane, &cmd, pane_size)?;
                    }
                    KeyCode::Char('x') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        close_active_pane(&mut panes, &mut active_pane).await?;
                        resize_all_panes(&mut panes, pane_size);
                    }
                    KeyCode::Char('k') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        if let Some(pane) = active_pane {
                            active_pane = Some(pane.saturating_sub(1));
                        }
                    }
                    KeyCode::Char('j') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        if let Some(pane) = active_pane {
                            if pane < panes.len() - 1 {
                                active_pane = Some(pane.saturating_add(1));
                            }
                        }
                    }
                    _ => {
                        if let Some(index) = active_pane {
                            if handle_pane_key_event(&mut panes[index], &key).await {
                                continue;
                            }
                        }
                    }
                },
                Event::Resize(cols, rows) => {
                    tracing::info!("Resized to: rows: {} cols: {}", rows, cols);
                    size.rows = rows;
                    size.cols = cols;
                    let pane_size = calc_pane_size(size, panes.len());
                    resize_all_panes(&mut panes, pane_size);
                }
                _ => {}
            }
        }

        cleanup_exited_panes(&mut panes, &mut active_pane);

        if panes.is_empty() {
            return Ok(());
        }
    }
}

Trait Implementations

impl Default for Cursor

fn default() -> Self

Returns the “default value” for a type.