Struct html::inline_text::builders::KeyboardInputBuilder

pub struct KeyboardInputBuilder { /* private fields */ }

A builder struct for KeyboardInput

Implementations

impl KeyboardInputBuilder

pub fn build(&mut self) -> KeyboardInput

Finish building the element

pub fn data( &mut self, data_key: impl Into<Cow<'static, str>>, value: impl Into<Cow<'static, str>> ) -> &mut KeyboardInputBuilder

Insert a data-* property

pub fn abbreviation<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut AbbreviationBuilder) -> &'a mut AbbreviationBuilder,

Append a new Abbreviation element

pub fn anchor<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut AnchorBuilder) -> &'a mut AnchorBuilder,

Append a new Anchor element

pub fn audio<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut AudioBuilder) -> &'a mut AudioBuilder,

Append a new Audio element

pub fn bidirectional_isolate<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut BidirectionalIsolateBuilder) -> &'a mut BidirectionalIsolateBuilder,

Append a new BidirectionalIsolate element

pub fn bidirectional_text_override<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut BidirectionalTextOverrideBuilder) -> &'a mut BidirectionalTextOverrideBuilder,

Append a new BidirectionalTextOverride element

pub fn bold<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut BoldBuilder) -> &'a mut BoldBuilder,

Append a new Bold element

pub fn button<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut ButtonBuilder) -> &'a mut ButtonBuilder,

Append a new Button element

pub fn canvas<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut CanvasBuilder) -> &'a mut CanvasBuilder,

Append a new Canvas element

pub fn cite<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut CiteBuilder) -> &'a mut CiteBuilder,

Append a new Cite element

pub fn code<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut CodeBuilder) -> &'a mut CodeBuilder,

Append a new Code element

pub fn data_el<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut DataBuilder) -> &'a mut DataBuilder,

Append a new Data element

pub fn data_list<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut DataListBuilder) -> &'a mut DataListBuilder,

Append a new DataList element

pub fn definition<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut DefinitionBuilder) -> &'a mut DefinitionBuilder,

Append a new Definition element

pub fn deleted_text<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut DeletedTextBuilder) -> &'a mut DeletedTextBuilder,

Append a new DeletedText element

pub fn embed<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut EmbedBuilder) -> &'a mut EmbedBuilder,

Append a new Embed element

pub fn emphasis<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut EmphasisBuilder) -> &'a mut EmphasisBuilder,

Append a new Emphasis element

pub fn iframe<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut IframeBuilder) -> &'a mut IframeBuilder,

Append a new Iframe element

pub fn image<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut ImageBuilder) -> &'a mut ImageBuilder,

Append a new Image element

pub fn image_map<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut ImageMapBuilder) -> &'a mut ImageMapBuilder,

Append a new ImageMap element

pub fn image_map_area<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut ImageMapAreaBuilder) -> &'a mut ImageMapAreaBuilder,

Append a new ImageMapArea element

pub fn input<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut InputBuilder) -> &'a mut InputBuilder,

Append a new Input element

pub fn inserted_text<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut InsertedTextBuilder) -> &'a mut InsertedTextBuilder,

Append a new InsertedText element

pub fn italic<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut ItalicBuilder) -> &'a mut ItalicBuilder,

Append a new Italic element

pub fn keyboard_input<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut KeyboardInputBuilder) -> &'a mut KeyboardInputBuilder,

Append a new KeyboardInput element

pub fn label<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut LabelBuilder) -> &'a mut LabelBuilder,

Append a new Label element

pub fn line_break<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut LineBreakBuilder) -> &'a mut LineBreakBuilder,

Append a new LineBreak element

pub fn line_break_opportunity<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut LineBreakOpportunityBuilder) -> &'a mut LineBreakOpportunityBuilder,

Append a new LineBreakOpportunity element

pub fn link<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut LinkBuilder) -> &'a mut LinkBuilder,

Append a new Link element

pub fn mark_text<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut MarkTextBuilder) -> &'a mut MarkTextBuilder,

Append a new MarkText element

pub fn meta<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut MetaBuilder) -> &'a mut MetaBuilder,

Append a new Meta element

pub fn meter<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut MeterBuilder) -> &'a mut MeterBuilder,

Append a new Meter element

pub fn no_script<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut NoScriptBuilder) -> &'a mut NoScriptBuilder,

Append a new NoScript element

pub fn object<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut ObjectBuilder) -> &'a mut ObjectBuilder,

Append a new Object element

pub fn output<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut OutputBuilder) -> &'a mut OutputBuilder,

Append a new Output element

pub fn picture<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut PictureBuilder) -> &'a mut PictureBuilder,

Append a new Picture element

pub fn progress<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut ProgressBuilder) -> &'a mut ProgressBuilder,

Append a new Progress element

pub fn quotation<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut QuotationBuilder) -> &'a mut QuotationBuilder,

Append a new Quotation element

pub fn ruby_annotation<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut RubyAnnotationBuilder) -> &'a mut RubyAnnotationBuilder,

Append a new RubyAnnotation element

pub fn sample_output<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut SampleOutputBuilder) -> &'a mut SampleOutputBuilder,

Append a new SampleOutput element

pub fn script<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut ScriptBuilder) -> &'a mut ScriptBuilder,

Append a new Script element

pub fn select<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut SelectBuilder) -> &'a mut SelectBuilder,

Append a new Select element

pub fn side_comment<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut SideCommentBuilder) -> &'a mut SideCommentBuilder,

Append a new SideComment element

pub fn slot<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut SlotBuilder) -> &'a mut SlotBuilder,

Append a new Slot element

pub fn span<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut SpanBuilder) -> &'a mut SpanBuilder,

Append a new Span element

pub fn strike_through<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut StrikeThroughBuilder) -> &'a mut StrikeThroughBuilder,

Append a new StrikeThrough element

pub fn strong<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut StrongBuilder) -> &'a mut StrongBuilder,

Append a new Strong element

pub fn sub_script<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut SubScriptBuilder) -> &'a mut SubScriptBuilder,

Append a new SubScript element

pub fn super_script<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut SuperScriptBuilder) -> &'a mut SuperScriptBuilder,

Append a new SuperScript element

pub fn template<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut TemplateBuilder) -> &'a mut TemplateBuilder,

Append a new Template element

pub fn text(&mut self, s: impl Into<Cow<'static, str>>) -> &mut Self

Append a new text element.

pub fn text_area<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut TextAreaBuilder) -> &'a mut TextAreaBuilder,

Append a new TextArea element

pub fn time<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut TimeBuilder) -> &'a mut TimeBuilder,

Append a new Time element

pub fn underline<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut UnderlineBuilder) -> &'a mut UnderlineBuilder,

Append a new Underline element

pub fn variable<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut VariableBuilder) -> &'a mut VariableBuilder,

Append a new Variable element

pub fn video<F>(&mut self, f: F) -> &mut Selfwhere F: for<'a> FnOnce(&'a mut VideoBuilder) -> &'a mut VideoBuilder,

Append a new Video element

pub fn access_key(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the accesskey attribute

pub fn auto_capitalize( &mut self, value: impl Into<Cow<'static, str>> ) -> &mut Self

Set the value of the autocapitalize attribute

pub fn autofocus(&mut self, value: bool) -> &mut Self

Set the value of the autofocus attribute

pub fn class(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the class attribute

pub fn content_editable( &mut self, value: impl Into<Cow<'static, str>> ) -> &mut Self

Set the value of the contenteditable attribute

pub fn direction(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the dir attribute

pub fn draggable(&mut self, value: bool) -> &mut Self

Set the value of the draggable attribute

pub fn enter_key_hint( &mut self, value: impl Into<Cow<'static, str>> ) -> &mut Self

Set the value of the enterkeyhint attribute

pub fn export_parts(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the exportparts attribute

pub fn hidden(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the hidden attribute

pub fn id(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the id attribute

pub fn inert(&mut self, value: bool) -> &mut Self

Set the value of the inert attribute

pub fn input_mode(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the inputmode attribute

pub fn is_(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the is attribute

pub fn item_id(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the itemid attribute

pub fn item_prop(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the itemprop attribute

pub fn item_ref(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the itemref attribute

pub fn item_scope(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the itemscope attribute

pub fn item_type(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the itemtype attribute

pub fn lang(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the lang attribute

pub fn nonce(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the nonce attribute

pub fn part(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the part attribute

pub fn slot_attr(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the slot attribute

pub fn spellcheck(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the spellcheck attribute

pub fn style(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the style attribute

pub fn tab_index(&mut self, value: i64) -> &mut Self

Set the value of the tabindex attribute

pub fn title(&mut self, value: impl Into<Cow<'static, str>>) -> &mut Self

Set the value of the title attribute

pub fn translate(&mut self, value: bool) -> &mut Self

Set the value of the translate attribute

pub fn push<T>(&mut self, child_el: T) -> &mut Selfwhere T: Into<KeyboardInputChild>,

Push a new child element to the list of children.

pub fn extend<I, T>(&mut self, iter: I) -> &mut Selfwhere I: IntoIterator<Item = T>, T: Into<KeyboardInputChild>,

Extend the list of children with an iterator of child elements.