Struct Terminal

pub struct Terminal { /* private fields */ }

Creates a scrollable display widget to handle terminal-like behavior, such as logging events or debug information. Replaces SimpleTerminal widget

Implementations

impl Terminal

pub fn new<'a, T: Into<Option<&'a str>>>( x: i32, y: i32, width: i32, height: i32, title: T, ) -> Terminal

Creates a new widget, takes an x, y coordinates, as well as a width and height, plus a title

Arguments

• x - The x coordinate in the screen
• y - The y coordinate in the screen
• width - The width of the widget
• heigth - The height of the widget
• title - The title or label of the widget

To use dynamic strings use with_label(self, &str) or set_label(&mut self, &str). labels support special symbols preceded by an @ sign and for the associated formatting.

Examples found in repository

examples/terminal.rs (line 44)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn default_fill() -> Self

Constructs a widget with the size of its parent

impl Terminal

pub fn ansi(&self) -> bool

Returns whether the terminal is in ANSI mode.

Examples found in repository

examples/terminal.rs (line 120)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

//--------------------------------------------------------------------------------------
/// Yet another set of tests for misc cursor functions and other stuff
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn set_ansi(&mut self, arg1: bool)

Enable/disable ANSI mode. If true, ANSI and VT100/xterm codes will be processed. If false, these codes won’t be processed and will either be ignored or print the error character “¿”, depending on the value of show_unknown().

Examples found in repository

examples/terminal.rs (line 122)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn append(&mut self, s: &str)

Appends text to the terminal at current cursor position using the current text color/attributes. Redraws are managed automatically by default; see redraw_style()

Examples found in repository

examples/terminal.rs (line 109)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

//--------------------------------------------------------------------------------------
/// Yet another set of tests for misc cursor functions and other stuff
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn append_u8(&mut self, s: &[u8])

Appends data to the terminal at current cursor position using the current text color/attributes Redraws are managed automatically by default; see redraw_style()

Examples found in repository

examples/terminal.rs (line 126)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn append_ascii(&mut self, s: &str)

Appends text to the terminal at current cursor position using the current text color/attributes. Slightly more efficient than append_utf8 Redraws are managed automatically by default; see redraw_style()

Examples found in repository

examples/terminal.rs (line 127)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn append_utf8(&mut self, s: &str)

Appends text to the terminal at current cursor position using the current text color/attributes. Handles UTF-8 chars split across calls Redraws are managed automatically by default; see redraw_style()

Examples found in repository

examples/terminal.rs (line 144)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn append_utf8_u8(&mut self, s: &[u8])

Appends data to the terminal at current cursor position using the current text color/attributes Handles UTF-8 chars split across calls Redraws are managed automatically by default; see redraw_style()

Examples found in repository

examples/terminal.rs (line 145)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn clear(&mut self)

Clears the screen to the current textbgcolor(), and homes the cursor.

Examples found in repository

examples/terminal.rs (line 501)

fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

//--------------------------------------------------------------------------------------
/// Yet another set of tests for misc cursor functions and other stuff
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn clear_mouse_selection(&mut self)

Clear any current mouse selection.

Examples found in repository

examples/terminal.rs (line 842)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn clear_to_color(&mut self, val: Color)

Clears the screen to a specific color val and homes the cursor. Does not affect the value of text_bg_color or text_bg_color_default

Examples found in repository

examples/terminal.rs (line 519)

fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

pub fn clear_screen(&mut self, arg1: bool)

Clear the terminal screen only; does not affect the cursor position.

Also clears the current mouse selection.

If scroll_to_hist is true, the screen is cleared by scrolling the contents into the scrollback history, where it can be retrieved with the scrollbar. If false, the screen is cleared and the scrollback history is unchanged.

Similar to the escape sequence \<ESC\>[2J.

pub fn clear_screen_home(&mut self, arg1: bool)

Clear the terminal screen and home the cursor

Also clears the current mouse selection.

If scroll_to_hist is true, the screen is cleared by scrolling the contents into the scrollback history, where it can be retrieved with the scrollbar. If false, the screen is cleared and the scrollback history is unchanged.

Similar to the escape sequence \<ESC\>[2J\<ESC\>[H.

Examples found in repository

examples/terminal.rs (line 508)

fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

pub fn clear_history(&mut self)

Clears the scroll history buffer and adjusts scrollbar, forcing it to redraw()

Examples found in repository

examples/terminal.rs (line 485)

fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn color(&self) -> Color

Get the background color for the terminal’s Fl_Group::box().

Examples found in repository

examples/terminal.rs (line 531)

fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

pub fn set_color(&mut self, color: Color)

Sets the background color for the terminal’s Fl_Group::box().

If the textbgcolor() and textbgcolor_default() are set to the special “see through” color 0xffffffff when any text was added, changing color() affects the color that shows through behind that existing text.

Otherwise, whatever specific background color was set for existing text will persist after changing color().

To see the effects of a change to color(), follow up with a call to redraw().

The default value is 0x0.

Examples found in repository

examples/terminal.rs (line 532)

fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

pub fn cursor_col(&self) -> i32

Return the cursor’s current column position on the screen.

Examples found in repository

examples/terminal.rs (line 148)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

//--------------------------------------------------------------------------------------
/// Yet another set of tests for misc cursor functions and other stuff
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn set_cursor_col(&mut self, val: i32)

Set the cursor’s current column position on the screen. This is a low-level “protected” function of the fltk library

Examples found in repository

examples/terminal.rs (line 852)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn cursor_row(&self) -> i32

Return the cursor’s current row position on the screen.

Examples found in repository

examples/terminal.rs (line 147)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

//--------------------------------------------------------------------------------------
/// Yet another set of tests for misc cursor functions and other stuff
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn set_cursor_row(&mut self, val: i32)

Set the cursor’s current row position on the screen. This is a low-level “protected” function of the fltk library

Examples found in repository

examples/terminal.rs (line 850)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn cursor_up(&mut self, count: i32, do_scroll: bool)

Moves cursor up count lines. If cursor hits screen top, it either stops (does not wrap) if do_scroll is false, or scrolls down if do_scroll is true. This is a low-level “protected” function of the fltk library

Examples found in repository

examples/terminal.rs (line 112)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

//--------------------------------------------------------------------------------------
/// Yet another set of tests for misc cursor functions and other stuff
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn cursor_down(&mut self, count: i32, do_scroll: bool)

Moves cursor down count lines. If cursor hits screen bottom, it either stops (does not wrap) if do_scroll is false, or wraps and scrolls up if do_scroll is true. This is a low-level “protected” function of the fltk library

Examples found in repository

examples/terminal.rs (line 881)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn cursor_left(&mut self, count: i32)

Moves cursor left count columns, and cursor stops (does not wrap) if it hits screen edge. This is a low-level “protected” function of the fltk library

Examples found in repository

examples/terminal.rs (line 893)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn cursor_right(&mut self, count: i32, do_scroll: bool)

Moves cursor right count columns. If cursor hits right edge of screen, it either stops (does not wrap) if do_scroll is false, or wraps and scrolls up one line if do_scroll is true. This is a low-level “protected” function of the fltk library

Examples found in repository

examples/terminal.rs (line 887)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn scroll(&mut self, count: i32)

Scroll the selection up(+)/down(-) number of rows This is a low-level “protected” function of the fltk library

Examples found in repository

examples/terminal.rs (line 900)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn clear_eod(&mut self)

Clear from cursor to End Of Display (EOD), like “<ESC>[J<ESC>[0J”.

pub fn clear_eol(&mut self)

Clear from cursor to End Of Line (EOL), like “<ESC>[K”.

Examples found in repository

examples/terminal.rs (line 906)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn clear_cur_line(&mut self)

Clear entire line cursor is currently on.

Examples found in repository

examples/terminal.rs (line 928)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn clear_line(&mut self, drow: i32)

Clear entire line for specified row.

Examples found in repository

examples/terminal.rs (line 922)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn clear_sod(&mut self)

Clear from cursor to Start Of Display (EOD), like “<ESC>[1J”.

pub fn clear_sol(&mut self)

Clear from cursor to Start Of Line (SOL), like “<ESC>[1K”.

Examples found in repository

examples/terminal.rs (line 912)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn insert_char(&mut self, c: char, rep: i32)

Insert char c at the current cursor position for rep times. Works only for single-byte characters, c can’t be multi-byte UTF-8. Does not wrap; characters at end of line are lost. This is a low-level “protected” function of the fltk library

Examples found in repository

examples/terminal.rs (line 947)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn insert_char_eol(&mut self, c: char, drow: i32, dcol: i32, rep: i32)

Insert char c for rep times at display row drow and column dcol. Works only for single-byte characters, c can’t be multi-byte UTF-8. Does not wrap; characters at end of line are lost. This is a low-level “protected” function of the fltk library

Examples found in repository

examples/terminal.rs (line 980)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn insert_rows(&mut self, count: i32)

Insert count rows at current cursor position. Causes rows below to scroll down, and empty lines created. Lines deleted by scroll down are NOT moved into the scroll history. This is a low-level “protected” function of the fltk library

Examples found in repository

examples/terminal.rs (line 954)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn delete_chars(&mut self, drow: i32, dcol: i32, count: i32)

Delete char(s) at (drow,dcol) for count times.

Examples found in repository

examples/terminal.rs (line 969)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn delete_cur_chars(&mut self, count: i32)

Delete char(s) at cursor position for count times.

Examples found in repository

examples/terminal.rs (line 964)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn delete_rows(&mut self, count: i32)

Delete count rows at cursor position. Causes rows to scroll up, and empty lines created at bottom of screen. Lines deleted by scroll up are NOT moved into the scroll history. This is a low-level “protected” function of the fltk library

Examples found in repository

examples/terminal.rs (line 974)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn cursor_bg_color(&self) -> Color

Get the cursor’s background color used for the cursor itself.

Examples found in repository

examples/terminal.rs (line 155)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn set_cursor_bg_color(&mut self, color: Color)

Set the cursor’s background color used for the cursor itself.

Examples found in repository

examples/terminal.rs (line 159)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn cursor_fg_color(&self) -> Color

Get the cursor’s foreground color used for the cursor itself.

Examples found in repository

examples/terminal.rs (line 163)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn set_cursor_fg_color(&mut self, color: Color)

Set the cursor’s foreground color used for the cursor itself.

Examples found in repository

examples/terminal.rs (line 161)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn get_selection(&self) -> Option<[i32; 4]>

Get the current mouse selection. Returns None if no selection, or Some([srow, scol, erow, ecol]) if there is a selection, where row and col represent start/end positions in the ring buffer. This is a low-level “protected” function of the fltk library

Examples found in repository

examples/terminal.rs (line 841)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn cursor_home(&mut self)

Move cursor to the home position (top/left).

Examples found in repository

examples/terminal.rs (line 527)

fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

pub fn display_columns(&self) -> i32

Return terminal’s display width in columns of text characters.

Examples found in repository

examples/terminal.rs (line 181)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn set_display_columns(&mut self, val: i32)

Set terminal’s display width in columns of text characters. Does not resize the terminal.

Examples found in repository

examples/terminal.rs (line 183)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn display_rows(&self) -> i32

Return terminal’s display height in lines of text.

Examples found in repository

examples/terminal.rs (line 170)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn set_history_rows(&mut self, arg1: i32)

Sets the terminal’s scrollback history buffer size in lines of text (rows).

Examples found in repository

examples/terminal.rs (line 194)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn history_rows(&self) -> i32

Gets the terminal’s scrollback history buffer size in lines of text (rows).

Examples found in repository

examples/terminal.rs (line 193)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn history_use(&self) -> i32

Returns how many lines are “in use” by the screen history buffer.

Examples found in repository

examples/terminal.rs (line 199)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn set_margin_bottom(&mut self, arg1: i32)

Set the bottom margin

Examples found in repository

examples/terminal.rs (line 217)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn margin_bottom(&self) -> i32

Return the bottom margin

Examples found in repository

examples/terminal.rs (line 207)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn set_margin_left(&mut self, arg1: i32)

Set the left margin

Examples found in repository

examples/terminal.rs (line 218)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn margin_left(&self) -> i32

Return the left margin

Examples found in repository

examples/terminal.rs (line 208)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn set_margin_right(&mut self, arg1: i32)

Set the right margin

Examples found in repository

examples/terminal.rs (line 219)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn margin_right(&self) -> i32

Return the right margin

Examples found in repository

examples/terminal.rs (line 209)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn set_margin_top(&mut self, arg1: i32)

Set the top margin

Examples found in repository

examples/terminal.rs (line 220)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn margin_top(&self) -> i32

Return the top margin

Examples found in repository

examples/terminal.rs (line 210)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn h_to_row(&self, pix: i32) -> i32

Given a height in pixels, return number of rows that “fits” into that area. This is a low-level “protected” function of the fltk library

Examples found in repository

examples/terminal.rs (line 349)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn w_to_col(&self, pix: i32) -> i32

Given a width in pixels, return number of columns that “fits” into that area. This is a low-level “protected” function of the fltk library

Examples found in repository

examples/terminal.rs (line 350)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn set_output_translate(&mut self, val: OutFlags)

Sets the combined output translation flags to val.

val can be sensible combinations of the OutFlags bit flags.

The default is LF_TO_CRLF, so that \n will generate both carriage-return (CR) and line-feed (LF).

For \r and \n to be handled literally, use output_translate(Terminal::OutFlags::OFF); To disable all output translations, use 0 or Terminal::OutFlags::OFF.

Examples found in repository

examples/terminal.rs (line 541)

fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

pub fn output_translate(&self) -> OutFlags

Return the current combined output translation flags.

Examples found in repository

examples/terminal.rs (line 540)

fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

pub fn print_char(&mut self, c: char)

Prints single ASCII char c at current cursor position, and advances the cursor.

• c must be ASCII, not utf-8
• Does not trigger redraws

Examples found in repository

examples/terminal.rs (line 227)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn print_char_utf8(&mut self, c: char)

Prints single UTF-8 char c at current cursor position, and advances the cursor if the character is printable. Handles ASCII and control codes (CR, LF, etc).

The character is displayed at the current cursor position using the current text color/attributes.

Handles control codes and can be used to construct ANSI/XTERM escape sequences.

• c must be a single char only (whether UTF-8 or ASCII)
• c can be an ASCII character, though not as efficent as print_char()
• Invalid UTF-8 chars show the error character (¿) depending on show_unknown(bool).
• Does not trigger redraws

Examples found in repository

examples/terminal.rs (line 229)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn plot_char(&mut self, c: char, row: i32, col: i32)

Print the ASCII character c at the terminal’s display position (drow,dcol). The character MUST be printable (in range 0x20 - 0x7e), and is displayed using the current text color/attributes. Characters outside that range are either ignored or print the error character (¿), depending on show_unknown(bool).

No range checking is done on drow,dcol:

• drow must be in range 0..(display_rows()-1)
• dcol must be in range 0..(display_columns()-1)
• Does not trigger redraws
• Does NOT handle control codes, ANSI or XTERM escape sequences.

Examples found in repository

examples/terminal.rs (line 443)

fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

pub fn plot_char_utf8(&mut self, c: char, drow: i32, dcol: i32)

Print a single UTF-8 character len at display position (drow,dcol). The character is displayed using the current text color/attributes.

This is a very low level method. No range checking is done on drow,dcol:

• drow must be in range 0..(display_rows()-1)
• dcol must be in range 0..(display_columns()-1)
• Does not trigger redraws
• Does not handle ANSI or XTERM escape sequences
• Invalid UTF-8 chars show the error character (¿) depending on show_unknown(bool).

Examples found in repository

examples/terminal.rs (line 455)

fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

pub fn set_redraw_rate(&mut self, set: f32)

Set the maximum rate redraw speed in floating point seconds if redraw_style() is set to RATE_LIMITED.

Examples found in repository

examples/terminal.rs (line 235)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn redraw_rate(&self) -> f32

Get max rate redraw speed in floating point seconds.

Examples found in repository

examples/terminal.rs (line 232)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn set_redraw_style(&mut self, set: RedrawStyle)

Set how Terminal manages screen redrawing.

Examples found in repository

examples/terminal.rs (line 247)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn redraw_style(&self) -> RedrawStyle

Get the redraw style.

Examples found in repository

examples/terminal.rs (line 240)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn reset_terminal(&mut self)

Resets terminal to default colors, clears screen, history and mouse selection, homes cursor, resets tabstops.

Examples found in repository

examples/terminal.rs (line 429)

fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn scrollbar_actual_size(&self) -> i32

Returns the scrollbar’s actual “trough size”, which is the width of FL_VERTICAL scrollbars, or height of FL_HORIZONTAL scrollbars.

If scrollbar_size() is zero (default), then the value of the global Fl::scrollbar_size() is returned, which is the default global scrollbar size for the entire application.

Examples found in repository

examples/terminal.rs (line 278)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn scrollbar_size(&self) -> i32

Get current pixel size of all the scrollbar’s troughs for this widget, or zero if the global Fl::scrollbar_size() is being used (default).

If this value returns zero, this widget’s scrollbars are using the global Fl::scrollbar_size(), in which case use scrollbar_actual_size() to get the actual (effective) pixel scrollbar size being used.

returns Scrollbar trough size in pixels, or 0 if the global Fl::scrollbar_size() is being used.

Examples found in repository

examples/terminal.rs (line 281)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn set_scrollbar_size(&mut self, val: i32)

Set the width of the both horizontal and vertical scrollbar’s trough to val, in pixels. If this value is zero (default), this widget will use fltk’s master scrollbar_size() value

Examples found in repository

examples/terminal.rs (line 287)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn selection_bg_color(&self) -> Color

Get mouse selection background color.

Examples found in repository

examples/terminal.rs (line 299)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn scrollbar(&self) -> Scrollbar

Returns the vertical scrollbar

Examples found in repository

examples/terminal.rs (line 269)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

//--------------------------------------------------------------------------------------
/// Yet another set of tests for misc cursor functions and other stuff
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn hscrollbar(&self) -> Scrollbar

Returns the horizontal scrollbar

Examples found in repository

examples/terminal.rs (line 270)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

//--------------------------------------------------------------------------------------
/// Yet another set of tests for misc cursor functions and other stuff
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn hscrollbar_style(&self) -> ScrollbarStyle

Get the horizontal scrollbar behavior style.

This determines when the scrollbar is visible.

Value will be one of the Fl_Terminal::HScrollbarStyle enum values.

Examples found in repository

examples/terminal.rs (line 131)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn set_hscrollbar_style(&mut self, val: ScrollbarStyle)

Set the scrollbar behavior style.

This determines when the scrollbar is visible.

ScrollbarStyle enum	Description
ON	Scrollbar is always displayed.
OFF	Scrollbar is never displayed.
AUTO	Scrollbar is displayed whenever the widget has been resized so that some of the text is hidden.

The default style is AUTO

Examples found in repository

examples/terminal.rs (line 132)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn set_selection_bg_color(&mut self, color: Color)

Set mouse selection background color.

Examples found in repository

examples/terminal.rs (line 304)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn selection_fg_color(&self) -> Color

Get mouse selection foreground color.

Examples found in repository

examples/terminal.rs (line 298)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn set_selection_fg_color(&mut self, color: Color)

Set mouse selection foreground color.

Examples found in repository

examples/terminal.rs (line 303)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn show_unknown(&self) -> bool

Return the “show unknown” flag. if true, show unknown chars as ‘¿’

Examples found in repository

examples/terminal.rs (line 137)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn set_show_unknown(&mut self, arg1: bool)

Set the “show unknown” flag. if true, show unknown chars as ‘¿’ (default off)

Examples found in repository

examples/terminal.rs (line 136)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn text_attrib(&self) -> Attrib

Return the text attribute bits (underline, inverse, etc) for subsequent appends.

Examples found in repository

examples/terminal.rs (line 413)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

//--------------------------------------------------------------------------------------
/// Yet another set of tests for misc cursor functions and other stuff
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn set_text_attrib(&mut self, arg1: Attrib)

Set text attribute bits (underline, inverse, etc) for subsequent appends.

Examples found in repository

examples/terminal.rs (line 414)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

//--------------------------------------------------------------------------------------
/// Yet another set of tests for misc cursor functions and other stuff
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn set_text_bg_color(&mut self, color: Color)

Set text background color to fltk color val. Use this for temporary color changes, similar to <ESC>[48;2;{R};{G};{B}m

This setting does not affect the ‘default’ text colors used by <ESC>[0m, <ESC>c, reset_terminal(), etc. To change both the current and default bg color, also use text_bg_color_default(Fl_Color).

Examples found in repository

examples/terminal.rs (line 332)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

//--------------------------------------------------------------------------------------
/// Yet another set of tests for misc cursor functions and other stuff
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn text_bg_color(&self) -> Color

Get the text background color.

Examples found in repository

examples/terminal.rs (line 327)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn set_text_bg_color_default(&mut self, color: Color)

Set the default text background color used by <ESC>c, <ESC>[0m, and reset_terminal(). Does not affect the ‘current’ text fg color; use set_text_bg_color(Fl_Color) to set that.

Examples found in repository

examples/terminal.rs (line 318)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn text_bg_color_default(&self) -> Color

Return the default text background color.

Examples found in repository

examples/terminal.rs (line 313)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

pub fn set_text_bg_color_xterm(&mut self, color: XtermColor)

Sets the background text color as one of the 8 ‘xterm color’ values.

This will be the background color used for all newly printed text, similar to the <ESC>[#m escape sequence, where # is between 40 and 47.

This color will be reset to the default bg color if reset_terminal() is called, or by <ESC>c, <ESC>[0m, etc.

The xterm color intensity values can be influenced by the Dim/Bold/Normal modes (which can be set with e.g. <ESC>[1m, textattrib(), etc), so the actual RGB values of these colors allow room for Dim/Bold to influence their brightness. For instance, “Normal Red” is not full brightness to allow “Bold Red” to be brighter. This goes for all colors except ‘Black’, which is not influenced by Dim or Bold; Black is always Black.

These background colors are slightly dimmer than the corresponding xterm foregroumd colors.

The 8 color xterm values are: 0 = Black, 1 = Red, 2 = Green, 3 = Yellow, 4 = Blue,5 = Magenta, 6 = Cyan, 7 = White

Examples found in repository

examples/terminal.rs (line 720)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn set_text_color(&mut self, color: Color)

Set the text color for the terminal. This is a convenience method that sets both textfgcolor() and textfgcolor_default(), ensuring both are set to the same value.

pub fn set_text_fg_color(&mut self, color: Color)

Set text foreground drawing color to fltk color val. Use this for temporary color changes, similar to <ESC>[38;2;{R};{G};{B}m

This setting does not affect the ‘default’ text colors used by <ESC>[0m, <ESC>c, reset_terminal(), etc. To change both the current and default fg color, also use textfgcolor_default(Fl_Color)

Examples found in repository

examples/terminal.rs (line 331)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

//--------------------------------------------------------------------------------------
/// Yet another set of tests for misc cursor functions and other stuff
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn text_fg_color(&self) -> Color

Get the text foreground color.

Examples found in repository

examples/terminal.rs (line 326)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}
//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar Test1 is clicked
fn mb_test1_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    term.append("0123456789 0\n");
    term.append("0123456789 1\n");
    term.append("0123456789 2\n");
    term.append("0123456789 3\n");
    term.append("0123456789 4\n");
    term.append("0123456789 5\n");
    term.append("0123456789 6\n");
    term.append("0123456789 7\n");
    term.append("0123456789 8\n");
    term.append("0123456789 9\n");
    term.append("------------\n");

    term.set_text_fg_color(Color::Green);
    term.plot_char('A', 0, 0);
    term.plot_char('B', 1, 1);
    term.plot_char('C', 2, 2);
    term.plot_char('D', 3, 3);
    term.plot_char('E', 4, 4);
    term.plot_char('F', 5, 5);
    term.set_text_fg_color(Color::XtermWhite);

    assert_eq!(term.cursor_row(), 11);
    assert_eq!(term.cursor_col(), 0);

    term.set_text_bg_color(Color::DarkBlue);
    term.plot_char_utf8('b', 8, 1);
    term.plot_char_utf8('↑', 9, 1);
    term.plot_char_utf8('c', 8, 2);
    term.plot_char_utf8('↑', 9, 2);
    term.plot_char_utf8('d', 8, 3);
    term.plot_char_utf8('↑', 9, 3);
    term.plot_char_utf8('e', 8, 4);
    term.plot_char_utf8('↑', 9, 4);
    term.plot_char_utf8('f', 8, 5);
    term.plot_char_utf8('↑', 9, 5);
    term.plot_char_utf8('g', 8, 6);
    term.plot_char_utf8('↑', 9, 6);
    term.set_text_bg_color(Color::TransparentBg);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("Done!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// More tests that run when the menu bar button Test2 is clicked
fn mb_test2_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();

    for i in 0..50 {
        term.append(&format!("{i}\n"));
    }
    assert_eq!(term.history_rows(), 100);

    term.clear_history();
    assert_eq!(term.history_use(), 0);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests that run when Test3 is clicked
fn mb_test3_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();
    term.reset_terminal();
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

    assert_eq!(term.history_use(), 0);
    term.clear();
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), term.display_rows()); // A screenful of lines added to history

    term.append("Test\ntext\na\nb\nc\nd");
    assert_eq!(term.cursor_row(), 5);
    let hist = term.history_use();
    term.clear_screen_home(false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.history_use(), hist); // History not changed

    term.append("Test\ntext\na\nb\nc\nd\ne");
    assert_eq!(term.cursor_row(), 6);
    term.clear_screen_home(true);
    assert_eq!(term.cursor_row(), 0);

    term.append("Test\ntext\na\nb\nc\n");
    assert_eq!(term.cursor_row(), 5);
    term.clear_to_color(Color::DarkBlue);
    assert_eq!(term.text_bg_color_default(), Color::TransparentBg);
    assert_eq!(term.text_bg_color(), Color::TransparentBg);
    assert_eq!(term.cursor_row(), 0);

    // Test cursor_home()
    term.append("Test\n\n\n\n\n\n\n\n\n\n");
    assert_eq!(term.cursor_row(), 10);
    term.cursor_home();
    assert_eq!(term.cursor_row(), 0);

    // Test the widget color
    assert_eq!(term.color(), Color::Black); // Default
    term.set_color(Color::DarkGreen);
    assert_eq!(term.color(), Color::DarkGreen);
    term.set_color(Color::Black);
    assert_eq!(term.color(), Color::Black);
    term.append(
        "This should be one line of white text on black, embedded into the top of a blue field.\n",
    );

    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF); // default
    term.set_output_translate(OutFlags::OFF);
    assert_eq!(term.output_translate(), OutFlags::OFF);
    term.set_output_translate(OutFlags::LF_TO_CRLF); // restore default
    assert_eq!(term.output_translate(), OutFlags::LF_TO_CRLF);

    term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
    term.append("\nDone!\n");
    term.set_text_attrib(Attrib::Normal);
}

//--------------------------------------------------------------------------------------
/// Another set of tests for the ring-buffer access methods
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn set_text_fg_color_default(&mut self, color: Color)

Set the default text foreground color used by <ESC>c, <ESC>[0m, and reset_terminal(). Does not affect the ‘current’ text fg color; use set_text_fg_color(Fl_Color) to set that.

Examples found in repository

examples/terminal.rs (line 317)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn text_fg_color_default(&self) -> Color

Return the default text foreground color.

Examples found in repository

examples/terminal.rs (line 312)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn set_text_fg_color_xterm(&mut self, color: XtermColor)

Sets the foreground text color as one of the 8 ‘xterm color’ values.

This will be the foreground color used for all newly printed text, similar to the <ESC>[#m escape sequence, where # is between 30 and 37.

This color will be reset to the default bg color if reset_terminal() is called, or by <ESC>c, <ESC>[0m, etc.

The xterm color intensity values can be influenced by the Dim/Bold/Normal modes (which can be set with e.g. <ESC>[1m, textattrib(), etc), so the actual RGB values of these colors allow room for Dim/Bold to influence their brightness. For instance, “Normal Red” is not full brightness to allow “Bold Red” to be brighter. This goes for all colors except ‘Black’, which is not influenced by Dim or Bold; Black is always Black.

The 8 color xterm values are: 0 = Black, 1 = Red, 2 = Green, 3 = Yellow, 4 = Blue,5 = Magenta, 6 = Cyan, 7 = White

Examples found in repository

examples/terminal.rs (line 719)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn text_font(&self) -> Font

Get the text font

Examples found in repository

examples/terminal.rs (line 340)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn set_text_font(&mut self, font: Font)

Sets the font used for all text displayed in the terminal. This affects all existing text (in display and history) as well as any newly printed text. Only monospace fonts are recommended.

Examples found in repository

examples/terminal.rs (line 343)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn text_size(&self) -> i32

Return text font size used to draw all text in the terminal.

Examples found in repository

examples/terminal.rs (line 348)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn set_text_size(&mut self, val: i32)

Sets the font size used for all text displayed in the terminal. This affects all existing text (in display and history) as well as any newly printed text. Changing this will affect the display_rows() and display_columns().

Examples found in repository

examples/terminal.rs (line 355)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn text(&self, lines_below_cursor: bool) -> String

Return a string copy of all lines in the terminal (including history).

If lines_below_cursor is false, lines below the cursor on down to the bottom of the display are ignored, and not included in the returned string.

If lines_below_cursor is true, then all lines in the display are returned including any below the cursor, even if all are blank.

Example use:

    use fltk::{prelude::*, terminal::Terminal};
    let mut tty = Terminal::new(0, 0, 400, 300, None);
     
    let s = tty.text(true);   // get a copy of the terminal's contents
    println!("Terminal's contents:\n{}", s);

Examples found in repository

examples/terminal.rs (line 113)

fn main() {
    let app = fltk::app::App::default();

    // Set panic handler for main thread (will become UI thread)
    std::panic::set_hook(Box::new({
        |e| {
            eprintln!("!!!!PANIC!!!!{:#?}", e);
            error_box(e.to_string()); // Only works from the UI thread
            std::process::exit(2);
        }
    }));

    let mut main_win = Window::new(
        2285,
        180,
        WIN_WIDTH,
        WIN_HEIGHT,
        "FLTK/Terminal Rust wrapper test",
    );
    main_win.set_type(WindowType::Double);
    main_win.make_resizable(true);

    let mut menu_bar = MenuBar::new(0, 0, WIN_WIDTH, 30, None);

    let mut term = Terminal::new(0, 30, WIN_WIDTH, WIN_HEIGHT - 30, None);
    term.set_label("term");
    main_win.resizable(&term);
    term.set_label_type(LabelType::None);

    let idx = menu_bar.add_choice("Test&1");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test1_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80031) }); // Alt-1

    let idx = menu_bar.add_choice("Test&2");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test2_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80032) }); // Alt-2

    let idx = menu_bar.add_choice("Test&3");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test3_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80033) }); // Alt-3

    let idx = menu_bar.add_choice("Test&4");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test4_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80034) }); // Alt-4

    let idx = menu_bar.add_choice("Test&5");
    menu_bar.at(idx).unwrap().set_callback({
        let mut term1 = term.clone();
        move |c| mb_test5_cb(c, &mut term1)
    });
    menu_bar
        .at(idx)
        .unwrap()
        .set_shortcut(unsafe { std::mem::transmute(0x80035) }); // Alt-5

    menu_bar.end();

    main_win.end();
    main_win.show();

    // Worker thread that drives the startup tests
    let _worker_thread: std::thread::JoinHandle<_> = std::thread::spawn({
        let mut term = term.clone();
        move || {
            println!("Startup tests\n");
            term.append("Startup tests\n\n");
            term.append("<tmp>\n"); // This line will be overwritten later

            term.cursor_up(2, false);
            assert_eq!(term.text(false), "Startup tests\n\n"); // Ignores lines below cursor
            assert_eq!(
                term.text(true),
                "Startup tests\n\n<tmp>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
            );

            // Testing ansi() and set_ansi() methods
            assert!(term.ansi(), "Default ANSI mode should be ON at startup");
            term.append("ANSI mode is \x1b[4mON\x1b[0m\n");
            term.set_ansi(false);
            assert!(!term.ansi());
            term.append("ANSI mode is \x1b[4mOFF\x1b[0m\n");
            // append() method is already being used/tested. Test the u8, ascii, and utf8 variants
            term.append_u8(b"Appending u8 array\n");
            term.append_ascii("Appending ASCII array ↑ (up-arrow is dropped)\n");
            term.set_ansi(true); // Restore ANSI state

            // Play with the horizontal scrollbar
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::AUTO);
            term.set_hscrollbar_style(ScrollbarStyle::ON);
            assert_eq!(term.hscrollbar_style(), ScrollbarStyle::ON);

            // Test show_unknown() as incidental part of testing append methods
            term.set_show_unknown(true);
            assert!(term.show_unknown());
            term.append_ascii(
                "Appending ASCII array with show_unknown() ↑ (up-arrow is three unknown bytes)\n",
            );
            term.set_show_unknown(false);
            assert!(!term.show_unknown());

            term.append_utf8("Appending UTF8 array ↑ (up-arrow is visible)\n");
            term.append_utf8_u8(b"Appending UTF8 array as u8 \xe2\x86\x91 (up-arrow is visible)\n");

            let r = term.cursor_row();
            assert_eq!(term.cursor_col(), 0);
            term.append(&format!("Testing cursor row/col {r}"));
            assert_eq!(term.cursor_col(), 24);
            assert_eq!(term.cursor_row(), r);

            // Test cursor color methods
            assert_eq!(
                term.cursor_bg_color(),
                Color::XtermGreen,
                "Default cursor bg at startup"
            );
            term.set_cursor_bg_color(Color::Red);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            term.set_cursor_fg_color(Color::Blue);
            assert_eq!(term.cursor_bg_color(), Color::Red);
            assert_eq!(term.cursor_fg_color(), Color::Blue);
            term.set_cursor_bg_color(Color::XtermGreen); // Restore the defaults
            term.set_cursor_fg_color(Color::from_hex(0xff_ff_f0));
            assert_eq!(term.cursor_bg_color(), Color::XtermGreen);
            assert_eq!(term.cursor_fg_color(), Color::from_hex(0xff_ff_f0));

            // The default display_rows() will derive from the window size
            let dr = term.display_rows();
            let height = term.h();
            assert_eq!(height, term.h());
            assert!(dr > 20, "Default display_rows at startup");
            term.resize(term.x(), term.y(), term.w(), height * 2);
            assert_eq!(term.h(), height * 2);
            assert_eq!(height * 2, term.h());
            assert!(term.display_rows() > dr);
            term.resize(term.x(), term.y(), term.w(), height);

            // The default display_columns() will derive from the window size
            let dc = term.display_columns();
            assert!(dc > 80, "Default display_rows at startup");
            term.set_display_columns(200);
            assert_eq!(term.display_columns(), 200);
            term.append("\n         1         2         3         4         5         6         7         8         9");
            term.append("\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
            term.append("[This text should be truncated by display_columns() call below.]\n"); // We shouldn't see this on screen
            term.set_display_columns(90);
            assert_eq!(term.display_columns(), 90);
            term.set_display_columns(dc); // Set back to default
            assert_eq!(term.display_columns(), dc);

            assert_eq!(term.history_rows(), 100, "Default history_rows at startup");
            term.set_history_rows(50);
            assert_eq!(term.history_rows(), 50);
            term.set_history_rows(100); // Set back to default
            assert_eq!(term.history_rows(), 100);

            let hu = term.history_use();
            term.append(&format!(
                "history_use = {hu} (it's not clear what this means)\n"
            ));
            // assert_eq!(term.history_use(), hu+1);

            term.append(&format!(
                "margins = b:{} l:{} r:{} t{}\n",
                term.margin_bottom(),
                term.margin_left(),
                term.margin_right(),
                term.margin_top()
            ));
            assert_eq!(term.margin_bottom(), 3);
            assert_eq!(term.margin_left(), 3);
            assert_eq!(term.margin_right(), 3);
            assert_eq!(term.margin_top(), 3);

            term.set_margin_bottom(5);
            term.set_margin_left(10);
            term.set_margin_right(15);
            term.set_margin_top(20);
            assert_eq!(term.margin_bottom(), 5);
            assert_eq!(term.margin_left(), 10);
            assert_eq!(term.margin_right(), 15);
            assert_eq!(term.margin_top(), 20);

            term.append("Single character: '");
            term.print_char('X');
            term.append("', single UTF-8 character: '");
            term.print_char_utf8('↑');
            term.append("'\n");

            let rr = term.redraw_rate();
            assert_eq!(rr, 0.1, "Default redraw rate at startup");
            term.append(&format!("Redraw rate {rr}\n"));
            term.set_redraw_rate(1.0);
            assert_eq!(term.redraw_rate(), 1.0);
            term.set_redraw_rate(rr);
            assert_eq!(term.redraw_rate(), rr);

            let rs = term.redraw_style();
            term.append(&format!("Redraw style {rs:?}\n"));
            assert_eq!(
                rs,
                RedrawStyle::RateLimited,
                "Default redraw style at startup"
            );
            term.set_redraw_style(RedrawStyle::NoRedraw);
            assert_eq!(term.redraw_style(), RedrawStyle::NoRedraw);
            term.set_redraw_style(rs);
            assert_eq!(term.redraw_style(), rs);

            // Sanity checks: enum values are implicitly assigned in the C++ code so could change unexpectedly
            assert_eq!(
                RedrawStyle::NoRedraw.bits(),
                0x0000,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::RateLimited.bits(),
                0x0001,
                "RedrawStyle enum values have been reassigned"
            );
            assert_eq!(
                RedrawStyle::PerWrite.bits(),
                0x0002,
                "RedrawStyle enum values have been reassigned"
            );

            let sb = term.scrollbar();
            let hsb = term.hscrollbar();
            // Both vertical and horizontal scrollbars are at zero
            assert_eq!(sb.value(), 0.0);
            assert_eq!(hsb.value(), 0.0);
            term.set_hscrollbar_style(ScrollbarStyle::AUTO);

            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            assert_eq!(term.scrollbar_actual_size(), 16);
            term.append(&format!("Scrollbar size {}\n", term.scrollbar_size()));
            assert_eq!(
                term.scrollbar_size(),
                0,
                "Default scrollbar size at startup"
            );
            term.set_scrollbar_size(40);
            assert_eq!(term.scrollbar_size(), 40);
            assert_eq!(term.scrollbar_actual_size(), 40);
            term.append(&format!(
                "Scrollbar actual size {}\n",
                term.scrollbar_actual_size()
            ));
            term.set_scrollbar_size(0); // Restore default
            assert_eq!(term.scrollbar_size(), 0);
            assert_eq!(term.scrollbar_actual_size(), 16);

            let sfc = term.selection_fg_color();
            let sbc = term.selection_bg_color();
            assert_eq!(sfc, Color::Black);
            assert_eq!(sbc, Color::White);
            term.append(&format!("Selection colors: {sfc} {sbc}\n"));
            term.set_selection_fg_color(Color::Green);
            term.set_selection_bg_color(Color::DarkBlue);
            assert_eq!(term.selection_fg_color(), Color::Green);
            assert_eq!(term.selection_bg_color(), Color::DarkBlue);
            term.set_selection_fg_color(sfc);
            term.set_selection_bg_color(sbc);
            assert_eq!(term.selection_fg_color(), Color::Black);
            assert_eq!(term.selection_bg_color(), Color::White);

            let tfcd = term.text_fg_color_default();
            let tbcd = term.text_bg_color_default();
            assert_eq!(tfcd, Color::XtermWhite);
            assert_eq!(tbcd, Color::TransparentBg);
            term.append(&format!("Default text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color_default(Color::Green);
            term.set_text_bg_color_default(Color::DarkBlue);
            assert_eq!(term.text_fg_color_default(), Color::Green);
            assert_eq!(term.text_bg_color_default(), Color::DarkBlue);
            term.set_text_fg_color_default(tfcd);
            term.set_text_bg_color_default(tbcd);
            assert_eq!(term.text_fg_color_default(), Color::XtermWhite);
            assert_eq!(term.text_bg_color_default(), Color::TransparentBg);

            let tfc = term.text_fg_color();
            let tbc = term.text_bg_color();
            assert_eq!(tfc, Color::XtermWhite);
            assert_eq!(tbc, Color::TransparentBg);
            term.append(&format!("Text colors: {sfc} {sbc}\n"));
            term.set_text_fg_color(Color::Green);
            term.set_text_bg_color(Color::DarkBlue);
            assert_eq!(term.text_fg_color(), Color::Green);
            assert_eq!(term.text_bg_color(), Color::DarkBlue);
            term.set_text_fg_color(tfc);
            term.set_text_bg_color(tbc);
            assert_eq!(term.text_fg_color(), Color::XtermWhite);
            assert_eq!(term.text_bg_color(), Color::TransparentBg);

            let tf = term.text_font();
            term.append(&format!("Text font: {tf:?}\n"));
            assert_eq!(tf, Font::Courier);
            term.set_text_font(Font::Screen);
            assert_eq!(term.text_font(), Font::Screen);
            term.set_text_font(tf);
            assert_eq!(term.text_font(), Font::Courier);

            let ts = term.text_size();
            let r = term.h_to_row(100);
            let c = term.w_to_col(100);
            term.append(&format!(
                "Text size: {ts}, h_to_row(100): {r}, w_to_col(100): {c}\n"
            ));
            assert_eq!(ts, 14);
            term.set_text_size(30);
            assert_eq!(term.text_size(), 30);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));
            term.set_text_size(ts);
            assert_eq!(term.text_size(), ts);
            term.append(&format!(
                "Text size: {}, h_to_row(100): {}, w_to_col(100): {}\n",
                term.text_size(),
                term.h_to_row(100),
                term.w_to_col(100)
            ));

            // Keyboard handler
            term.handle({
                move |term, e| {
                    match e {
                        fltk::enums::Event::KeyDown
                            if fltk::app::event_key() == fltk::enums::Key::Escape =>
                        {
                            // false to let FLTK handle ESC. true to hide ESC
                            false
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && fltk::app::is_event_ctrl() =>
                        {
                            // We handle control keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.append_utf8(&k);
                            true
                        }

                        fltk::enums::Event::KeyDown
                            if fltk::app::event_length() == 1 && !fltk::app::is_event_alt() =>
                        {
                            // We handle normal printable keystroke
                            let k = fltk::app::event_text().unwrap();
                            term.take_focus().unwrap();
                            term.append(&k);
                            true
                        }

                        // fltk docs say that keyboard handler should always claim Focus and Unfocus events
                        // We can do this, or else ignore them (return false)
                        // fltk::enums::Event::Focus | fltk::enums::Event::Unfocus => {
                        //     term.redraw();
                        //     true
                        // }
                        _ => false, // Let FLTK handle everything else
                    }
                }
            });

            let attr_save = term.text_attrib();
            term.set_text_attrib(Attrib::Inverse | Attrib::Italic);
            term.append("\nStartup tests complete. Keyboard is live.\n");
            assert_eq!(term.text_attrib(), Attrib::Inverse | Attrib::Italic);
            term.set_text_attrib(attr_save);
            assert_eq!(term.text_attrib(), attr_save);
            term.redraw();
        }
    });

    app.run().unwrap();
}

pub fn selection_text(&self) -> Option<String>

Return text selection (for copy()/paste() operations)

Examples found in repository

examples/terminal.rs (line 556)

fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn selection_text_len(&self) -> i32

Return byte length of all UTF-8 chars in selection, or 0 if no selection. NOTE: Length includes trailing white on each line.

Examples found in repository

examples/terminal.rs (line 555)

fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn disp_erow(&self) -> i32

Return the ending row# in the display area.

Examples found in repository

examples/terminal.rs (line 588)

fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn disp_srow(&self) -> i32

Return the starting row# in the display area.

Examples found in repository

examples/terminal.rs (line 586)

fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn hist_erow(&self) -> i32

Return the ending row# of the scrollback history.

Examples found in repository

examples/terminal.rs (line 586)

fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn hist_srow(&self) -> i32

Return the starting row# of the scrollback history.

Examples found in repository

examples/terminal.rs (line 589)

fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn hist_use(&self) -> i32

Return number of rows in use by the scrollback history.

pub fn hist_use_srow(&self) -> i32

Return the starting row of the "in use" scrollback history.

pub fn is_inside_selection(&self, row: i32, col: i32) -> bool

Is global row/column inside the current mouse selection? This is a low-level “protected” function of the fltk library

pub fn is_selection(&self) -> bool

Returns true if there’s a mouse selection.

pub fn offset(&self) -> i32

Returns the current offset into the ring buffer.

Examples found in repository

examples/terminal.rs (line 591)

fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn ring_erow(&self) -> i32

Return the ending row# in the ring buffer (Always ring_rows()-1)

Examples found in repository

examples/terminal.rs (line 599)

fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn ring_srow(&self) -> i32

Return the starting row# in the ring buffer (Always 0)

Examples found in repository

examples/terminal.rs (line 598)

fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn ring_rows(&self) -> i32

Return the number of rows in the ring buffer.

Examples found in repository

examples/terminal.rs (line 572)

fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

pub fn u8c_cursor(&self) -> Utf8Char

Return the Utf8Char for character under cursor.

Examples found in repository

examples/terminal.rs (line 854)

fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn u8c_disp_row(&self, drow: i32) -> BuffRow<'_>

Return u8c for beginning of row drow of the display. This is a low-level “protected” function of the fltk library

Examples found in repository

examples/terminal.rs (line 619)

fn mb_test4_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    let sel_len = term.selection_text_len();
    let sel = term.selection_text();

    term.take_focus().unwrap();
    term.reset_terminal();
    // Test the Utf8Char primitive
    let uc = Utf8Char::new(b'Q');
    let uc1 = uc.text_utf8();
    assert_eq!(&uc1, b"Q");
    assert_eq!(&uc.attrib(), &Attrib::Normal);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::TransparentBg);

    let ring_rows = term.ring_rows();

    term.take_focus().unwrap();
    term.clear_history();
    assert_eq!(term.history_use(), 0);

    // Subtract row numbers, modulo `rows`
    fn row_diff(rows: i32, a: i32, b: i32) -> i32 {
        match a - b {
            n if n < 0 => n + rows,
            n => n,
        }
    }
    // disp_srow is always 1 greater than hist_erow, modulo (ring_rows+1)
    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);
    assert!(term.disp_srow() >= 0);
    assert!(term.disp_erow() >= 0);
    assert!(term.hist_srow() >= 0);
    assert!(term.hist_erow() >= 0);
    assert!(term.offset() >= 0);
    assert!(term.disp_srow() <= ring_rows);
    assert!(term.disp_erow() <= ring_rows);
    assert!(term.hist_srow() <= ring_rows);
    assert!(term.hist_erow() <= ring_rows);
    assert!(term.offset() <= ring_rows);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    assert_eq!(term.ring_erow(), term.ring_rows() - 1);
    assert_eq!(term.ring_srow(), 0);

    /// Local function to read back all rows from the display into a long string.
    /// Does not include scrollback history.
    /// Trims trailing blanks on each line
    fn read_disp(term: &Terminal) -> String {
        let rows = term.display_rows();
        let mut text: Vec<u8> = Vec::with_capacity((rows * 64) as usize);
        for row in 0..rows {
            let r = term.u8c_disp_row(row).trim();
            // Iterate through a row, accumulating [u8]
            for c in r.iter() {
                // Note: Sometimes utf-8 length is > 1
                text.extend_from_slice(c.text_utf8());
            }
            text.extend_from_slice(b"\n");
        }
        // Return the result as a string
        std::str::from_utf8(&text).unwrap().to_string()
    }

    term.clear();
    term.append("Top line  ↑ (up-arrow)");
    term.set_text_attrib(Attrib::Underline);
    term.append("  ");
    term.set_text_attrib(Attrib::Normal);
    term.append("  \n");
    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    // The two plain blanks at the end will be trimmed, the two underlined blanks will be retained.

    assert_eq!(text_out, "Top line  ↑ (up-arrow)  ");
    let r = term.u8c_disp_row(0);
    assert_eq!(r.col(0).text_utf8(), b"T");
    assert_eq!(r.col(10).text_utf8(), b"\xe2\x86\x91"); // UTF-8 up-arrow
    assert_eq!(r.col(24).text_utf8(), b" "); // First blank after test text, NOT trimmed
    let r = term.u8c_disp_row(1);
    assert_eq!(r.col(0).text_utf8(), b" "); // Second row starts with blanks
    assert_eq!(r.col(1).text_utf8(), b" "); // Second row is full of blanks

    // Clear the screen again, then append test text, then read it back and compare
    let test_text = "The wind was a torrent of darkness among the gusty trees.
The moon was a ghostly galleon tossed upon cloudy seas.
The road was a ribbon of moonlight over the purple moor,
And the highwayman came riding—
            Riding—riding—
The highwayman came riding, up to the old inn-door.";

    term.clear_history();
    term.clear();
    let bg_save = term.text_bg_color();
    let fg_save = term.text_fg_color();
    term.set_text_bg_color(Color::DarkBlue); // Set spooky colors
    term.set_text_fg_color(Color::from_rgb(0x40, 0x40, 0xff));
    term.append(test_text);
    term.set_text_bg_color(bg_save);
    term.set_text_fg_color(fg_save);

    let mut text_out = read_disp(term);
    // Trim trailing empty lines
    text_out = text_out.trim_end_matches(&"\n").to_string();
    assert_eq!(test_text, text_out);

    assert_eq!(row_diff(ring_rows, term.disp_srow(), term.hist_erow()), 1);

    assert_eq!(term.ring_srow(), 0);
    assert_eq!(term.ring_erow(), ring_rows - 1);
    assert_eq!(
        row_diff(ring_rows, term.disp_erow(), term.disp_srow()) + 1,
        term.display_rows()
    );
    assert_eq!(
        row_diff(ring_rows, term.hist_erow(), term.hist_srow()) + 1,
        term.history_rows()
    );

    term.append(&format!(
        "\n\nScreen has {} rows of {} columns.\n",
        term.display_rows(),
        term.display_columns()
    ));

    term.append(&format!("Selection len: {sel_len}\nSelection: '{sel:?}'\n"));
}

//--------------------------------------------------------------------------------------
/// Yet another set of tests for misc cursor functions and other stuff
/// Note: these tests depend heavily on the low-level "protected" parts of the fltk library, which should be used with caution.
fn mb_test5_cb(_choice: &mut fltk::menu::Choice, term: &mut Terminal) {
    term.take_focus().unwrap();

    // Test the attr_fg_color and attr_bg_color methods.
    // Put a single character 'A' into the buffer and check it
    term.clear(); // No reset_terminal(), just clear() to preserve the mouse selection for later
    term.set_text_bg_color(Color::TransparentBg);
    term.set_text_fg_color(Color::XtermWhite);
    term.append("A");
    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"A");
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::TransparentBg);
    assert_eq!(&uc.attr_bgcolor(Some(term)), &Color::Black);
    assert_eq!(&uc.attr_fgcolor(Some(term)), &Color::XtermWhite);
    assert_eq!(&uc.attrib(), &Attrib::Normal);

    // Put a short string "BCD" into the first line of the buffer, with fg color change after the 'B' and bold after 'C'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[32mC\x1b[1mD\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermGreen);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermGreen);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_rgb(0x20, 0xf0, 0x20));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.attr_fgcolor(Some(term)),
        &Color::from_rgb(0x20, 0xf0, 0x20)
    );
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_rgb(0x20, 0x20, 0x20));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Put a short string "BCDE" into the buffer, with fg color change after the 'B', bg change after 'C', and bold after 'D'
    term.clear();
    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.set_text_attrib(Attrib::Normal);
    assert_eq!(term.text_attrib(), Attrib::Normal);

    assert!(term.ansi());
    term.append("B\x1b[37mC\x1b[44mD\x1b[1mE\n");

    let r = &term.u8c_disp_row(0);
    let uc = r.col(0);
    assert_eq!(uc.text_utf8(), b"B");
    assert!(uc.is_char(b'B'));
    assert!(!uc.is_char(b'A'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(1);
    assert_eq!(uc.text_utf8(), b"C");
    assert!(uc.is_char(b'C'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBlack);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBlack);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(2);
    assert_eq!(uc.text_utf8(), b"D");
    assert!(uc.is_char(b'D'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::XtermWhite);
    assert_eq!(&uc.attr_bgcolor(None), &Color::XtermBgBlue);
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    let uc = r.col(3);
    assert_eq!(uc.text_utf8(), b"E");
    assert!(uc.is_char(b'E'));
    assert_eq!(&uc.fgcolor(), &Color::XtermWhite);
    assert_eq!(&uc.bgcolor(), &Color::XtermBgBlue);
    assert_eq!(&uc.attr_fgcolor(None), &Color::from_hex(0xf0f0f0));
    assert_eq!(&uc.attr_bgcolor(None), &Color::from_hex(0x2020e0));
    assert_eq!(
        &uc.charflags(),
        &(CharFlags::FG_XTERM | CharFlags::BG_XTERM)
    );

    // Test some miscellaneous Utf8 constants
    assert_eq!(uc.length(), 1);
    assert_eq!(uc.max_utf8(), 4);
    assert_eq!(uc.pwidth(), 9.0);
    assert_eq!(uc.pwidth_int(), 9);

    term.set_text_fg_color_xterm(XtermColor::White);
    term.set_text_bg_color_xterm(XtermColor::Black);
    term.clear();
    term.set_text_attrib(Attrib::Normal);

    // Mouse selection functions
    term.append(&format!("Mouse selection: {:?}\n", &term.get_selection()));
    term.clear_mouse_selection();
    assert_eq!(term.get_selection(), None);

    // Play with cursor position
    term.append("0123456789\n"); // Set up test pattern
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");

    term.set_cursor_row(1);
    assert_eq!(term.cursor_row(), 1);
    term.set_cursor_col(1);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"1");

    term.append("----"); // Overwrites text at cursor and moves cursor forward
    assert_eq!(term.cursor_row(), 1);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");
    term.set_cursor_col(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Overwritten text

    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen, so nothing happens
    term.cursor_up(1, false);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"o");

    // Hit top of screen with scroll enabled. A blank line from history is scrolled in.
    term.cursor_up(1, true);
    assert_eq!(term.cursor_row(), 0);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Go back down to the overwritten text
    term.cursor_down(2, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 1);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Go right past the overwritten text
    term.cursor_right(4, false);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"5");

    // Go left to the end of the overwritten text
    term.cursor_left(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-");

    // Scroll back down, removing the blank line at the top.
    // Cursor stays in place, the text moves under it.
    term.scroll(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    // Clear from here to end-of-line
    term.clear_eol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Now clear from here to start-of-line. Cursor does not move.
    term.clear_sol();
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_left(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_col(0);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");

    // Clear some lines
    term.clear_line(1);
    assert_eq!(term.cursor_row(), 2);
    assert_eq!(term.cursor_col(), 0);
    term.set_cursor_row(1);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.set_cursor_row(3);
    term.clear_cur_line();
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    assert_eq!(term.cursor_row(), 3);
    assert_eq!(term.cursor_col(), 0);

    term.append("Two lines above are intentionally left blank.\n");
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 0);

    // Set up the test pattern again, then play with insert/delete
    term.append("0123456789\n");
    term.append("ABCDEFGHIJ\n");
    term.append("abcdefghij\n");
    assert_eq!(term.cursor_row(), 7);

    term.set_cursor_row(4);
    term.set_cursor_col(4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.insert_char('x', 5); // Push this row right 5 chars starting at col 4
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.cursor_right(5, false);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Insert two blank rows above cursor. Cursor stays put.
    term.insert_rows(2);
    assert_eq!(term.cursor_row(), 4);
    assert_eq!(term.cursor_col(), 9);
    assert_eq!(term.u8c_cursor().text_utf8(), b" ");
    term.cursor_down(2, false); // Go down to find our text again
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    // Go back to the beginning of the inserted 'x' characters and delete them.
    term.cursor_left(5);
    assert_eq!(term.u8c_cursor().text_utf8(), b"x");
    term.delete_cur_chars(5);
    assert_eq!(term.cursor_row(), 6);
    assert_eq!(term.cursor_col(), 4);
    assert_eq!(term.u8c_cursor().text_utf8(), b"4");

    term.delete_chars(7, 2, 2); // Delete "CD" from the next row
    term.cursor_down(1, false);
    term.cursor_left(2);
    assert_eq!(term.u8c_cursor().text_utf8(), b"E");

    term.delete_rows(1); // Middle row of pattern is gone, cursor stays put
    assert_eq!(term.u8c_cursor().text_utf8(), b"c");
    term.cursor_up(1, false);
    term.delete_rows(2); // Delete remains of test pattern

    term.set_text_attrib(Attrib::Bold);
    term.insert_char_eol('-', 3, 15, 20);
    term.set_cursor_row(3);
    term.set_cursor_col(15);
    assert_eq!(term.u8c_cursor().text_utf8(), b"-"); // Check the insertion
    assert_eq!(term.u8c_cursor().attrib(), Attrib::Bold);

    term.set_text_attrib(Attrib::Italic);
    term.append(" and all lines below");
    term.set_text_attrib(Attrib::Normal);
    term.cursor_down(1, false);

    let mut hsb = term.hscrollbar();
    let mut sb = term.scrollbar();
    hsb.set_value(100.0);
    assert_eq!(hsb.value(), 100.0);
    sb.set_value(50.0);
    assert_eq!(sb.value(), 50.0);
    hsb.set_value(0.0);
    assert_eq!(hsb.value(), 0.0);
    sb.set_value(0.0);
    assert_eq!(sb.value(), 0.0);
}

pub fn u8c_hist_row(&self, hrow: i32) -> BuffRow<'_>

Return u8c for beginning of row hrow inside the scrollback history. This is a low-level “protected” function of the fltk library

pub fn u8c_hist_use_row(&self, hurow: i32) -> BuffRow<'_>

Return u8c for beginning of row hurow inside the ‘in use’ part of the\n scrollback history. This is a low-level “protected” function of the fltk library

pub fn u8c_ring_row(&self, grow: i32) -> BuffRow<'_>

Return u8c for beginning of row grow in the ring buffer. This is a low-level “protected” function of the fltk library

Trait Implementations

impl Clone for Terminal

fn clone(&self) -> Terminal

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Terminal

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Terminal

fn default() -> Self

Returns the “default value” for a type.

impl GroupExt for Terminal

fn begin(&self)

Begins a group, used for widgets implementing the group trait

fn end(&self)

Ends a group, used for widgets implementing the group trait

fn clear(&mut self)

Clear a group from all widgets

fn children(&self) -> i32

Return the number of children in a group

fn child(&self, idx: i32) -> Option<Widget>

Return child widget by index

fn find<W: WidgetExt>(&self, widget: &W) -> i32

Find a widget within a group and return its index

fn add<W: WidgetExt>(&mut self, widget: &W)

Add a widget to a group

fn insert<W: WidgetExt>(&mut self, widget: &W, index: i32)

Insert a widget to a group at a certain index

fn remove<W: WidgetExt>(&mut self, widget: &W)

Remove a widget from a group, but does not delete it

fn remove_by_index(&mut self, idx: i32)

Remove a child widget by its index

fn resizable<W: WidgetExt>(&self, widget: &W)

The resizable widget defines both the resizing frame and the resizing behavior of the group and its children.

fn make_resizable(&mut self, val: bool)

Make the group itself resizable, should be called before the widget is shown

fn add_resizable<W: WidgetExt>(&mut self, widget: &W)

Adds a widget to the group and makes it the resizable widget

fn set_clip_children(&mut self, flag: bool)

Clips children outside the group boundaries

fn clip_children(&self) -> bool

Get whether clip_children is set

fn draw_child<W: WidgetExt>(&self, w: &mut W)

Draw a child widget, the call should be in a WidgetBase::draw method

fn update_child<W: WidgetExt>(&self, w: &mut W)

Update a child widget, the call should be in a WidgetBase::draw method

fn draw_outside_label<W: WidgetExt>(&self, w: &mut W)

Draw the outside label, the call should be in a WidgetBase::draw method

fn draw_children(&mut self)

Draw children, the call should be in a WidgetBase::draw method

fn init_sizes(&mut self)

Resets the internal array of widget sizes and positions

fn bounds(&self) -> Vec<(i32, i32, i32, i32)>

Get the bounds of all children widgets (left, upper, right, bottom)

unsafe fn as_group(&self) -> Group

Converts a widget implementing GroupExt into a Group widget

impl IntoIterator for Terminal

type Item = Widget

The type of the elements being iterated over.

type IntoIter = IntoIter<<Terminal as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Terminal

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl WidgetBase for Terminal

fn delete(wid: Self)

Deletes widgets and their children.

unsafe fn from_widget_ptr(ptr: *mut Fl_Widget) -> Self

transforms a widget pointer to a Widget, for internal use

unsafe fn from_widget<W: WidgetExt>(w: W) -> Self

Get a widget from base widget

fn handle<F: FnMut(&mut Self, Event) -> bool + 'static>(&mut self, cb: F)

Set a custom handler, where events are managed manually, akin to Fl_Widget::handle(int). Handled or ignored events should return true, unhandled events should return false. takes the widget as a closure argument. The ability to handle an event might depend on handling other events, as explained here

fn draw<F: FnMut(&mut Self) + 'static>(&mut self, cb: F)

Set a custom draw method. takes the widget as a closure argument. macOS requires that WidgetBase::draw actually calls drawing functions

fn resize_callback<F: FnMut(&mut Self, i32, i32, i32, i32) + 'static>( &mut self, cb: F, )

Perform a callback on resize. Avoid resizing the parent or the same widget to avoid infinite recursion

unsafe fn assume_derived(&mut self)

Makes the widget derived

fn from_dyn_widget<W: WidgetExt>(w: &W) -> Option<Self>

Cast a type-erased widget back to its original widget

fn from_dyn_widget_ptr(w: *mut Fl_Widget) -> Option<Self>

Cast a type-erased widget pointer back to its original widget

impl WidgetExt for Terminal

fn set_label(&mut self, title: &str)

Sets the widget’s label. labels support special symbols preceded by an @ sign. and for the associated formatting.

fn unset_label(&mut self)

Unset a widget’s label

fn redraw(&mut self)

Redraws a widget, necessary for resizing and changing positions

fn show(&mut self)

Shows the widget

fn hide(&mut self)

Hides the widget

fn x(&self) -> i32

Returns the x coordinate of the widget

fn y(&self) -> i32

Returns the y coordinate of the widget

fn w(&self) -> i32

Returns the width of the widget

fn h(&self) -> i32

Returns the height of the widget

fn label(&self) -> Option<String>

Returns the label of the widget

fn measure_label(&self) -> (i32, i32)

Measures the label’s width and height

fn as_widget_ptr(&self) -> *mut Fl_Widget

transforms a widget to a base Fl_Widget, for internal use

fn activate(&mut self)

Activates the widget

fn deactivate(&mut self)

Deactivates the widget

fn redraw_label(&mut self)

Redraws the label of the widget

fn resize(&mut self, x: i32, y: i32, width: i32, height: i32)

Resizes and/or moves the widget, takes x, y, width and height

fn widget_resize(&mut self, x: i32, y: i32, width: i32, height: i32)

Does a simple resize ignoring class-specific resize functionality

fn tooltip(&self) -> Option<String>

Returns the tooltip text

fn set_tooltip(&mut self, txt: &str)

Sets the tooltip text

fn color(&self) -> Color

Returns the widget color

fn set_color(&mut self, color: Color)

Sets the widget’s color

fn label_color(&self) -> Color

Returns the widget label’s color

fn set_label_color(&mut self, color: Color)

Sets the widget label’s color

fn label_font(&self) -> Font

Returns the widget label’s font

fn set_label_font(&mut self, font: Font)

Sets the widget label’s font

fn label_size(&self) -> i32

Returns the widget label’s size

fn set_label_size(&mut self, sz: i32)

Sets the widget label’s size

fn label_type(&self) -> LabelType

Returns the widget label’s type

fn set_label_type(&mut self, typ: LabelType)

Sets the widget label’s type

fn frame(&self) -> FrameType

Returns the widget’s frame type

fn set_frame(&mut self, typ: FrameType)

Sets the widget’s frame type

fn changed(&self) -> bool

Returns whether the widget was changed

fn set_changed(&mut self)

Mark the widget as changed

fn clear_changed(&mut self)

Clears the changed status of the widget

fn align(&self) -> Align

Returns the alignment of the widget

fn set_align(&mut self, align: Align)

Sets the alignment of the widget

fn set_when(&mut self, trigger: When)

Sets the default callback trigger for a widget, equivalent to when()

fn when(&self) -> When

Return the callback trigger, equivalent to when()

fn parent(&self) -> Option<Group>

Returns the parent of the widget

fn selection_color(&self) -> Color

Gets the selection color of the widget

fn set_selection_color(&mut self, color: Color)

Sets the selection color of the widget

fn do_callback(&mut self)

Runs the already registered callback

fn window(&self) -> Option<Box<dyn WindowExt>>

Returns the direct window holding the widget

fn top_window(&self) -> Option<Box<dyn WindowExt>>

Returns the topmost window holding the widget

fn takes_events(&self) -> bool

Checks whether a widget is capable of taking events

fn take_focus(&mut self) -> Result<(), FltkError>

Make the widget take focus

fn set_visible_focus(&mut self)

Set the widget to have visible focus

fn clear_visible_focus(&mut self)

Clear visible focus

fn visible_focus(&mut self, v: bool)

Set the visible focus using a flag

fn has_visible_focus(&self) -> bool

Return whether the widget has visible focus

fn has_focus(&self) -> bool

Return whether the widget has focus

fn was_deleted(&self) -> bool

Check if a widget was deleted

fn damage(&self) -> bool

Return whether the widget was damaged

fn set_damage(&mut self, flag: bool)

Signal the widget as damaged and it should be redrawn in the next event loop cycle

fn damage_type(&self) -> Damage

Return the damage mask

fn set_damage_type(&mut self, mask: Damage)

Signal the type of damage a widget received

fn set_damage_area(&mut self, mask: Damage, x: i32, y: i32, w: i32, h: i32)

Signal damage for an area inside the widget

fn clear_damage(&mut self)

Clear the damaged flag

fn as_window(&self) -> Option<Box<dyn WindowExt>>

Return the widget as a window if it’s a window

fn as_group(&self) -> Option<Group>

Return the widget as a group widget if it’s a group widget

fn inside<W: WidgetExt>(&self, wid: &W) -> bool

Checks whether the self widget is inside another widget

fn get_type<T: WidgetType>(&self) -> T

Returns the widget type when applicable

fn set_type<T: WidgetType>(&mut self, typ: T)

Sets the widget type

fn set_image<I: ImageExt>(&mut self, image: Option<I>)

Sets the image of the widget

fn set_image_scaled<I: ImageExt>(&mut self, image: Option<I>)

Sets the image of the widget scaled to the widget’s size

fn image(&self) -> Option<Box<dyn ImageExt>>

Gets the image associated with the widget

fn set_deimage<I: ImageExt>(&mut self, image: Option<I>)

Sets the deactivated image of the widget

fn set_deimage_scaled<I: ImageExt>(&mut self, image: Option<I>)

Sets the deactivated image of the widget scaled to the widget’s size

fn deimage(&self) -> Option<Box<dyn ImageExt>>

Gets the deactivated image associated with the widget

fn set_callback<F: FnMut(&mut Self) + 'static>(&mut self, cb: F)

Sets the callback when the widget is triggered (clicks for example) takes the widget as a closure argument

fn emit<T: 'static + Clone + Send + Sync>(&mut self, sender: Sender<T>, msg: T)

Emits a message on callback using a sender

unsafe fn as_widget<W: WidgetBase>(&self) -> W

Upcast a WidgetExt to some widget type

fn visible(&self) -> bool

Returns whether a widget is visible

fn visible_r(&self) -> bool

Returns whether a widget or any of its parents are visible (recursively)

fn is_same<W: WidgetExt>(&self, other: &W) -> bool

Return whether two widgets object point to the same widget

fn active(&self) -> bool

Returns whether a widget is active

fn active_r(&self) -> bool

Returns whether a widget or any of its parents are active (recursively)

fn handle_event(&mut self, event: Event) -> bool

Handle a specific event

fn is_derived(&self) -> bool

Check whether a widget is derived

fn as_base_widget(&self) -> Widget

where Self: Sized,

Upcast a WidgetExt to a Widget

impl WidgetProps for Terminal

fn with_pos(self, x: i32, y: i32) -> Self

Initialize to position x, y

fn with_size(self, width: i32, height: i32) -> Self

Initialize to size width, height

fn with_label(self, title: &str) -> Self

Initialize with a label

fn with_align(self, align: Align) -> Self

Initialize with alignment

fn with_type<T: WidgetType>(self, typ: T) -> Self

Initialize with type

fn below_of<W: WidgetExt>(self, wid: &W, padding: i32) -> Self

Initialize at bottom of another widget

fn above_of<W: WidgetExt>(self, wid: &W, padding: i32) -> Self

Initialize above of another widget

fn right_of<W: WidgetExt>(self, wid: &W, padding: i32) -> Self

Initialize right of another widget

fn left_of<W: WidgetExt>(self, wid: &W, padding: i32) -> Self

Initialize left of another widget

fn center_of<W: WidgetExt>(self, w: &W) -> Self

Initialize center of another widget

fn center_x<W: WidgetExt>(self, w: &W) -> Self

Initialize center of another widget on the x axis

fn center_y<W: WidgetExt>(self, w: &W) -> Self

Initialize center of another widget on the y axis

fn center_of_parent(self) -> Self

Initialize center of parent

fn size_of<W: WidgetExt>(self, w: &W) -> Self

Initialize to the size of another widget

fn size_of_parent(self) -> Self

Initialize to the size of the parent

impl Eq for Terminal

impl Send for Terminal

Available on non-crate feature single-threaded only.

impl Sync for Terminal

Available on non-crate feature single-threaded only.