Struct BlockEditorState 

pub struct BlockEditorState { /* private fields */ }

Implementations

impl BlockEditorState

pub fn new(window: &mut Window, cx: &mut Context<'_, Self>) -> Self

Create an editor holding one empty paragraph.

pub fn with_submit_policy(self, policy: SubmitPolicy) -> Self

pub fn set_submit_policy(&mut self, policy: SubmitPolicy)

Replace the policy; notify the editor after changing it so the retained view’s policy-scoped key context is refreshed.

pub fn with_clipboard_policy(self, policy: ClipboardPolicy) -> Self

pub fn set_clipboard_policy(&mut self, policy: ClipboardPolicy)

pub fn scroll_handle(&self) -> Option<ScrollHandle>

The retained scroll owner; content-sized wrappers share this handle.

pub fn with_input_rules( self, rules: impl IntoIterator<Item = InputRule>, ) -> Self

Builder: the Markdown input rules to run while typing (D13). The default is InputRule::markdown_defaults; pass an empty list to type Markdown literally.

pub fn with_input_rule_filter( self, filter: impl Fn(InputRule, &str) -> bool + Send + Sync + 'static, ) -> Self

Pure policy invoked before an enabled input rule rewrites typed content. Return false when a host workflow (e.g. completion) owns the same sigil. Receives leaf-native text before the caret, never serialized offsets; must not perform I/O or re-enter the editor. Defaults to allowing rules.

pub fn set_input_rules(&mut self, rules: impl IntoIterator<Item = InputRule>)

Replace the input rules (see Self::with_input_rules).

pub fn set_task_checked( &mut self, block: BlockId, checked: bool, cx: &mut Context<'_, Self>, )

Check or uncheck the task item holding block (a list item or its text leaf); one undo step (D14). The selection is kept.

pub fn with_source(self, source: &str) -> Self

Builder: initial Markdown.

pub fn set_source( &mut self, source: &str, cx: &mut Context<'_, Self>, ) -> Result<(), SharedString>

Replace the content. No Changed event; clears history.

pub fn source(&self) -> String

The document as canonical Markdown.

pub fn source_snapshot(&self) -> SourceSnapshot

Shared canonical source, materialized at most once per revision.

pub fn capture_caret(&self) -> Result<CapturedRange, CapturedRangeError>

pub fn capture_selection(&self) -> Result<CapturedRange, CapturedRangeError>

pub fn capture_suffix( &self, len: usize, ) -> Result<CapturedRange, CapturedRangeError>

pub fn capture_leaf_range( &self, range: Range<usize>, ) -> Result<CapturedRange, CapturedRangeError>

pub fn with_image_policy(self, policy: ImagePolicy) -> Self

Configure presentation/resource admission without mutating the document.

pub fn set_image_policy( &mut self, policy: ImagePolicy, cx: &mut Context<'_, Self>, )

pub fn image_policy(&self) -> ImagePolicy

pub fn caret_prefix_snapshot(&self) -> Option<SharedString>

pub fn caret_prefix(&self) -> Option<&str>

pub fn is_capture_current(&self, range: &CapturedRange) -> bool

pub fn replace_captured( &mut self, range: &mut CapturedRange, text: &str, cx: &mut Context<'_, Self>, ) -> Result<(), CapturedRangeError>

pub fn select_end( &mut self, cx: &mut Context<'_, Self>, ) -> Result<(), SelectionError>

pub fn reveal_caret(&mut self, cx: &mut Context<'_, Self>)

Reveal the current caret after viewport/layout changes without moving it.

pub fn invalidate_captures(&mut self)

Fence host callbacks on external owner changes without reparsing content.

pub fn is_composing(&self) -> bool

pub fn model(&self) -> &BlockEditorModel

The headless model (document, selection, history).

pub fn revision(&self) -> u64

Document revision; bumped by every committed transaction.

pub fn selection(&self) -> &BlockSelection

The current selection.

pub fn block_kind_at_caret(&self) -> Option<BlockKind>

Kind of the text block holding the caret, if any.

pub fn set_editor_style( &mut self, style: BlockEditorStyle, cx: &mut Context<'_, Self>, )

Override caret, selection and composition colours (BlockEditorStyle).

pub fn editor_style(&self) -> &BlockEditorStyle

The editor style overrides in effect.

pub fn set_scroll_handle(&mut self, handle: ScrollHandle)

The scroll container the editor sits in (its track_scroll handle). With one set, the caret is scrolled into view after it moves; blocks outside the container’s visible area are culled either way.

pub fn is_readonly(&self) -> bool

Whether edits are blocked (navigation and selection still work).

pub fn set_readonly(&mut self, readonly: bool, cx: &mut Context<'_, Self>)

Block or allow edits.

pub fn focus(&self, window: &mut Window, cx: &mut App)

Focus the editor.

pub fn set_selection( &mut self, selection: BlockSelection, cx: &mut Context<'_, Self>, ) -> Result<(), SelectionError>

Set the selection; emits SelectionChanged.

pub fn run( &mut self, command: EditorCommand, cx: &mut Context<'_, Self>, ) -> Result<bool, CommandError>

Run a model command as one transaction.

pub fn undo(&mut self, cx: &mut Context<'_, Self>)

Undo the last transaction (or IME composition) group.

pub fn redo(&mut self, cx: &mut Context<'_, Self>)

Redo the last undone group.

pub fn link_at( &self, at: Point<Pixels>, ) -> Option<(BlockId, Range<usize>, SharedString)>

The link drawn under the window point at: its leaf, byte range and url.

pub fn hovered_link(&self) -> Option<&SharedString>

The url of the link under the mouse, if any (D14 hover).

pub fn link_at_caret(&self) -> Option<SharedString>

The url of the link at the caret (or the selection start).

pub fn request_link_edit(&mut self, cx: &mut Context<'_, Self>)

Cmd/Ctrl+K: ask the host for its link popover.

pub fn set_link(&mut self, url: Option<&str>, cx: &mut Context<'_, Self>)

Add, change (Some(url)) or remove (None) the link on the selection, or on the whole link at a collapsed caret. One undo step.

pub fn table_delete_edit(&self) -> Option<TableEdit>

What Cmd/Ctrl+Alt+Backspace does here (None: nothing).

pub fn paste( &mut self, item: ClipboardItem, plain: bool, cx: &mut Context<'_, Self>, )

Deliver semantic clipboard content. plain bypasses Markdown import. With Host policy this emits one request; there is no fallback insertion until the owner resolves it, so mixed image/text entries cannot double insert. This method itself never reads the system clipboard.

pub fn is_paste_current(&self, request: &PasteRequest) -> bool

Resolve an intercepted paste with text not consumed by the host’s other admissions (e.g. image attachments). None means wholly handled or rejected. Returns false when navigation/edits made the request stale.

pub fn apply_paste( &mut self, request: &PasteRequest, text: Option<&str>, cx: &mut Context<'_, Self>, ) -> bool

impl BlockEditorState

pub fn table_grips_at( &self, at: Point<Pixels>, ) -> Vec<(BlockId, TableLine, Bounds<Pixels>)>

The grips to show for the pointer at at: the hovered column’s grip above its header cell and the hovered row’s grip at its left edge. Column and row boxes come from the frame’s rebuilt table grid (FrameLayout::layout_tables), so they match the drawn cells for every alignment, after scrolling and resizing.

pub fn open_table_menu( &mut self, table: BlockId, line: TableLine, grip: Bounds<Pixels>, cx: &mut Context<'_, Self>, )

Select line of table and open its menu below / beside grip.

pub fn open_table_menu_for( &mut self, table: BlockId, line: TableLine, cx: &mut Context<'_, Self>, )

Open the menu of line of table (the grip position from the last frame). For tests and hosts that drive the menu themselves.

pub fn table_menu_anchor(&self) -> Option<Point<Pixels>>

Where the open menu hangs from (window coordinates).

pub fn table_menu_open(&self) -> bool

pub fn table_menu_action(&mut self, edit: TableEdit, cx: &mut Context<'_, Self>)

Run a menu entry on the menu’s row / column (one undo step) and close the menu, except for alignment, which keeps it open to show the change.

Trait Implementations

impl EntityInputHandler for BlockEditorState

fn text_for_range( &mut self, range16: Range<usize>, adjusted: &mut Option<Range<usize>>, _: &mut Window, _: &mut Context<'_, Self>, ) -> Option<String>

See InputHandler::text_for_range for details

fn selected_text_range( &mut self, _: bool, _: &mut Window, _: &mut Context<'_, Self>, ) -> Option<UTF16Selection>

See InputHandler::selected_text_range for details

fn marked_text_range( &self, _: &mut Window, _: &mut Context<'_, Self>, ) -> Option<Range<usize>>

See InputHandler::marked_text_range for details

fn unmark_text(&mut self, _: &mut Window, _: &mut Context<'_, Self>)

See InputHandler::unmark_text for details

fn paste( &mut self, item: ClipboardItem, _: &mut Window, cx: &mut Context<'_, Self>, )

See InputHandler::paste for details

fn replace_text_in_range( &mut self, range16: Option<Range<usize>>, text: &str, _: &mut Window, cx: &mut Context<'_, Self>, )

See InputHandler::replace_text_in_range for details

fn replace_and_mark_text_in_range( &mut self, range16: Option<Range<usize>>, new_text: &str, new_selected16: Option<Range<usize>>, _: &mut Window, cx: &mut Context<'_, Self>, )

See InputHandler::replace_and_mark_text_in_range for details

fn bounds_for_range( &mut self, range16: Range<usize>, _: Bounds<Pixels>, _: &mut Window, _: &mut Context<'_, Self>, ) -> Option<Bounds<Pixels>>

See InputHandler::bounds_for_range for details

fn character_index_for_point( &mut self, at: Point<Pixels>, _: &mut Window, _: &mut Context<'_, Self>, ) -> Option<usize>

See InputHandler::character_index_for_point for details

fn set_selected_text_range( &mut self, _range_utf16: Range<usize>, _window: &mut Window, _cx: &mut Context<'_, Self>, )

See InputHandler::set_selected_text_range for details

fn text_length_utf16( &mut self, _window: &mut Window, _cx: &mut Context<'_, Self>, ) -> Option<usize>

See InputHandler::text_length_utf16 for details

fn accepts_text_input( &self, _window: &mut Window, _cx: &mut Context<'_, Self>, ) -> bool

See InputHandler::accepts_text_input for details

fn text_input_configuration( &mut self, _window: &mut Window, _cx: &mut Context<'_, Self>, ) -> TextInputConfiguration

See InputHandler::text_input_configuration for details

fn text_input_editable_range( &mut self, _window: &mut Window, _cx: &mut Context<'_, Self>, ) -> Option<Range<usize>>

See InputHandler::text_input_editable_range for details

impl EventEmitter<BlockEditorEvent> for BlockEditorState

impl Focusable for BlockEditorState

fn focus_handle(&self, _: &App) -> FocusHandle

Returns the focus handle associated with this view.