Struct titanium::desktop::gui::libdruid::widget::TextBox

pub struct TextBox<T> {
    pub handles_tab_notifications: bool,
    /* private fields */
}

A widget that allows user text input.

Editing values

If the text you are editing represents a value of some other type, such as a number, you should use a ValueTextBox and an appropriate Formatter. You can create a ValueTextBox by passing the appropriate Formatter to TextBox::with_formatter.

Fields

handles_tab_notifications: bool

if true (the default), this textbox will attempt to change focus on tab.

You can override this in a controller if you want to customize tab behaviour.

Implementations

impl<T> TextBox<T>where T: EditableText + TextStorage,

pub fn new() -> TextBox<T>

Create a new TextBox widget.

Examples

use druid::widget::TextBox;
use druid::{ WidgetExt, Data, Lens };

#[derive(Clone, Data, Lens)]
struct AppState {
    name: String,
}

let _ = TextBox::new()
    .with_placeholder("placeholder text")
    .lens(AppState::name);

pub fn multiline() -> TextBox<T>

Create a new multi-line TextBox.

Examples

let multiline = TextBox::multiline()
    .lens(AppState::name);

pub fn with_line_wrapping(self, wrap_lines: bool) -> TextBox<T>

If true (and this is a multiline text box) lines will be wrapped at the maximum layout width.

If false, lines will not be wrapped, and horizontal scrolling will be enabled.

Examples

//will scroll horizontally
let scroll_text_box = TextBox::new()
    .with_line_wrapping(false)
    .lens(AppState::name);

//will wrap only for a single line
let wrap_text_box = TextBox::new()
    .with_line_wrapping(true)
    .lens(AppState::name);

//will scroll as well as having multiple lines
let scroll_multi_line_text_box = TextBox::multiline()
    .with_line_wrapping(false)
    .lens(AppState::name);

//will wrap for each line
let wrap_multi_line_text_box = TextBox::multiline()
    .with_line_wrapping(true) // this is default and can be removed for the same result
    .lens(AppState::name);

impl<T> TextBox<T>

pub fn with_text_size(self, size: impl Into<KeyOrValue<f64>>) -> TextBox<T>

Builder-style method for setting the text size.

The argument can be either an f64 or a Key<f64>.

Examples

let text_box = TextBox::new()
    .with_text_size(14.)
    .lens(AppState::name);

use druid::Key;

const FONT_SIZE : Key<f64> = Key::new("font-size");

let text_box = TextBox::new()
    .with_text_size(FONT_SIZE)
    .lens(AppState::name);

pub fn with_text_alignment(self, alignment: TextAlignment) -> TextBox<T>

Builder-style method to set the TextAlignment.

This is only relevant when the TextBox is not multiline, in which case it determines how the text is positioned inside the TextBox when it does not fill the available space.

Note:

This does not behave exactly like TextAlignment does when used with label; in particular this does not account for reading direction. This means that TextAlignment::Start (the default) always means left aligned, and TextAlignment::End always means right aligned.

This should be considered a bug, but it will not be fixed until proper BiDi support is implemented.

Examples

use druid::TextAlignment;

let text_box = TextBox::new()
    .with_text_alignment(TextAlignment::Center)
    .lens(AppState::name);

pub fn with_font(self, font: impl Into<KeyOrValue<FontDescriptor>>) -> TextBox<T>

Builder-style method for setting the font.

The argument can be a FontDescriptor or a Key<FontDescriptor> that refers to a font defined in the Env.

Examples

use druid::{ FontDescriptor, FontFamily, Key };

const FONT : Key<FontDescriptor> = Key::new("font");

let text_box = TextBox::new()
    .with_font(FontDescriptor::new(FontFamily::MONOSPACE))
    .lens(AppState::name);

let text_box = TextBox::new()
    .with_font(FONT)
    .lens(AppState::name);

pub fn with_text_color(self, color: impl Into<KeyOrValue<Color>>) -> TextBox<T>

Builder-style method for setting the text color.

The argument can be either a Color or a Key<Color>.

Examples

use druid::{ Color, Key };

const COLOR : Key<Color> = Key::new("color");

let text_box = TextBox::new()
    .with_text_color(Color::RED)
    .lens(AppState::name);

let text_box = TextBox::new()
    .with_text_color(COLOR)
    .lens(AppState::name);

pub fn set_text_size(&mut self, size: impl Into<KeyOrValue<f64>>)

Set the text size.

The argument can be either an f64 or a Key<f64>.

pub fn set_font(&mut self, font: impl Into<KeyOrValue<FontDescriptor>>)

Set the font.

The argument can be a FontDescriptor or a Key<FontDescriptor> that refers to a font defined in the Env.

pub fn set_text_alignment(&mut self, alignment: TextAlignment)

Set the TextAlignment for this `TextBox``.

This is only relevant when the TextBox is not multiline, in which case it determines how the text is positioned inside the TextBox when it does not fill the available space.

Note:

This does not behave exactly like TextAlignment does when used with label; in particular this does not account for reading direction. This means that TextAlignment::Start (the default) always means left aligned, and TextAlignment::End always means right aligned.

This should be considered a bug, but it will not be fixed until proper BiDi support is implemented.

pub fn set_text_color(&mut self, color: impl Into<KeyOrValue<Color>>)

Set the text color.

The argument can be either a Color or a Key<Color>.

If you change this property, you are responsible for calling request_layout to ensure the label is updated.

pub fn text_position(&self) -> Point

The point, relative to the origin, where this text box draws its TextLayout.

This is exposed in case the user wants to do additional drawing based on properties of the text.

This is not valid until layout has been called.

impl<T> TextBox<T>where T: Data,

pub fn with_placeholder(self, placeholder: impl Into<LabelText<T>>) -> TextBox<T>

Builder-style method to set the TextBox’s placeholder text.

pub fn set_placeholder(&mut self, placeholder: impl Into<LabelText<T>>)

Set the TextBox’s placeholder text.

impl<T> TextBox<T>

pub fn text(&self) -> &TextComponent<T>

An immutable reference to the inner TextComponent.

Using this correctly is difficult; please see the TextComponent docs for more information.

pub fn text_mut(&mut self) -> &mut TextComponent<T>

A mutable reference to the inner TextComponent.

Using this correctly is difficult; please see the TextComponent docs for more information.

impl TextBox<String>

pub fn with_formatter<T>( self, formatter: impl Formatter<T> + 'static ) -> ValueTextBox<T>where T: Data,

Turn this TextBox into a ValueTextBox, using the Formatter to manage the value.

For simple value formatting, you can use the ParseFormatter.

Trait Implementations

impl<T> Default for TextBox<T>where T: TextStorage + EditableText,

fn default() -> TextBox<T>

Returns the “default value” for a type.

impl<T> Widget<T> for TextBox<T>where T: TextStorage + EditableText,

fn event( &mut self, ctx: &mut EventCtx<'_, '_>, event: &Event, data: &mut T, env: &Env )

Handle an event.

fn lifecycle( &mut self, ctx: &mut LifeCycleCtx<'_, '_>, event: &LifeCycle, data: &T, env: &Env )

Handle a life cycle notification.

fn update(&mut self, ctx: &mut UpdateCtx<'_, '_>, old: &T, data: &T, env: &Env)

Update the widget’s appearance in response to a change in the app’s Data or Env.

fn layout( &mut self, ctx: &mut LayoutCtx<'_, '_>, bc: &BoxConstraints, data: &T, env: &Env ) -> Size

Compute layout.

fn paint(&mut self, ctx: &mut PaintCtx<'_, '_, '_>, data: &T, env: &Env)

Paint the widget appearance.

fn compute_max_intrinsic( &mut self, axis: Axis, ctx: &mut LayoutCtx<'_, '_>, bc: &BoxConstraints, data: &T, env: &Env ) -> f64

Computes max intrinsic/preferred dimension of a widget on the provided axis.