Struct rerun::external::eframe::egui::widgets::TextEdit

pub struct TextEdit<'t> {

    text: &'t mut dyn TextBuffer,
    hint_text: WidgetText,
    hint_text_font: Option<FontSelection>,
    id: Option<Id>,
    id_salt: Option<Id>,
    font_selection: FontSelection,
    text_color: Option<Color32>,
    layouter: Option<&'t mut dyn FnMut(&Ui, &str, f32) -> Arc<Galley>>,
    password: bool,
    frame: bool,
    margin: Margin,
    multiline: bool,
    interactive: bool,
    desired_width: Option<f32>,
    desired_height_rows: usize,
    event_filter: EventFilter,
    cursor_at_end: bool,
    min_size: Vec2,
    align: Align2,
    clip_text: bool,
    char_limit: usize,
    return_key: Option<KeyboardShortcut>,
}

A text region that the user can edit the contents of.

See also Ui::text_edit_singleline and Ui::text_edit_multiline.

Example:

let response = ui.add(egui::TextEdit::singleline(&mut my_string));
if response.changed() {
    // …
}
if response.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
    // …
}

To fill an Ui with a TextEdit use Ui::add_sized:

ui.add_sized(ui.available_size(), egui::TextEdit::multiline(&mut my_string));

You can also use TextEdit to show text that can be selected, but not edited. To do so, pass in a &mut reference to a &str, for instance:

fn selectable_text(ui: &mut egui::Ui, mut text: &str) {
    ui.add(egui::TextEdit::multiline(&mut text));
}

Advanced usage

See TextEdit::show.

Other

The background color of a crate::TextEdit is crate::Visuals::extreme_bg_color.

Fields

text: &'t mut dyn TextBuffer

hint_text: WidgetText

hint_text_font: Option<FontSelection>

id: Option<Id>

id_salt: Option<Id>

font_selection: FontSelection

text_color: Option<Color32>

layouter: Option<&'t mut dyn FnMut(&Ui, &str, f32) -> Arc<Galley>>

password: bool

frame: bool

margin: Margin

multiline: bool

interactive: bool

desired_width: Option<f32>

desired_height_rows: usize

event_filter: EventFilter

cursor_at_end: bool

min_size: Vec2

align: Align2

clip_text: bool

char_limit: usize

return_key: Option<KeyboardShortcut>

Implementations

impl<'t> TextEdit<'t>

pub fn load_state(ctx: &Context, id: Id) -> Option<TextEditState>

pub fn store_state(ctx: &Context, id: Id, state: TextEditState)

impl<'t> TextEdit<'t>

pub fn singleline(text: &'t mut dyn TextBuffer) -> TextEdit<'t>

No newlines (\n) allowed. Pressing enter key will result in the TextEdit losing focus (response.lost_focus).

pub fn multiline(text: &'t mut dyn TextBuffer) -> TextEdit<'t>

A TextEdit for multiple lines. Pressing enter key will create a new line by default (can be changed with return_key).

pub fn code_editor(self) -> TextEdit<'t>

Build a TextEdit focused on code editing. By default it comes with:

• monospaced font
• focus lock (tab will insert a tab character instead of moving focus)

pub fn id(self, id: Id) -> TextEdit<'t>

Use if you want to set an explicit Id for this widget.

pub fn id_source(self, id_salt: impl Hash) -> TextEdit<'t>

A source for the unique Id, e.g. .id_source("second_text_edit_field") or .id_source(loop_index).

pub fn id_salt(self, id_salt: impl Hash) -> TextEdit<'t>

A source for the unique Id, e.g. .id_salt("second_text_edit_field") or .id_salt(loop_index).

pub fn hint_text(self, hint_text: impl Into<WidgetText>) -> TextEdit<'t>

Show a faint hint text when the text field is empty.

If the hint text needs to be persisted even when the text field has input, the following workaround can be used:

let text_edit = egui::TextEdit::multiline(&mut my_string)
    .desired_width(f32::INFINITY);
let output = text_edit.show(ui);
let painter = ui.painter_at(output.response.rect);
let text_color = Color32::from_rgba_premultiplied(100, 100, 100, 100);
let galley = painter.layout(
    String::from("Enter text"),
    FontId::default(),
    text_color,
    f32::INFINITY
);
painter.galley(output.galley_pos, galley, text_color);

pub fn hint_text_font( self, hint_text_font: impl Into<FontSelection> ) -> TextEdit<'t>

Set a specific style for the hint text.

pub fn password(self, password: bool) -> TextEdit<'t>

If true, hide the letters from view and prevent copying from the field.

pub fn font(self, font_selection: impl Into<FontSelection>) -> TextEdit<'t>

Pick a crate::FontId or TextStyle.

pub fn text_color(self, text_color: Color32) -> TextEdit<'t>

pub fn text_color_opt(self, text_color: Option<Color32>) -> TextEdit<'t>

pub fn layouter( self, layouter: &'t mut dyn FnMut(&Ui, &str, f32) -> Arc<Galley> ) -> TextEdit<'t>

Override how text is being shown inside the TextEdit.

This can be used to implement things like syntax highlighting.

This function will be called at least once per frame, so it is strongly suggested that you cache the results of any syntax highlighter so as not to waste CPU highlighting the same string every frame.

The arguments is the enclosing Ui (so you can access e.g. Ui::fonts), the text and the wrap width.

let mut layouter = |ui: &egui::Ui, string: &str, wrap_width: f32| {
    let mut layout_job: egui::text::LayoutJob = my_memoized_highlighter(string);
    layout_job.wrap.max_width = wrap_width;
    ui.fonts(|f| f.layout_job(layout_job))
};
ui.add(egui::TextEdit::multiline(&mut my_code).layouter(&mut layouter));

pub fn interactive(self, interactive: bool) -> TextEdit<'t>

Default is true. If set to false then you cannot interact with the text (neither edit or select it).

Consider using Ui::add_enabled instead to also give the TextEdit a greyed out look.

pub fn frame(self, frame: bool) -> TextEdit<'t>

Default is true. If set to false there will be no frame showing that this is editable text!

pub fn margin(self, margin: impl Into<Margin>) -> TextEdit<'t>

Set margin of text. Default is Margin::symmetric(4.0, 2.0)

pub fn desired_width(self, desired_width: f32) -> TextEdit<'t>

Set to 0.0 to keep as small as possible. Set to f32::INFINITY to take up all available space (i.e. disable automatic word wrap).

pub fn desired_rows(self, desired_height_rows: usize) -> TextEdit<'t>

Set the number of rows to show by default. The default for singleline text is 1. The default for multiline text is 4.

pub fn lock_focus(self, tab_will_indent: bool) -> TextEdit<'t>

When false (default), pressing TAB will move focus to the next widget.

When true, the widget will keep the focus and pressing TAB will insert the '\t' character.

pub fn cursor_at_end(self, b: bool) -> TextEdit<'t>

When true (default), the cursor will initially be placed at the end of the text.

When false, the cursor will initially be placed at the beginning of the text.

pub fn clip_text(self, b: bool) -> TextEdit<'t>

When true (default), overflowing text will be clipped.

When false, widget width will expand to make all text visible.

This only works for singleline TextEdit.

pub fn char_limit(self, limit: usize) -> TextEdit<'t>

Sets the limit for the amount of characters can be entered

This only works for singleline TextEdit

pub fn horizontal_align(self, align: Align) -> TextEdit<'t>

Set the horizontal align of the inner text.

pub fn vertical_align(self, align: Align) -> TextEdit<'t>

Set the vertical align of the inner text.

pub fn min_size(self, min_size: Vec2) -> TextEdit<'t>

Set the minimum size of the TextEdit.

pub fn return_key( self, return_key: impl Into<Option<KeyboardShortcut>> ) -> TextEdit<'t>

Set the return key combination.

This combination will cause a newline on multiline, whereas on singleline it will cause the widget to lose focus.

This combination is optional and can be disabled by passing None into this function.

impl<'t> TextEdit<'t>

pub fn show(self, ui: &mut Ui) -> TextEditOutput

Show the TextEdit, returning a rich TextEditOutput.

let output = egui::TextEdit::singleline(&mut my_string).show(ui);
if let Some(text_cursor_range) = output.cursor_range {
    use egui::TextBuffer as _;
    let selected_chars = text_cursor_range.as_sorted_char_range();
    let selected_text = my_string.char_range(selected_chars);
    ui.label("Selected text: ");
    ui.monospace(selected_text);
}

Trait Implementations

impl<'t> Widget for TextEdit<'t>

fn ui(self, ui: &mut Ui) -> Response

Allocate space, interact, paint, and return a Response.

impl<'t> WidgetWithState for TextEdit<'t>

type State = TextEditState