Struct TextEditor 

pub struct TextEditor<'a, Message, Renderer = Renderer>
where
    Renderer: Renderer,
{ /* private fields */ }

A Material 3 outlined multi-line text field.

Implementations

impl<'a, Message, Renderer> TextEditor<'a, Message, Renderer>

where Message: 'a, Renderer: Renderer + 'a,

pub fn new(content: &'a Content<Renderer>) -> Self

pub fn id(self, id: impl Into<Id>) -> Self

pub fn placeholder(self, placeholder: impl IntoFragment<'a>) -> Self

Examples found in repository

examples/showcase/pages/inputs.rs (line 11)

pub(super) fn view(state: &Showcase) -> material::Element<'_, Message> {
    let input = material::widget::text_input::outlined("Write a note", &state.note)
        .on_input(Message::TextChanged);

    let editor = material::widget::text_editor::outlined_area(&state.editor_content)
        .placeholder("Write details")
        .on_action(Message::EditorAction);

    let select_options = ["Assist", "Suggestion", "Filter"];
    let select = material::widget::select::outlined(
        select_options,
        state.select_choice,
        Message::SelectChanged,
    )
    .placeholder("Choose a chip")
    .label("Chip type");

    let combobox = material::widget::combobox::outlined_with_input(
        &state.combobox_options,
        "Search a chip",
        &state.combobox_input,
        state.combobox_choice.as_ref(),
        Message::ComboboxSelected,
    )
    .label("Searchable chip")
    .on_input(Message::ComboboxInputChanged);

    page::sections([
        page::section("Text fields", page::stack([input.into(), editor.into()])).into(),
        page::section(
            "Selection fields",
            page::stack([select.into(), combobox.into()]),
        )
        .into(),
        page::section("Pickers", pickers(state)).into(),
        page::section("Search", search_bar(state)).into(),
        page::section("Dividers", dividers()).into(),
    ])
    .into()
}

pub fn width(self, width: impl Into<Pixels>) -> Self

pub fn height(self, height: impl Into<Length>) -> Self

pub fn min_height(self, min_height: impl Into<Pixels>) -> Self

pub fn max_height(self, max_height: impl Into<Pixels>) -> Self

pub fn on_action(self, on_edit: impl Fn(Action) -> Message + 'a) -> Self

Examples found in repository

examples/showcase/pages/inputs.rs (line 12)

pub(super) fn view(state: &Showcase) -> material::Element<'_, Message> {
    let input = material::widget::text_input::outlined("Write a note", &state.note)
        .on_input(Message::TextChanged);

    let editor = material::widget::text_editor::outlined_area(&state.editor_content)
        .placeholder("Write details")
        .on_action(Message::EditorAction);

    let select_options = ["Assist", "Suggestion", "Filter"];
    let select = material::widget::select::outlined(
        select_options,
        state.select_choice,
        Message::SelectChanged,
    )
    .placeholder("Choose a chip")
    .label("Chip type");

    let combobox = material::widget::combobox::outlined_with_input(
        &state.combobox_options,
        "Search a chip",
        &state.combobox_input,
        state.combobox_choice.as_ref(),
        Message::ComboboxSelected,
    )
    .label("Searchable chip")
    .on_input(Message::ComboboxInputChanged);

    page::sections([
        page::section("Text fields", page::stack([input.into(), editor.into()])).into(),
        page::section(
            "Selection fields",
            page::stack([select.into(), combobox.into()]),
        )
        .into(),
        page::section("Pickers", pickers(state)).into(),
        page::section("Search", search_bar(state)).into(),
        page::section("Dividers", dividers()).into(),
    ])
    .into()
}

pub fn font(self, font: impl Into<Renderer::Font>) -> Self

pub fn size(self, size: impl Into<Pixels>) -> Self

pub fn line_height(self, line_height: impl Into<LineHeight>) -> Self

pub fn padding(self, padding: impl Into<Padding>) -> Self

pub fn wrapping(self, wrapping: Wrapping) -> Self

pub fn key_binding( self, key_binding: impl Fn(KeyPress) -> Option<Binding<Message>> + 'a, ) -> Self

pub fn style(self, style: impl Fn(&Theme, Status) -> Style + 'a) -> Self

where <Theme as Catalog>::Class<'a>: From<StyleFn<'a, Theme>>,

Trait Implementations

impl<Message, Renderer> Debug for TextEditor<'_, Message, Renderer>

where Renderer: Renderer,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, Message, Renderer> From<TextEditor<'a, Message, Renderer>> for Element<'a, Message, Theme, Renderer>

where Message: 'a, Renderer: Renderer + 'a,

fn from(text_editor: TextEditor<'a, Message, Renderer>) -> Self

Converts to this type from the input type.

impl<Message, Renderer> Widget<Message, Theme, Renderer> for TextEditor<'_, Message, Renderer>

where Renderer: Renderer,

fn tag(&self) -> Tag

Returns the Tag of the Widget.

fn state(&self) -> State

Returns the State of the Widget.

fn children(&self) -> Vec<Tree>

Returns the state Tree of the children of the Widget.

fn diff(&self, tree: &mut Tree)

Reconciles the Widget with the provided Tree.

fn size(&self) -> Size<Length>

Returns the Size of the Widget in lengths.

fn size_hint(&self) -> Size<Length>

Returns a Size hint for laying out the Widget.

fn layout( &mut self, tree: &mut Tree, renderer: &Renderer, limits: &Limits, ) -> Node

Returns the layout::Node of the Widget.

fn operate( &mut self, tree: &mut Tree, layout: Layout<'_>, renderer: &Renderer, operation: &mut dyn Operation, )

Applies an Operation to the Widget.

fn update( &mut self, tree: &mut Tree, event: &Event, layout: Layout<'_>, cursor: Cursor, renderer: &Renderer, clipboard: &mut dyn Clipboard, shell: &mut Shell<'_, Message>, viewport: &Rectangle, )

Processes a runtime Event.

fn mouse_interaction( &self, tree: &Tree, layout: Layout<'_>, cursor: Cursor, viewport: &Rectangle, renderer: &Renderer, ) -> Interaction

Returns the current mouse::Interaction of the Widget.

fn draw( &self, tree: &Tree, renderer: &mut Renderer, theme: &Theme, defaults: &Style, layout: Layout<'_>, cursor: Cursor, viewport: &Rectangle, )

Draws the Widget using the associated Renderer.

fn overlay<'b>( &'b mut self, tree: &'b mut Tree, layout: Layout<'b>, renderer: &Renderer, viewport: &Rectangle, translation: Vector, ) -> Option<Element<'b, Message, Theme, Renderer>>

Returns the overlay of the Widget, if there is any.