Struct Terminal

pub struct Terminal { /* private fields */ }

Available on crate feature dep_fltk only.

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 ansi(&self) -> bool

Returns whether the terminal is in ANSI mode.

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().

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()

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()

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()

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()

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()

pub fn clear(&mut self)

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

pub fn clear_mouse_selection(&mut self)

Clear any current mouse selection.

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

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.

pub fn clear_history(&mut self)

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

pub fn color(&self) -> Color

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

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.

pub fn cursor_col(&self) -> i32

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

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

pub fn cursor_row(&self) -> i32

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

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

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

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

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

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

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

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”.

pub fn clear_cur_line(&mut self)

Clear entire line cursor is currently on.

pub fn clear_line(&mut self, drow: i32)

Clear entire line for specified row.

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”.

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

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

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

pub fn delete_chars(&mut self, drow: i32, dcol: i32, count: i32)

Delete char(s) at (drow,dcol) for count times.

pub fn delete_cur_chars(&mut self, count: i32)

Delete char(s) at cursor position for count times.

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

pub fn cursor_bg_color(&self) -> Color

Get the cursor’s background color used for the cursor itself.

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

Set the cursor’s background color used for the cursor itself.

pub fn cursor_fg_color(&self) -> Color

Get the cursor’s foreground color used for the cursor itself.

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

Set the cursor’s foreground color used for the cursor itself.

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

pub fn cursor_home(&mut self)

Move cursor to the home position (top/left).

pub fn display_columns(&self) -> i32

Return terminal’s display width in columns of text characters.

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

Set terminal’s display width in columns of text characters. Does not resize the terminal.

pub fn display_rows(&self) -> i32

Return terminal’s display height in lines of text.

pub fn set_history_rows(&mut self, arg1: i32)

Sets the terminal’s scrollback history buffer size in lines of text (rows).

pub fn history_rows(&self) -> i32

Gets the terminal’s scrollback history buffer size in lines of text (rows).

pub fn history_use(&self) -> i32

Returns how many lines are “in use” by the screen history buffer.

pub fn set_margin_bottom(&mut self, arg1: i32)

Set the bottom margin

pub fn margin_bottom(&self) -> i32

Return the bottom margin

pub fn set_margin_left(&mut self, arg1: i32)

Set the left margin

pub fn margin_left(&self) -> i32

Return the left margin

pub fn set_margin_right(&mut self, arg1: i32)

Set the right margin

pub fn margin_right(&self) -> i32

Return the right margin

pub fn set_margin_top(&mut self, arg1: i32)

Set the top margin

pub fn margin_top(&self) -> i32

Return the top margin

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

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

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.

pub fn output_translate(&self) -> OutFlags

Return the current combined output translation flags.

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

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

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.

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).

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.

pub fn redraw_rate(&self) -> f32

Get max rate redraw speed in floating point seconds.

pub fn set_redraw_style(&mut self, set: RedrawStyle)

Set how Terminal manages screen redrawing.

pub fn redraw_style(&self) -> RedrawStyle

Get the redraw style.

pub fn reset_terminal(&mut self)

Resets terminal to default colors, clears screen, history and mouse selection, homes cursor, resets tabstops.

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.

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.

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

pub fn selection_bg_color(&self) -> Color

Get mouse selection background color.

pub fn scrollbar(&self) -> Scrollbar

Returns the vertical scrollbar

pub fn hscrollbar(&self) -> Scrollbar

Returns the horizontal scrollbar

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.

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

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

Set mouse selection background color.

pub fn selection_fg_color(&self) -> Color

Get mouse selection foreground color.

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

Set mouse selection foreground color.

pub fn show_unknown(&self) -> bool

Return the “show unknown” flag. if true, show unknown chars as ‘¿’

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

Set the “show unknown” flag. if true, show unknown chars as ‘¿’ (default off)

pub fn text_attrib(&self) -> Attrib

Return the text attribute bits (underline, inverse, etc) for subsequent appends.

pub fn set_text_attrib(&mut self, arg1: Attrib)

Set text attribute bits (underline, inverse, etc) for subsequent appends.

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).

pub fn text_bg_color(&self) -> Color

Get the text background color.

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.

pub fn text_bg_color_default(&self) -> Color

Return the default text background color.

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

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)

pub fn text_fg_color(&self) -> Color

Get the text foreground color.

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.

pub fn text_fg_color_default(&self) -> Color

Return the default text foreground color.

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

pub fn text_font(&self) -> Font

Get the text font

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.

pub fn text_size(&self) -> i32

Return text font size used to draw all text in the terminal.

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().

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);

pub fn selection_text(&self) -> String

Return text selection (for copy()/paste() operations)

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.

pub fn disp_erow(&self) -> i32

Return the ending row# in the display area.

pub fn disp_srow(&self) -> i32

Return the starting row# in the display area.

pub fn hist_erow(&self) -> i32

Return the ending row# of the scrollback history.

pub fn hist_srow(&self) -> i32

Return the starting row# of the scrollback history.

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.

pub fn ring_erow(&self) -> i32

Return the ending row# in the ring buffer (Always ring_rows()-1)

pub fn ring_srow(&self) -> i32

Return the starting row# in the ring buffer (Always 0)

pub fn ring_rows(&self) -> i32

Return the number of rows in the ring buffer.

pub fn u8c_cursor(&self) -> Utf8Char

Return the Utf8Char for character under cursor.

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

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<(), Error>

Formats the value using the given formatter.

impl Default for Terminal

fn default() -> Terminal

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>(&self, widget: &W) -> i32

where W: WidgetExt,

Find a widget within a group and return its index

fn add<W>(&mut self, widget: &W)

where W: WidgetExt,

Add a widget to a group

fn insert<W>(&mut self, widget: &W, index: i32)

where W: WidgetExt,

Insert a widget to a group at a certain index

fn remove<W>(&mut self, widget: &W)

where W: WidgetExt,

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>(&self, widget: &W)

where W: WidgetExt,

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>(&mut self, widget: &W)

where W: WidgetExt,

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>(&self, w: &mut W)

where W: WidgetExt,

Draw a child widget, the call should be in a WidgetBase::draw method

fn update_child<W>(&self, w: &mut W)

where W: WidgetExt,

Update a child widget, the call should be in a WidgetBase::draw method

fn draw_outside_label<W>(&self, w: &mut W)

where W: WidgetExt,

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 into_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) -> <Terminal as IntoIterator>::IntoIter

Creates an iterator from a value.

impl PartialEq for Terminal

fn eq(&self, other: &Terminal) -> 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 new<'a, T>(x: i32, y: i32, width: i32, height: i32, title: T) -> Terminal

where T: Into<Option<&'a str>>,

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

fn default_fill() -> Terminal

Constructs a widget with the size of its parent

fn delete(wid: Terminal)

Deletes widgets and their children.

unsafe fn from_widget_ptr(ptr: *mut Fl_Widget) -> Terminal

transforms a widget pointer to a Widget, for internal use

unsafe fn from_widget<W>(w: W) -> Terminal

where W: WidgetExt,

Get a widget from base widget

fn handle<F>(&mut self, cb: F)

where F: FnMut(&mut Terminal, Event) -> bool + 'static,

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>(&mut self, cb: F)

where F: FnMut(&mut Terminal) + 'static,

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>(&mut self, cb: F)

where F: FnMut(&mut Terminal, i32, i32, i32, i32) + 'static,

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>(w: &W) -> Option<Terminal>

where W: WidgetExt,

Cast a type-erased widget back to its original widget

fn from_dyn_widget_ptr(w: *mut Fl_Widget) -> Option<Terminal>

Cast a type-erased widget pointer back to its original widget

impl WidgetExt for Terminal

fn center_x<W>(self, w: &W) -> Terminal

where W: WidgetExt,

Initialize center of another widget

fn center_y<W>(self, w: &W) -> Terminal

where W: WidgetExt,

Initialize center of another widget

fn with_pos(self, x: i32, y: i32) -> Terminal

Initialize to a position x, y

fn with_size(self, width: i32, height: i32) -> Terminal

Initialize to size width, height

fn with_label(self, title: &str) -> Terminal

Initialize with a label

fn with_align(self, align: Align) -> Terminal

Initialize with alignment

fn with_type<T>(self, typ: T) -> Terminal

where T: WidgetType,

Initialize with type

fn below_of<W>(self, wid: &W, padding: i32) -> Terminal

where W: WidgetExt,

Initialize at bottom of another widget

fn above_of<W>(self, wid: &W, padding: i32) -> Terminal

where W: WidgetExt,

Initialize above of another widget

fn right_of<W>(self, wid: &W, padding: i32) -> Terminal

where W: WidgetExt,

Initialize right of another widget

fn left_of<W>(self, wid: &W, padding: i32) -> Terminal

where W: WidgetExt,

Initialize left of another widget

fn center_of<W>(self, w: &W) -> Terminal

where W: WidgetExt,

Initialize center of another widget

fn center_of_parent(self) -> Terminal

Initialize center of parent

fn size_of<W>(self, w: &W) -> Terminal

where W: WidgetExt,

Initialize to the size of another widget

fn size_of_parent(self) -> Terminal

Initialize to the size of the parent

fn set_pos(&mut self, x: i32, y: i32)

Set to position x, y

fn set_size(&mut self, width: i32, height: i32)

Set to dimensions width and height

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 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 width(&self) -> i32

Returns the width of the widget

fn height(&self) -> i32

Returns the height 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) -> 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_trigger(&mut self, trigger: CallbackTrigger)

Sets the default callback trigger for a widget, equivalent to when()

fn trigger(&self) -> CallbackTrigger

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>(&self, wid: &W) -> bool

where W: WidgetExt,

Checks whether the self widget is inside another widget

fn get_type<T>(&self) -> T

where T: WidgetType,

Returns the widget type when applicable

fn set_type<T>(&mut self, typ: T)

where T: WidgetType,

Sets the widget type

fn set_image<I>(&mut self, image: Option<I>)

where I: ImageExt,

Sets the image of the widget

fn set_image_scaled<I>(&mut self, image: Option<I>)

where I: ImageExt,

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

unsafe fn image_mut(&self) -> Option<&mut Image>

Get a reference type of the widget’s image

fn set_deimage<I>(&mut self, image: Option<I>)

where I: ImageExt,

Sets the deactivated image of the widget

fn set_deimage_scaled<I>(&mut self, image: Option<I>)

where I: ImageExt,

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

unsafe fn deimage_mut(&self) -> Option<&mut Image>

Get a reference type of the widget’s deactivated image

fn set_callback<F>(&mut self, cb: F)

where F: FnMut(&mut Terminal) + 'static,

Sets the callback when the widget is triggered (clicks for example) takes the widget as a closure argument

fn emit<T>(&mut self, sender: Sender<T>, msg: T)

where T: 'static + Clone + Send + Sync,

Emits a message on callback using a sender

unsafe fn into_widget<W>(&self) -> W

where W: WidgetBase,

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>(&self, other: &W) -> bool

where W: WidgetExt,

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 Eq for Terminal

impl Send for Terminal

impl Sync for Terminal