Package com.vaadin.flow.component.select

Class Select<T>

    • Method Detail

      • setRenderer

        public void setRenderer​(ComponentRenderer<? extends Component,​T> renderer)
        Sets the item renderer for this select group. The renderer is applied to each item to create a component which represents the item option in the select's drop down.

        Default is null which means that the item's Object.toString() method is used and set as the text content of the vaadin item element.

        Parameters:
        renderer - the item renderer, or null to clear

      • setTextRenderer

        public void setTextRenderer​(ItemLabelGenerator<T> itemLabelGenerator)
        Convenience setter for creating a TextRenderer from the given function that converts the item to a string.

        NOTE: even though this accepts an ItemLabelGenerator, this is not the same as setItemLabelGenerator(ItemLabelGenerator) which does a different thing.

        Parameters:
        itemLabelGenerator - the function that creates the text content from the item, not null

      • setEmptySelectionAllowed

        public void setEmptySelectionAllowed​(boolean emptySelectionAllowed)
        Sets whether the user is allowed to select nothing. When set true a special empty item is shown to the user.

        Default is false. The empty selection item can be customized with setEmptySelectionCaption(String).

        Parameters:
        emptySelectionAllowed - true to allow not selecting anything, false to require selection
        See Also:
        setEmptySelectionCaption(String)

      • isEmptySelectionAllowed

        public boolean isEmptySelectionAllowed()
        Returns whether the user is allowed to select nothing.
        Returns:
        true if empty selection is allowed, false otherwise

      • setEmptySelectionCaption

        public void setEmptySelectionCaption​(String emptySelectionCaption)
        Sets the empty selection caption when setEmptySelectionAllowed(boolean) has been enabled. The caption is shown for the empty selection item in the drop down.

        When the empty selection item is selected, the select shows the value provided by setItemLabelGenerator(ItemLabelGenerator) for the null item, or the string set with setPlaceholder(String) or an empty string if not placeholder is set.

        Default is an empty string "", which will show the place holder when selected.

        Parameters:
        emptySelectionCaption - the empty selection caption to set, not null
        See Also:
        setEmptySelectionAllowed(boolean)

      • getEmptySelectionCaption

        public String getEmptySelectionCaption()

      • setItemEnabledProvider

        public void setItemEnabledProvider​(SerializablePredicate<T> itemEnabledProvider)
        Sets the item enabled predicate for this select. The predicate is applied to each item to determine whether the item should be enabled (true) or disabled (false). Disabled items are displayed as grayed out and the user cannot select them.

        By default is null and all the items are enabled.

        Parameters:
        itemEnabledProvider - the item enable predicate or null to clear

      • getItemLabelGenerator

        public ItemLabelGenerator<T> getItemLabelGenerator()
        Gets the item label generator. It generates the text that is shown in the input part for the item when it has been selected.

        Default is null.

        Returns:
        the item label generator, null if not set

      • setItemLabelGenerator

        public void setItemLabelGenerator​(ItemLabelGenerator<T> itemLabelGenerator)
        Sets the item label generator. It generates the text that is shown in the input part for the item when it has been selected.

        Default is null and the text content generated for the item with setRenderer(ComponentRenderer) is used instead.

        Parameters:
        itemLabelGenerator - the item label generator to set, or null to clear

      • getPlaceholder

        public String getPlaceholder()
        Gets the placeholder hint set for the user.
        Returns:
        the placeholder or null if none set

      • setPlaceholder

        public void setPlaceholder​(String placeholder)
        Sets the placeholder hint for the user.

        The placeholder will be displayed in the case that there is no item selected, or the selected item has an empty string label, or the selected item has no label and it's DOM content is empty.

        Default value is null.

        Overrides:
        setPlaceholder in class GeneratedVaadinSelect<Select<T>,​T>
        Parameters:
        placeholder - the placeholder to set, or null to remove

      • setLabel

        public void setLabel​(String label)
        Sets the string for the label element.

        NOTE: the label must be set for the required indicator to be visible.

        Specified by:
        setLabel in interface HasLabel
        Overrides:
        setLabel in class GeneratedVaadinSelect<Select<T>,​T>
        Parameters:
        label - string or null to clear it

      • getLabel

        public String getLabel()
        Gets the string for the label element.
        Specified by:
        getLabel in interface HasLabel
        Returns:
        the label string, or null if not set

      • setAutofocus

        public void setAutofocus​(boolean autofocus)
        Sets the select to have focus when the page loads.

        Default is false.

        Overrides:
        setAutofocus in class GeneratedVaadinSelect<Select<T>,​T>
        Parameters:
        autofocus - the autofocus to set

      • isAutofocus

        public boolean isAutofocus()
        Gets whether this select has been set to autofocus when the page loads.
        Returns:
        true if set to autofocus, false if not

      • getDataProvider

        public DataProvider<T,​?> getDataProvider()
        Gets the data provider.
        Returns:
        the data provider, not null

      • onEnabledStateChanged

        public void onEnabledStateChanged​(boolean enabled)
        Description copied from class: Component
        Handle component enable state when the enabled state changes.

        By default this sets or removes the 'disabled' attribute from the element. This can be overridden to have custom handling.

        Overrides:
        onEnabledStateChanged in class Component
        Parameters:
        enabled - the new enabled state of the component

      • setRequiredIndicatorVisible

        public void setRequiredIndicatorVisible​(boolean requiredIndicatorVisible)
        Sets the required indicator visible or not.

        If set visible, it is visually indicated in the user interface.

        The method is intended to be used with Binder which does server-side validation. In case HTML element has its own (client-side) validation it should be disabled when setRequiredIndicatorVisible(true) is called and re-enabled back on setRequiredIndicatorVisible(false). It's responsibility of each component implementation to follow the contract so that the method call doesn't do anything else than show/hide the "required" indication. Usually components provide their own setRequired method which should be called in case the client-side validation is required. NOTE: The required indicator will not be visible, if the setLabel(String) property is not set for the select.

        Specified by:
        setRequiredIndicatorVisible in interface HasValue<AbstractField.ComponentValueChangeEvent<Select<T>,​T>,​T>
        Specified by:
        setRequiredIndicatorVisible in interface HasValueAndElement<AbstractField.ComponentValueChangeEvent<Select<T>,​T>,​T>
        Parameters:
        requiredIndicatorVisible - true to make the required indicator visible, false if not

      • getErrorMessage

        public String getErrorMessage()
        Gets the error message to show to the user on invalid selection
        Specified by:
        getErrorMessage in interface HasValidation
        Returns:
        the error message or null if not set

      • isInvalid

        public boolean isInvalid()
        Gets whether the select is currently in invalid state.
        Specified by:
        isInvalid in interface HasValidation
        Returns:
        true for invalid, false for valid

      • add

        public void add​(Component... components)
        Adds the given components as children of this component.

        In case any of the specified components has already been added to another parent, it will be removed from there and added to this one.

        NOTE: If you add a component with the slot attribute set, it will be placed in the light-dom of the vaadin-select instead of the drop down, similar to addToPrefix(Component...)

        Specified by:
        add in interface HasComponents
        Parameters:
        components - the components to add

      • addComponents

        public void addComponents​(T afterItem,
                          Component... components)
        Description copied from interface: HasItemComponents
        Adds the components after the given item.
        Specified by:
        addComponents in interface HasItemComponents<T>
        Parameters:
        afterItem - item to add components after
        components - components to add after item

      • prependComponents

        public void prependComponents​(T beforeItem,
                              Component... components)
        Description copied from interface: HasItemComponents
        Adds the components before the given item.
        Specified by:
        prependComponents in interface HasItemComponents<T>
        Parameters:
        beforeItem - item to add components in front of
        components - components to add before item

      • addComponentAtIndex

        public void addComponentAtIndex​(int index,
                                Component component)
        Adds the given component as child of this component at the specific index.

        In case the specified component has already been added to another parent, it will be removed from there and added to this one.

        NOTE: If you add a component with the slot attribute set, it will be placed in the light-dom of the vaadin-select instead of the drop down, similar to addToPrefix(Component...)

        Specified by:
        addComponentAtIndex in interface HasComponents
        Parameters:
        index - the index, where the component will be added. The index must be non-negative and may not exceed the children count
        component - the component to add, value should not be null

      • addComponentAsFirst

        public void addComponentAsFirst​(Component component)
        Adds the given component as the first child of this component.

        In case the specified component has already been added to another parent, it will be removed from there and added to this one.

        NOTE: If you add a component with the slot attribute set, it will be placed in the light-dom of the vaadin-select instead of the drop down, similar to addToPrefix(Component...)

        Specified by:
        addComponentAsFirst in interface HasComponents
        Parameters:
        component - the component to add, value should not be null

      • getChildren

        public Stream<Component> getChildren()
        Description copied from class: Component
        Gets the child components of this component.

        The default implementation finds child components by traversing each child Element tree.

        If the component is injected to a PolymerTemplate using the @Id annotation the getChildren method will only return children added from the server side and will not return any children declared in the template file.

        Overrides:
        getChildren in class Component
        Returns:
        the child components of this component
        See Also:
        Id

      • remove

        public void remove​(Component... components)
        Removes the given child components from this component.

        NOTE: any component with the slot attribute will be attempted to removed from the light dom of the vaadin-select, instead of inside the options drop down.

        Specified by:
        remove in interface HasComponents
        Overrides:
        remove in class GeneratedVaadinSelect<Select<T>,​T>
        Parameters:
        components - the components to remove
        Throws:
        IllegalArgumentException - if any of the components is not a child of this component

      • addThemeVariants

        public void addThemeVariants​(SelectVariant... variants)
        Adds theme variants to the component.
        Parameters:
        variants - theme variants to add

      • removeThemeVariants

        public void removeThemeVariants​(SelectVariant... variants)
        Removes theme variants from the component.
        Parameters:
        variants - theme variants to remove

      • hasValidValue

        protected boolean hasValidValue()
        Description copied from class: AbstractSinglePropertyField
        Checks whether the element property has a value that can be converted to the model type. Property changes from the element will be ignored if this method returns false. The default implementation always return true.
        Overrides:
        hasValidValue in class AbstractSinglePropertyField<Select<T>,​T>
        Returns:
        true if the element property value can be converted to the model type; otherwise false

      • onAttach

        protected void onAttach​(AttachEvent attachEvent)
        Description copied from class: Component
        Called when the component is attached to a UI.

        The default implementation does nothing.

        This method is invoked before the AttachEvent is fired for the component.

        Overrides:
        onAttach in class Component
        Parameters:
        attachEvent - the attach event