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_mono(self) -> Self

Use the current theme’s monospace family for text and placeholder.

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 — cx.typography().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. Clears the undo history.

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. Each edit it applies moves the spans through Edit::map, so until the caller hands over fresh ones — FieldEvent::Changed carries the edit to reparse from — they stay on the characters they were computed for.

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

pub fn set_matches( &mut self, matches: Vec<Range<usize>>, cx: &mut Context<'_, Self>, )

Wash these byte ranges behind the text, as search matches. Not kept in step with edits, and cleared by Self::set_content, the same as Self::set_spans. A range past the end or off a char boundary is not painted.

pub fn set_chips(&mut self, chips: Vec<Chip>, cx: &mut Context<'_, Self>)

Paint these ranges of the content as chips — see Chip.

The content keeps the source text; only painting and editing change. The caret steps over a chip, a selection that cuts one takes all of it, and one delete removes it. Each edit moves the chips with the text, and an edit reaching inside one drops it. Undo and redo bring back the chips each step had.

A caret inside a chip moves to its end. Self::set_content clears them.

pub fn chips(&self) -> &[Chip]

The chips this field is painting — see Self::set_chips.

pub fn select(&mut self, range: Range<usize>, cx: &mut Context<'_, Self>)

Select range and scroll it into view, with the caret at its end. Clamped to the content and to char boundaries, and grown over any chip it cuts.

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.