Struct TextEditor 

pub struct TextEditor { /* private fields */ }

A text editor view built on top of Editor. See text_editor.

Note: this requires that the document underlying it is a TextDocument for the use of some logic.

Implementations

impl TextEditor

pub fn editor_style( self, style: impl Fn(EditorCustomStyle) -> EditorCustomStyle + 'static, ) -> Self

Sets the custom style properties of the TextEditor.

pub fn editor(&self) -> &Editor

Return a reference to the underlying Editor.

pub fn with_editor(self, f: impl FnOnce(&Editor)) -> Self

Allows for creation of a TextEditor with an existing Editor.

pub fn with_editor_mut(self, f: impl FnOnce(&mut Editor)) -> Self

Allows for creation of a TextEditor with an existing mutable Editor.

pub fn editor_id(&self) -> EditorId

Returns the EditorId of the underlying Editor.

pub fn with_doc(self, f: impl FnOnce(&dyn Document)) -> Self

Opens the TextEditor with the provided Document. You should usually not swap this out without good reason.

pub fn doc(&self) -> Rc<dyn Document>

Returns a reference to the underlying Document. This should usually be a TextDocument.

pub fn rope_text(&self) -> RopeTextVal

pub fn use_doc(self, doc: Rc<dyn Document>) -> Self

Use a different document in the text editor

pub fn share_doc(self, other: &TextEditor) -> Self

Use the same document as another text editor view.

let primary = text_editor();
let secondary = text_editor().share_document(&primary);

stack((
    primary,
    secondary,
))

If you wish for it to also share the styling, consider using TextEditor::shared_editor instead.

pub fn shared_editor(&self) -> TextEditor

Create a new TextEditor instance from this instance, sharing the document and styling.

let primary = text_editor();
let secondary = primary.shared_editor();

Also see the Editor example.

pub fn styling(self, styling: impl Styling + 'static) -> Self

Change the Styling used for the editor.

let styling = SimpleStyling::builder()
    .font_size(12)
    .weight(Weight::BOLD);
text_editor().styling(styling);

pub fn styling_rc(self, styling: Rc<dyn Styling>) -> Self

Use an Rc<dyn Styling> to share between different editors.

pub fn read_only(self) -> Self

Set the text editor to read only. Equivalent to setting Editor::read_only Default: false

pub fn placeholder(self, text: impl Into<String>) -> Self

Set the placeholder text that is displayed when the document is empty. Can span multiple lines. This is per-editor, not per-document. Equivalent to calling TextDocument::add_placeholder Default: None

Note: only works for the default backing TextDocument doc

pub fn pre_command( self, f: impl Fn(PreCommand<'_>) -> CommandExecuted + 'static, ) -> Self

When commands are run on the document, this function is called. If it returns CommandExecuted::Yes then further handlers after it, including the default handler, are not executed.

use floem::views::editor::command::{Command, CommandExecuted};
use floem::views::text_editor::text_editor;
use floem_editor_core::command::EditCommand;
text_editor("Hello")
    .pre_command(|ev| {
        if matches!(ev.cmd, Command::Edit(EditCommand::Undo)) {
            // Sorry, no undoing allowed
            CommandExecuted::Yes
        } else {
            CommandExecuted::No
        }
    })
    .pre_command(|_| {
        // This will never be called if command was an undo
        CommandExecuted::Yes
    })
    .pre_command(|_| {
        // This will never be called
        CommandExecuted::No
    });

Note that these are specific to each text editor view.

Note: only works for the default backing TextDocument doc

pub fn update(self, f: impl Fn(OnUpdate<'_>) + 'static) -> Self

Listen for deltas applied to the editor.

Useful for anything that has positions based in the editor that can be updated after typing, such as syntax highlighting.

Note: only works for the default backing TextDocument doc

Trait Implementations

impl View for TextEditor

fn id(&self) -> ViewId

fn view_style(&self) -> Option<Style>

fn debug_name(&self) -> Cow<'static, str>

fn paint(&mut self, cx: &mut PaintCx<'_>)

View-specific implementation. Will be called in PaintCx::paint_view. Usually you’ll call paint_view for every child view. But you might also draw text, adjust the offset, clip or draw text.

fn view_class(&self) -> Option<StyleClassRef>

fn update(&mut self, cx: &mut UpdateCx<'_>, state: Box<dyn Any>)

Use this method to react to changes in view-related state. You will usually send state to this hook manually using the View’s Id handle

fn style_pass(&mut self, cx: &mut StyleCx<'_>)

Use this method to style the view’s children.

fn layout(&mut self, cx: &mut LayoutCx<'_>) -> NodeId

Use this method to layout the view’s children. Usually you’ll do this by calling LayoutCx::layout_node.

fn compute_layout(&mut self, cx: &mut ComputeLayoutCx<'_>) -> Option<Rect>

Responsible for computing the layout of the view’s children.

fn event_before_children( &mut self, cx: &mut EventCx<'_>, event: &Event, ) -> EventPropagation

fn event_after_children( &mut self, cx: &mut EventCx<'_>, event: &Event, ) -> EventPropagation

fn scroll_to( &mut self, cx: &mut WindowState, target: ViewId, rect: Option<Rect>, ) -> bool

Scrolls the view and all direct and indirect children to bring the target view to be visible. Returns true if this view contains or is the target.