Struct EditorPane 

pub struct EditorPane { /* private fields */ }

Editor shell with replaceable editable content, status chrome, and an attachment preview band.

Implementations

impl EditorPane

pub fn new() -> Self

Creates an editor shell with a default EditInput.

Examples found in repository

examples/chat/demo.rs (line 765)

	pub fn new(ctx: &UiContext) -> Self {
		let editor = Rc::new(RefCell::new({
			let mut editor = Editor::new(EditorOptions::default());
			editor.set_completion(Box::new(SlashCommands::new(demo_commands())));
			editor
		}));
		let edit_outcome = Rc::new(RefCell::new(None));
		let work = Rc::new(RefCell::new(WorkState {
			working: true,
			since:   Duration::ZERO,
			fade:    Tween::settled(GREEN),
		}));
		let model = Rc::new(RefCell::new(Str::new_static("Fable 5++")));
		let pane = EditorPane::new()
			.input(DemoInput::new(Rc::clone(&editor), Rc::clone(&edit_outcome)))
			.status(DemoStatus::new(Rc::clone(&work), Rc::clone(&model), ctx.charset));
		let attachments = pane.attachments();
		let editor_ui = Ui::from_root(pane, 0, ctx.clone());
		Self {
			started_at: Instant::now(),
			ctx: ctx.clone(),
			cancel_hint: ctx.charset.icon(Icon::Cancellable),
			editor_ui,
			editor,
			edit_outcome,
			work,
			last_working: true,
			model,
			attachments,
			transcript: vec![Entry::Command],
			drawn_entries: 0,
			transcript_rows: 0,
			appended_messages: 0,
			emitted_shards: 0,
			last_viewport: Size::new(0, 0),
			height_floor: 0,
			frame: Frame::new(Size::new(0, 0)),
			live_panel: None,
			live_rows: std::array::from_fn(|_| LiveRowCache::new()),
			live_label_scratch: StrMut::with_capacity(40),
			right_inset: 0,
			switch_requested: false,
		}
	}

pub fn input(self, input: impl IntoComponent) -> Self

Replaces the editable leaf.

Examples found in repository

examples/chat/demo.rs (line 766)

	pub fn new(ctx: &UiContext) -> Self {
		let editor = Rc::new(RefCell::new({
			let mut editor = Editor::new(EditorOptions::default());
			editor.set_completion(Box::new(SlashCommands::new(demo_commands())));
			editor
		}));
		let edit_outcome = Rc::new(RefCell::new(None));
		let work = Rc::new(RefCell::new(WorkState {
			working: true,
			since:   Duration::ZERO,
			fade:    Tween::settled(GREEN),
		}));
		let model = Rc::new(RefCell::new(Str::new_static("Fable 5++")));
		let pane = EditorPane::new()
			.input(DemoInput::new(Rc::clone(&editor), Rc::clone(&edit_outcome)))
			.status(DemoStatus::new(Rc::clone(&work), Rc::clone(&model), ctx.charset));
		let attachments = pane.attachments();
		let editor_ui = Ui::from_root(pane, 0, ctx.clone());
		Self {
			started_at: Instant::now(),
			ctx: ctx.clone(),
			cancel_hint: ctx.charset.icon(Icon::Cancellable),
			editor_ui,
			editor,
			edit_outcome,
			work,
			last_working: true,
			model,
			attachments,
			transcript: vec![Entry::Command],
			drawn_entries: 0,
			transcript_rows: 0,
			appended_messages: 0,
			emitted_shards: 0,
			last_viewport: Size::new(0, 0),
			height_floor: 0,
			frame: Frame::new(Size::new(0, 0)),
			live_panel: None,
			live_rows: std::array::from_fn(|_| LiveRowCache::new()),
			live_label_scratch: StrMut::with_capacity(40),
			right_inset: 0,
			switch_requested: false,
		}
	}

pub fn status(self, status: impl IntoComponent) -> Self

Adds or replaces the status band above the editable content.

Examples found in repository

examples/chat/demo.rs (line 767)

	pub fn new(ctx: &UiContext) -> Self {
		let editor = Rc::new(RefCell::new({
			let mut editor = Editor::new(EditorOptions::default());
			editor.set_completion(Box::new(SlashCommands::new(demo_commands())));
			editor
		}));
		let edit_outcome = Rc::new(RefCell::new(None));
		let work = Rc::new(RefCell::new(WorkState {
			working: true,
			since:   Duration::ZERO,
			fade:    Tween::settled(GREEN),
		}));
		let model = Rc::new(RefCell::new(Str::new_static("Fable 5++")));
		let pane = EditorPane::new()
			.input(DemoInput::new(Rc::clone(&editor), Rc::clone(&edit_outcome)))
			.status(DemoStatus::new(Rc::clone(&work), Rc::clone(&model), ctx.charset));
		let attachments = pane.attachments();
		let editor_ui = Ui::from_root(pane, 0, ctx.clone());
		Self {
			started_at: Instant::now(),
			ctx: ctx.clone(),
			cancel_hint: ctx.charset.icon(Icon::Cancellable),
			editor_ui,
			editor,
			edit_outcome,
			work,
			last_working: true,
			model,
			attachments,
			transcript: vec![Entry::Command],
			drawn_entries: 0,
			transcript_rows: 0,
			appended_messages: 0,
			emitted_shards: 0,
			last_viewport: Size::new(0, 0),
			height_floor: 0,
			frame: Frame::new(Size::new(0, 0)),
			live_panel: None,
			live_rows: std::array::from_fn(|_| LiveRowCache::new()),
			live_label_scratch: StrMut::with_capacity(40),
			right_inset: 0,
			switch_requested: false,
		}
	}

pub fn attachments(&self) -> Attachments

Shared handle to this composer’s staged attachments.

Examples found in repository

examples/chat/demo.rs (line 768)

	pub fn new(ctx: &UiContext) -> Self {
		let editor = Rc::new(RefCell::new({
			let mut editor = Editor::new(EditorOptions::default());
			editor.set_completion(Box::new(SlashCommands::new(demo_commands())));
			editor
		}));
		let edit_outcome = Rc::new(RefCell::new(None));
		let work = Rc::new(RefCell::new(WorkState {
			working: true,
			since:   Duration::ZERO,
			fade:    Tween::settled(GREEN),
		}));
		let model = Rc::new(RefCell::new(Str::new_static("Fable 5++")));
		let pane = EditorPane::new()
			.input(DemoInput::new(Rc::clone(&editor), Rc::clone(&edit_outcome)))
			.status(DemoStatus::new(Rc::clone(&work), Rc::clone(&model), ctx.charset));
		let attachments = pane.attachments();
		let editor_ui = Ui::from_root(pane, 0, ctx.clone());
		Self {
			started_at: Instant::now(),
			ctx: ctx.clone(),
			cancel_hint: ctx.charset.icon(Icon::Cancellable),
			editor_ui,
			editor,
			edit_outcome,
			work,
			last_working: true,
			model,
			attachments,
			transcript: vec![Entry::Command],
			drawn_entries: 0,
			transcript_rows: 0,
			appended_messages: 0,
			emitted_shards: 0,
			last_viewport: Size::new(0, 0),
			height_floor: 0,
			frame: Frame::new(Size::new(0, 0)),
			live_panel: None,
			live_rows: std::array::from_fn(|_| LiveRowCache::new()),
			live_label_scratch: StrMut::with_capacity(40),
			right_inset: 0,
			switch_requested: false,
		}
	}

pub fn with(self, prop: Prop, value: impl Into<PropValue>) -> Self

Sets one editor-shell property.

pub fn with_str(self, prop: Prop, value: &str) -> Self

Sets one editor-shell property from a string.

Trait Implementations

impl Component for EditorPane

fn props(&self) -> &Props

Component properties.

fn props_mut(&mut self) -> &mut Props

Mutable component properties.

fn slot(&self) -> Slot

Stable identity.

fn children(&self) -> &[Cached]

Every owned child, including embedded inactive subtrees.

fn children_mut(&mut self) -> &mut [Cached]

Every owned child, including embedded inactive subtrees.

fn ring(&self, out: &mut Vec<Slot>)

Appends focusable slots in document order.

fn measure(&mut self, ctx: &UiContext) -> (u16, u16)

Content width bounds, exclusive of this component’s chrome.

fn height(&mut self, ctx: &UiContext, width: u16) -> u16

Content height at the supplied content width.

fn place(&mut self, ctx: &UiContext, rect: Rect)

Places children inside the supplied content rectangle.

fn paint(&mut self, pc: &mut PaintCtx<'_>, rect: Rect)

Paints content inside the supplied content rectangle.

fn value(&self, out: &mut Map<String, Value>)

Adds this component’s named value to an output object.

fn set_text(&mut self, ctx: &UiContext, text: Str) -> bool

Replaces text content where supported.

fn kind(&self) -> &'static str

Concrete implementation name for debug tooling; defaults to the type’s full path via std::any::type_name. The OMP_TUI_DEBUG tree dump trims it to the trailing path segment.

fn paints_border(&self) -> bool

Whether Cached should paint this component’s border property as chrome.

fn paints_background(&self) -> bool

Whether Cached should paint this component’s background property across its rectangle. Components that own a partial background fill opt out and paint it themselves.

fn gradient_bounds(&self, content: Rect) -> Option<Rect>

A narrowed projection frame for two-stop fg=/bg= ramps, given the painted content rectangle. None projects across the full chrome; content-sized leaves (crate::components::Pre) return their authored extent so the ramp completes across the glyphs instead of the stretched layout width.

fn resize_tail(&mut self) -> Option<ResizeTail<'_>>

Opt-in viewport-tail provider for resize drags: children a drag frame may compose bottom-up, with the vertical gap between them. None — the default — renders this component whole.

fn validation_error(&self) -> Option<String>

A validation error blocking submission — an unmet required or match= constraint owned by this component’s internal records; None when valid. Component-level props are checked by the caller.

fn stretch_in_row(&self) -> bool

Whether a row should stretch this component across its cross axis.

fn focusable(&self) -> bool

Whether this component contributes its own slot to the focus ring. The default honors the focus flag, so any container can opt into keyboard navigation from markup.

fn enter(&mut self, forward: bool)

Positions internal selection when focus enters from either direction.

fn key(&mut self, ec: &mut EventCtx<'_>, key: Key) -> Flow

Handles a keyboard event.

fn mouse( &mut self, ec: &mut EventCtx<'_>, tag: HitTag, at: (u16, u16), rect: Rect, mouse: Mouse, ) -> Flow

Handles a mouse gesture over one of this component’s hit regions.

fn paste(&mut self, ec: &mut EventCtx<'_>, text: &str) -> Flow

Pastes text into this component: Flow::Consumed repaints, Flow::Event additionally surfaces a crate::UiEvent, and Flow::Skip leaves the paste unhandled.

fn paste_raw(&mut self, ec: &mut EventCtx<'_>, text: &str) -> Flow

Pastes text verbatim, bypassing any smart-paste interpretation the component applies in Component::paste (drop classification, large-paste collapse). Defaults to Component::paste for components without such interpretation.

impl Default for EditorPane

fn default() -> Self

Returns the “default value” for a type.