Struct TextField 

pub struct TextField { /* private fields */ }

A text field. Shape decides whether it is one line or many; everything else about it is the same either way.

Implementations

impl TextField

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

pub fn with_undo_limit(self, limit: usize) -> Self

How many undo steps to keep. App-wide configuration would be a gpui global alongside crate::input::init, not a Theme field — the theme is rebuilt on every light/dark switch, which would quietly reset anything behavioural parked in it.

pub fn with_placeholder(self, placeholder: impl Into<SharedString>) -> Self

pub fn with_key_context(self, context: impl Into<SharedString>) -> Self

Claim an extra key context on this field, so an app can bind a key here that it does not want bound in every other field.

The composer case, and the reason this exists: enter sends a message and shift-enter breaks a line, while the notes field two panels over still takes enter as a newline. gpui resolves a keystroke to the binding whose context matches deepest in the focus path, and nothing is deeper than the focused field — so a container around it cannot win enter, however it is bound. Rebinding MULTILINE_KEY_CONTEXT globally would win, and would take the newline away from every other multi-line field in the app. A context of the field’s own is the only thing that is both deep enough and narrow enough.

const COMPOSER: &str = "Composer";
cx.bind_keys([
    KeyBinding::new("enter", Send, Some(COMPOSER)),
    KeyBinding::new("shift-enter", input::InsertNewline, Some(COMPOSER)),
]);
let field = cx.new(|cx| {
    TextField::new(cx)
        .with_shape(Shape::Grow { min: 3, max: 12 })
        .with_key_context(COMPOSER)
});

pub fn with_frame(self, frame: bool) -> Self

Draw without the box, padding and focus ring. The caller owns the spacing then, and owns showing that the field is focused.

pub fn with_metrics(self, metrics: Metrics) -> Self

Set the text in something other than body copy — Typography::of(cx).h1 sets a field the way a document sets its own heading.

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

Update typography without replacing the editing state.

pub fn with_shape(self, shape: Shape) -> Self

pub fn with_case(self, case: Case) -> Self

pub fn set_case(&mut self, case: Case)

The case from here on. What the field already holds is left as it is: the text came from somewhere else, and a caller switching the case of a shared field would otherwise rewrite the name it is showing.

pub fn case(&self) -> Case

pub fn shape(&self) -> Shape

pub fn content(&self) -> &SharedString

pub fn spans(&self) -> &[(Range<usize>, HighlightKind)]

The syntax spans this field is painting — see Self::set_spans.

pub fn set_content( &mut self, content: impl Into<SharedString>, cx: &mut Context<'_, Self>, )

Replace the content, putting the cursor at the end.

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

pub fn set_spans( &mut self, spans: Vec<(Range<usize>, HighlightKind)>, cx: &mut Context<'_, Self>, )

Paint these byte ranges in syntax colours, in document order. Whatever they leave uncovered stays the field’s own text colour, so a language nothing can colour is simply no spans at all.

This field holds text, not a document: it does not parse, and it does not keep the spans in step with edits. The caller recomputes them — FieldEvent::Changed is the signal — and until it does, the frames in between paint the ranges it last handed over. Stale ones are dropped rather than shifted, so the worst a late recolour looks like is a word in the wrong colour for a frame.

set_content clears them: replacing the text replaces what the colours were about.

pub fn set_placeholder( &mut self, placeholder: impl Into<SharedString>, cx: &mut Context<'_, Self>, )

Self::with_placeholder after construction, for a hint that follows something else — the field naming whichever agent, file or channel is selected rather than being rebuilt each time one is.

pub fn cursor(&self) -> usize

Where the caret is, as a byte offset into Self::content.

What a caller needs to read the text behind the caret: the # an autocomplete triggers on, the word a lookup would act on. With a selection this is the moving end, which is where typing would land.

pub fn offset_bounds(&self, offset: usize) -> Option<Bounds<Pixels>>

Where a byte offset sits on screen — the bounds of the row it is on, in window coordinates.

The anchor for anything that hangs off a position in the text rather than off the field: a mention picker under the # that opened it, in a box that is also growing a row at a time. Pass it to crate::popover::menu_at, which takes a window point.

None until the field has painted once — this is measured off the shaped layout, and there is none before then.

Trait Implementations

impl EntityInputHandler for TextField

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

See InputHandler::text_for_range for details

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

See InputHandler::selected_text_range for details

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

See InputHandler::marked_text_range for details

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

See InputHandler::unmark_text for details

fn replace_text_in_range( &mut self, range_utf16: Option<Range<usize>>, new_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, range_utf16: Option<Range<usize>>, new_text: &str, new_selected_range_utf16: Option<Range<usize>>, _window: &mut Window, cx: &mut Context<'_, Self>, )

See InputHandler::replace_and_mark_text_in_range for details

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

See InputHandler::bounds_for_range for details

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

See InputHandler::character_index_for_point for details

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

See InputHandler::paste 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<FieldEvent> for TextField

impl Focusable for TextField

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

Returns the focus handle associated with this view.

impl Render for TextField

fn render( &mut self, _window: &mut Window, cx: &mut Context<'_, Self>, ) -> impl IntoElement

Render this view into an element tree.