Method Details

• isAutofocus

  public boolean isAutofocus()

  Whether the component should automatically receive focus when the page loads.

  Returns:

  true if the component should automatically receive focus

• setAutofocus

  public void setAutofocus(boolean autofocus)

  Sets the whether the component should automatically receive focus when the page loads. Defaults to false.

  Parameters:

  autofocus - true component should automatically receive focus

• getPageSize

  public int getPageSize()

  Gets the page size, which is the number of items fetched at a time from the data provider.

  The page size is also the largest number of items that can support client-side filtering. If you provide more items than the page size, the component has to fall back to server-side filtering.

  The default page size is 50.

  Returns:

  the maximum number of items sent per request

  See Also:

  • setPageSize(int)

• setPageSize

  public void setPageSize(int pageSize)

  Sets the page size, which is the number of items requested at a time from the data provider. This does not guarantee a maximum query size to the backend; when the overlay has room to render more new items than the page size, multiple "pages" will be requested at once.

  The page size is also the largest number of items that can support client-side filtering. If you provide more items than the page size, the component has to fall back to server-side filtering.

  Setting the page size after the ComboBox has been rendered effectively resets the component, and the current page(s) and sent over again.

  The default page size is 50.

  Parameters:

  pageSize - the maximum number of items sent per request, should be greater than zero

• isOpened

  @Synchronize(property="opened", value="opened-changed") public boolean isOpened()

  Whether the dropdown is opened or not.

  Returns:

  true if the drop-down is opened, false otherwise

• setOpened

  public void setOpened(boolean opened)

  Sets whether the dropdown should be opened or not.

  Parameters:

  opened - true to open the drop-down, false to close it

• isAllowCustomValue

  public boolean isAllowCustomValue()

  If true, the user can input string values that do not match to any existing item labels, which will fire a ComboBoxBase.CustomValueSetEvent.

  Returns:

  true if the component fires custom value set events, false otherwise

  See Also:

  • setAllowCustomValue(boolean)
  • addCustomValueSetListener(ComponentEventListener)

• setAllowCustomValue

  public void setAllowCustomValue(boolean allowCustomValue)

  Enables or disables the component firing events for custom string input.

  When enabled, a ComboBoxBase.CustomValueSetEvent will be fired when the user inputs a string value that does not match any existing items and commits it eg. by blurring or pressing the enter-key.

  Note that ComboBox doesn't do anything with the custom value string automatically. Use the addCustomValueSetListener(ComponentEventListener) method to determine how the custom value should be handled. For example, when the ComboBox has String as the value type, you can add a listener which sets the custom string as the value of the ComboBox with setValue(Object).

  Setting to true also allows an unfocused ComboBox to display a string that doesn't match any of its items nor its current value, unless this is explicitly handled with addCustomValueSetListener(ComponentEventListener). When set to false, an unfocused ComboBox will always display the label of the currently selected item.

  Parameters:

  allowCustomValue - true to enable custom value set events, false to disable them

  See Also:

  • addCustomValueSetListener(ComponentEventListener)

• getFilter

  @Synchronize(property="filter", value="filter-changed") protected String getFilter()

  Filtering string the user has typed into the input field.

  Returns:

  the filter string

• setFilter

  protected void setFilter(String filter)

  Sets the filter string for the filter input.

  Setter is only required to allow using @Synchronize

  Parameters:

  filter - the String value to set

• setRequiredIndicatorVisible

  public void setRequiredIndicatorVisible(boolean required)

  Sets whether the user is required to provide a value. When required, an indicator appears next to the label and the field invalidates if the value is cleared.

  NOTE: The required indicator is only visible when the field has a label, see HasLabel.setLabel(String).

  Specified by:

  setRequiredIndicatorVisible in interface HasValue<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TItem>

  Specified by:

  setRequiredIndicatorVisible in interface HasValueAndElement<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TItem>

  Parameters:

  required - true to make the field required, false otherwise

• isRequiredIndicatorVisible

  public boolean isRequiredIndicatorVisible()

  Gets whether the user is required to provide a value.

  Specified by:

  isRequiredIndicatorVisible in interface HasValue<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TItem>

  Specified by:

  isRequiredIndicatorVisible in interface HasValueAndElement<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TItem>

  Returns:

  true if the field is required, false otherwise

  See Also:

  • setRequiredIndicatorVisible(boolean)

• isRequired

  public boolean isRequired()

  Alias for isRequiredIndicatorVisible()

  Returns:

  true if the field is required, false otherwise

• setRequired

  public void setRequired(boolean required)

  Alias for setRequiredIndicatorVisible(boolean).

  Parameters:

  required - true to make the field required, false otherwise

• setAriaLabel

  public void setAriaLabel(String ariaLabel)

  Description copied from interface: HasAriaLabel

  Set the aria-label of the component to the given text.

  This method should not be used if HasAriaLabel.setAriaLabelledBy(String) is also used. If both attributes are present, aria-labelledby will take precedence over aria-label.

  Specified by:

  setAriaLabel in interface HasAriaLabel

  Parameters:

  ariaLabel - the aria-label text to set or null to clear

• getAriaLabel

  public Optional<String> getAriaLabel()

  Description copied from interface: HasAriaLabel

  Gets the aria-label of the component.

  Specified by:

  getAriaLabel in interface HasAriaLabel

  Returns:

  an optional aria-label of the component if no aria-label has been set

• setAriaLabelledBy

  public void setAriaLabelledBy(String labelledBy)

  Description copied from interface: HasAriaLabel

  Set the aria-labelledby of the component. The value must be a valid id attribute of another element that labels the component. The label element must be in the same DOM scope of the component, otherwise screen readers may fail to announce the label content properly.

  This method should not be used if HasAriaLabel.setAriaLabel(String) is also used. If both attributes are present, aria-labelledby will take precedence over aria-label.

  Specified by:

  setAriaLabelledBy in interface HasAriaLabel

  Parameters:

  labelledBy - the string with the id of the element that will be used as label or null to clear

• getAriaLabelledBy

  public Optional<String> getAriaLabelledBy()

  Description copied from interface: HasAriaLabel

  Gets the aria-labelledby of the component

  Specified by:

  getAriaLabelledBy in interface HasAriaLabel

  Returns:

  an optional aria-labelledby of the component if no aria-labelledby has been set

• setItemLabelGenerator

  public void setItemLabelGenerator(ItemLabelGenerator<TItem> itemLabelGenerator)

  Sets the item label generator that is used to produce the strings shown in the combo box for each item. By default, String.valueOf(Object) is used.

  When the setRenderer(Renderer) is used, the ItemLabelGenerator is only used to show the selected item label.

  Parameters:

  itemLabelGenerator - the item label provider to use, not null

• getItemLabelGenerator

  public ItemLabelGenerator<TItem> getItemLabelGenerator()

  Gets the item label generator that is used to produce the strings shown in the combo box for each item.

  Returns:

  the item label generator used, not null

• generateLabel

  protected String generateLabel(TItem item)

  Generates a string label for a data item using the current item label generator

  Parameters:

  item - the data item

  Returns:

  string label for the data item

• setClassNameGenerator

  public void setClassNameGenerator(SerializableFunction<TItem,String> classNameGenerator)

  Sets the function that is used for generating CSS class names for the dropdown items in the ComboBox. Returning null from the generator results in no custom class name being set. Multiple class names can be returned from the generator as space-separated.

  Parameters:

  classNameGenerator - the class name generator to set, not null

  Throws:

  NullPointerException - if classNameGenerator is null

  Since:

  24.5

• getItemClassNameGenerator

  public SerializableFunction<TItem,String> getItemClassNameGenerator()

  Gets the item class name generator that is used for generating CSS class names for the dropdown items in the ComboBox.

  Returns:

  the item class name generator, not null

  Since:

  24.5

• generateClassName

  protected String generateClassName(TItem item)

  Generates a string class name for a data item using the current item class name generator

  Parameters:

  item - the data item

  Returns:

  string class name for the data item

• setRenderer

  public void setRenderer(Renderer<TItem> renderer)

  Sets the Renderer responsible to render the individual items in the list of possible choices of the ComboBox. It doesn't affect how the selected item is rendered - that can be configured by using setItemLabelGenerator(ItemLabelGenerator).

  Parameters:

  renderer - a renderer for the items in the selection list of the ComboBox, not null

  Note that filtering of the ComboBox is not affected by the renderer that is set here. Filtering is done on the original values and can be affected by setItemLabelGenerator(ItemLabelGenerator).

• setValue

  public void setValue(TValue value)

  Description copied from interface: HasValue

  Sets the value of this object. If the new value is not equal to getValue(), fires a value change event. May throw IllegalArgumentException if the value is not acceptable.

  Implementation note: the implementing class should document whether null values are accepted or not, and override HasValue.getEmptyValue() if the empty value is not null.

  Specified by:

  setValue in interface HasValue<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TItem>

  Overrides:

  setValue in class AbstractField<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TValue>

  Parameters:

  value - the new value

• onAttach

  protected void onAttach(AttachEvent attachEvent)

  Description copied from class: Component

  Called when the component is attached to a UI.

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

  Make sure to call super.onAttach when overriding this method.

  Overrides:

  onAttach in class Component

  Parameters:

  attachEvent - the attach event

• onDetach

  protected void onDetach(DetachEvent detachEvent)

  Description copied from class: Component

  Called when the component is detached from a UI.

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

  Make sure to call super.onDetach when overriding this method.

  Overrides:

  onDetach in class Component

  Parameters:

  detachEvent - the detach event

• addCustomValueSetListener

  public Registration addCustomValueSetListener(ComponentEventListener<ComboBoxBase.CustomValueSetEvent<TComponent>> listener)

  Adds a listener for the event which is fired when user inputs a string value that does not match any existing items and commits it eg. by blurring or pressing the enter-key.

  Note that ComboBox doesn't do anything with the custom value string automatically. Use this method to determine how the custom value should be handled. For example, when the ComboBox has String as the value type, you can add a listener which sets the custom string as the value of the ComboBox with setValue(Object).

  As a side effect, this makes the ComboBox allow custom values. If you want to disable the firing of custom value set events once the listener is added, please disable it explicitly via the setAllowCustomValue(boolean) method.

  The custom value becomes disallowed automatically once the last custom value set listener is removed.

  Parameters:

  listener - the listener to be notified when a new value is filled

  Returns:

  a Registration for removing the event listener

  See Also:

  • setAllowCustomValue(boolean)

• getListDataView

  public ComboBoxListDataView<TItem> getListDataView()

  Gets the list data view for the ComboBox. This data view should only be used when the items are in-memory set with:

  • setItems(Collection)
  • HasListDataView.setItems(Object[])
  • setItems(ListDataProvider)
  • setItems(ComboBox.ItemFilter, ListDataProvider)
  • setItems(ComboBox.ItemFilter, Object[])
  • setItems(ComboBox.ItemFilter, Collection)

  If the items are not in-memory an exception is thrown. When the items are fetched lazily, use getLazyDataView() instead.

  Specified by:

  getListDataView in interface HasListDataView<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TItem>

  Returns:

  the list data view that provides access to the items in the ComboBox

• setItems

  public ComboBoxListDataView<TItem> setItems(Collection<TItem> items)

  Sets the items from the given Collection and returns a ListDataView that provides information and allows operations on the items.

  Filtering will use a case insensitive match to show all items where the filter text is a substring of the label displayed for that item, which you can configure with setItemLabelGenerator(ItemLabelGenerator).

  Filtering will be handled in the client-side if the size of the data set is less than the page size. To force client-side filtering with a larger data set (at the cost of increased network traffic), you can increase the page size with setPageSize(int).

  Setting the items resets the combo box's value to null.

  Specified by:

  setItems in interface HasListDataView<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TItem>

  Parameters:

  items - the items to display, not null

  Returns:

  ListDataView providing access to the items

• setItems

  public ComboBoxListDataView<TItem> setItems(ComboBox.ItemFilter<TItem> itemFilter, Collection<TItem> items)

  Sets the data items of this combo box and a filtering function for defining which items are displayed when user types into the combo box.

  Note that defining a custom filter will force the component to make server roundtrips to handle the filtering. Otherwise it can handle filtering in the client-side, if the size of the data set is less than the pageSize.

  Setting the items resets the combo box's value to null.

  The returned data view object can be used for further access to combo box items, or later on fetched with getListDataView(). For using lazy data loading, use one of the setItems methods which take a fetch callback parameter instead.

  Parameters:

  itemFilter - filter to check if an item is shown when user typed some text into the ComboBox

  items - the data items to display

  Returns:

  the in-memory data view instance that provides access to the data bound to the combo box

• setItems

  public ComboBoxListDataView<TItem> setItems(ComboBox.ItemFilter<TItem> itemFilter, TItem... items)

  Sets the data items of this combo box and a filtering function for defining which items are displayed when user types into the combo box.

  Note that defining a custom filter will force the component to make server roundtrips to handle the filtering. Otherwise it can handle filtering in the client-side, if the size of the data set is less than the pageSize.

  Setting the items resets the combo box's value to null.

  The returned data view object can be used for further access to combo box items, or later on fetched with getListDataView(). For using lazy data loading, use one of the setItems methods which take a fetch callback parameter instead.

  Parameters:

  itemFilter - filter to check if an item is shown when user typed some text into the ComboBox

  items - the data items to display

  Returns:

  the in-memory data view instance that provides access to the data bound to the combo box

• setItems

  public ComboBoxListDataView<TItem> setItems(ComboBox.ItemFilter<TItem> itemFilter, ListDataProvider<TItem> listDataProvider)

  Sets a ListDataProvider for this combo box and a filtering function for defining which items are displayed when user types into the combo box.

  Note that defining a custom filter will force the component to make server roundtrips to handle the filtering. Otherwise it can handle filtering in the client-side, if the size of the data set is less than the pageSize.

  Setting the items resets the combo box's value to null.

  The returned data view object can be used for further access to combo box items, or later on fetched with getListDataView(). For using lazy data loading, use one of the setItems methods which take a fetch callback parameter instead.

  Parameters:

  itemFilter - filter to check if an item is shown when user typed some text into the ComboBox.

  listDataProvider - ListDataProvider providing items to the component.

  Returns:

  the in-memory data view instance that provides access to the data bound to the combo box

• setItems

  public ComboBoxListDataView<TItem> setItems(ListDataProvider<TItem> dataProvider)

  Description copied from interface: HasListDataView

  Sets a ListDataProvider for the component to use and returns a ListDataView that provides information and allows operations on the items.

  Specified by:

  setItems in interface HasListDataView<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TItem>

  Parameters:

  dataProvider - ListDataProvider providing items to the component.

  Returns:

  ListDataView providing access to the items

• getLazyDataView

  public ComboBoxLazyDataView<TItem> getLazyDataView()

  Gets the lazy data view for the ComboBox. This data view should only be used when the items are provided lazily from the backend with:

  • setItems(CallbackDataProvider.FetchCallback)
  • setItemsWithFilterConverter(CallbackDataProvider.FetchCallback, SerializableFunction)
  • setItems(CallbackDataProvider.FetchCallback, CallbackDataProvider.CountCallback)
  • setItemsWithFilterConverter(CallbackDataProvider.FetchCallback, CallbackDataProvider.CountCallback, SerializableFunction)
  • setItems(BackEndDataProvider)

  If the items are not fetched lazily an exception is thrown. When the items are in-memory, use getListDataView() instead.

  Specified by:

  getLazyDataView in interface HasLazyDataView<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TItem,TValue>

  Returns:

  the lazy data view that provides access to the data bound to the ComboBox

  Throws:

  IllegalStateException - if no items fetch callback(s) set

• setItemsWithFilterConverter

  public <C> ComboBoxLazyDataView<TItem> setItemsWithFilterConverter(CallbackDataProvider.FetchCallback<TItem,C> fetchCallback, SerializableFunction<String,C> filterConverter)

  Supply items lazily with a callback from a backend, using custom filter type. The combo box will automatically fetch more items and adjust its size until the backend runs out of items. Usage example:

  comboBox.setItemsWithFilterConverter( query -> orderService.getOrdersByCount(query.getFilter(), query.getOffset(), query.getLimit()), orderCountStr -> Integer.parseInt(orderCountStr)); Note: Validations for orderCountStr are omitted for briefness.

  Combo box's client-side filter typed by the user is transformed into a callback's filter through the given filter converter.

  The returned data view object can be used for further configuration, or later on fetched with getLazyDataView(). For using in-memory data, like Collection, use setItems(Collection) instead.

  Type Parameters:

  C - filter type used by a callback

  Parameters:

  fetchCallback - function that returns a stream of items from the backend based on the offset, limit and a object filter

  filterConverter - a function which converts a combo box's filter-string typed by the user into a callback's object filter

  Returns:

  ComboBoxLazyDataView instance for further configuration

• setItemsWithFilterConverter

  public <C> ComboBoxLazyDataView<TItem> setItemsWithFilterConverter(CallbackDataProvider.FetchCallback<TItem,C> fetchCallback, CallbackDataProvider.CountCallback<TItem,C> countCallback, SerializableFunction<String,C> filterConverter)

  Supply items lazily with callbacks: the first one fetches the items based on offset, limit and an optional filter, the second provides the exact count of items in the backend. Use this only in case getting the count is cheap and the user benefits from the component showing immediately the exact size. Usage example:

  comboBox.setItemsWithFilterConverter( query -> orderService.getOrdersByCount(query.getFilter(), query.getOffset(), query.getLimit()), query -> orderService.getSize(query.getFilter()), orderCountStr -> Integer.parseInt(orderCountStr)); Note: Validations for orderCountStr are omitted for briefness.

  Combo box's client-side filter typed by the user is transformed into a custom filter type through the given filter converter.

  The returned data view object can be used for further configuration, or later on fetched with getLazyDataView(). For using in-memory data, like Collection, use setItems(Collection) instead.

  Type Parameters:

  C - filter type used by a callbacks

  Parameters:

  fetchCallback - function that returns a stream of items from the backend based on the offset, limit and a object filter

  countCallback - function that return the number of items in the back end for a query

  filterConverter - a function which converts a combo box's filter-string typed by the user into a callback's object filter

  Returns:

  ComboBoxLazyDataView instance for further configuration

• setItems

  public ComboBoxLazyDataView<TItem> setItems(CallbackDataProvider.FetchCallback<TItem,String> fetchCallback)

  Supply items lazily with a callback from a backend. The ComboBox will automatically fetch more items and adjust its size until the backend runs out of items. Usage example without component provided filter:

  comboBox.setItems(query -> orderService.getOrders(query.getOffset(), query.getLimit());

  Since ComboBox supports filtering, it can be fetched via query.getFilter():

  comboBox.setItems(query -> orderService.getOrders(query.getFilter(), query.getOffset(), query.getLimit());

  The returned data view object can be used for further configuration, or later on fetched with getLazyDataView(). For using in-memory data, like Collection, use HasListDataView.setItems(Collection) instead.

  If item filtering by some value type other than String is preferred and backend service is able to fetch and filter items by such type, converter for client side's filter string can be set along with fetch callback. See: setItemsWithFilterConverter(CallbackDataProvider.FetchCallback, SerializableFunction)

  Specified by:

  setItems in interface HasLazyDataView<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TItem,TValue>

  Parameters:

  fetchCallback - function that returns a stream of items from the backend based on the offset, limit and an optional filter provided by the query object

  Returns:

  ComboBoxLazyDataView instance for further configuration

• setItems

  public ComboBoxLazyDataView<TItem> setItems(CallbackDataProvider.FetchCallback<TItem,String> fetchCallback, CallbackDataProvider.CountCallback<TItem,String> countCallback)

  Supply items lazily with callbacks: the first one fetches the items based on offset, limit and an optional filter, the second provides the exact count of items in the backend. Use this only in case getting the count is cheap and the user benefits from the ComboBox showing immediately the exact size. Usage example without component provided filter:

  comboBox.setItems( query -> orderService.getOrders(query.getOffset(), query.getLimit()), query -> orderService.getSize());

  Since ComboBox supports filtering, it can be fetched via query.getFilter():

  comboBox.setItems( query -> orderService.getOrders(query.getFilter(), query.getOffset(), query.getLimit()), query -> orderService.getSize(query.getFilter()));

  The returned data view object can be used for further configuration, or later on fetched with getLazyDataView(). For using in-memory data, like Collection, use HasListDataView.setItems(Collection) instead.

  If item filtering by some value type other than String is preferred and backend service is able to fetch and filter items by such type, converter for client side's filter string can be set along with fetch callback. See: setItemsWithFilterConverter(CallbackDataProvider.FetchCallback, CallbackDataProvider.CountCallback, SerializableFunction)

  Specified by:

  setItems in interface HasLazyDataView<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TItem,TValue>

  Parameters:

  fetchCallback - function that returns a stream of items from the back end for a query

  countCallback - function that return the number of items in the back end for a query

  Returns:

  ComboBoxLazyDataView instance for further configuration

• setItemsPageable

  public ComboBoxLazyDataView<TItem> setItemsPageable(ComboBoxBase.SpringData.FetchCallback<org.springframework.data.domain.Pageable,TItem> fetchCallback)

  Supply items lazily with a callback from a backend based on a Spring Data Pageable. The component will automatically fetch more items and adjust its size until the backend runs out of items. Usage example:

  comboBox.setItemsPageable((pageable, filterString) -> orderService.getOrders(pageable, filterString));

  The returned data view object can be used for further configuration, or later on fetched with getLazyDataView(). For using in-memory data, like Collection, use HasListDataView.setItems(Collection) instead.

  Parameters:

  fetchCallback - a function that returns a sorted list of items from the backend based on the given pageable

  Returns:

  a data view for further configuration

• setItemsPageable

  public ComboBoxLazyDataView<TItem> setItemsPageable(ComboBoxBase.SpringData.FetchCallback<org.springframework.data.domain.Pageable,TItem> fetchCallback, ComboBoxBase.SpringData.CountCallback<org.springframework.data.domain.Pageable> countCallback)

  Supply items lazily with callbacks: the first one fetches a list of items from a backend based on a Spring Data Pageable, the second provides the exact count of items in the backend. Use this in case getting the count is cheap and the user benefits from the component showing immediately the exact size. Usage example:

  component.setItemsPageable( (pageable, filterString) -> orderService.getOrders(pageable, filterString), (pageable, filterString) -> orderService.countOrders(filterString));

  The returned data view object can be used for further configuration, or later on fetched with getLazyDataView(). For using in-memory data, like Collection, use HasListDataView.setItems(Collection) instead.

  Parameters:

  fetchCallback - a function that returns a sorted list of items from the backend based on the given pageable and filter string

  countCallback - a function that returns the number of items in the back end based on the filter string

  Returns:

  LazyDataView instance for further configuration

• setItems

  public ComboBoxLazyDataView<TItem> setItems(BackEndDataProvider<TItem,String> dataProvider)

  Description copied from interface: HasLazyDataView

  Supply items with a BackEndDataProvider that lazy loads items from a backend. Note that component will query the data provider for the item count. In case that is not desired for performance reasons, use HasLazyDataView.setItems(CallbackDataProvider.FetchCallback) instead.

  The returned data view object can be used for further configuration, or later on fetched with HasLazyDataView.getLazyDataView(). For using in-memory data, like Collection, use HasListDataView.setItems(Collection) instead.

  Specified by:

  setItems in interface HasLazyDataView<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TItem,TValue>

  Parameters:

  dataProvider - BackEndDataProvider instance

  Returns:

  LazyDataView instance for further configuration

• getGenericDataView

  public ComboBoxDataView<TItem> getGenericDataView()

  Gets the generic data view for the ComboBox. This data view can be used when getListDataView() or getLazyDataView() are not applicable for the underlying data provider, or you don't want to distinct between which type of data view to use.

  Specified by:

  getGenericDataView in interface HasDataView<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TItem,TValue>

  Returns:

  the generic DataView implementation for ComboBox

  See Also:

  • getListDataView()
  • getLazyDataView()

• setItems

  public ComboBoxDataView<TItem> setItems(DataProvider<TItem,String> dataProvider)

  Description copied from interface: HasDataView

  Set a generic data provider for the component to use and returns the base DataView that provides API to get information on the items.

  This method should be used only when the data provider type is not either ListDataProvider or BackEndDataProvider.

  Specified by:

  setItems in interface HasDataView<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TItem,TValue>

  Parameters:

  dataProvider - DataProvider instance to use, not null

  Returns:

  DataView providing information on the data

• setItems

  @Deprecated public ComboBoxDataView<TItem> setItems(InMemoryDataProvider<TItem> dataProvider)

  Deprecated.

  does not work so don't use

  The method is not supported for the ComboBox component, use another overloaded method with filter converter setItems(InMemoryDataProvider, SerializableFunction)

  Always throws an UnsupportedOperationException.

  Specified by:

  setItems in interface HasDataView<TComponent extends ComboBoxBase<TComponent,TItem,TValue>,TItem,TValue>

  Parameters:

  dataProvider - InMemoryDataProvider to use, not null

  Returns:

  DataView providing information on the data

  Throws:

  UnsupportedOperationException - when using this method with an InMemoryDataProvider

  See Also:

  • setItems(InMemoryDataProvider, SerializableFunction)

• setItems

  public ComboBoxDataView<TItem> setItems(InMemoryDataProvider<TItem> inMemoryDataProvider, SerializableFunction<String,SerializablePredicate<TItem>> filterConverter)

  Sets an in-memory data provider for the combo box to use, taking into account both in-memory filtering from data provider and combo box's text filter.

  Text filter is transformed into a predicate filter through the given filter converter. Example of filter converter which produces the Person's name predicate: (String nameFilter) -> person -> person.getName().equalsIgnoreCase (nameFilter);

  Filtering will be handled in the client-side if the size of the data set is less than the page size. To force client-side filtering with a larger data set (at the cost of increased network traffic), you can increase the page size with setPageSize(int).

  Note! Using a ListDataProvider instead of a InMemoryDataProvider is recommended to get access to ListDataView API by using setItems(ListDataProvider).

  Parameters:

  inMemoryDataProvider - InMemoryDataProvider to use, not null

  filterConverter - a function which converts a component's internal filter into a predicate applied to the data provider

  Returns:

  DataView providing information on the data

• setDataProvider

  public <C> void setDataProvider(DataProvider<TItem,C> dataProvider, SerializableFunction<String,C> filterConverter)

  Sets a generic data provider for the ComboBox to use.

  ComboBox triggers filtering queries based on the strings users type into the field. For this reason you need to provide the second parameter, a function which converts the filter-string typed by the user into filter-type used by your data provider. If your data provider already supports String as the filter-type, it can be used without a converter function via setItems(DataProvider).

  Using this method provides the same result as using a data provider wrapped with DataProvider.withConvertedFilter(SerializableFunction).

  Changing the combo box's data provider resets its current value to null.

  Use this method when none of the setItems methods are applicable, e.g. when having a data provider with filter that cannot be transformed to DataProvider<T, Void>.

• setDataProvider

  public void setDataProvider(ComboBox.FetchItemsCallback<TItem> fetchItems, SerializableFunction<String,Integer> sizeCallback)

  Sets a CallbackDataProvider using the given fetch items callback and a size callback.

  This method is a shorthand for making a CallbackDataProvider that handles a partial Query object.

  Changing the combo box's data provider resets its current value to null.

  Parameters:

  fetchItems - a callback for fetching items, not null

  sizeCallback - a callback for getting the count of items, not null

  See Also:

  • CallbackDataProvider

• getDataProvider

  public DataProvider<TItem,?> getDataProvider()

  Gets the data provider used by this ComboBox.

  To get information and control over the items in the ComboBox, use either getListDataView() or getLazyDataView() instead.

  Returns:

  the data provider used by this ComboBox

• isSelected

  protected abstract boolean isSelected(TItem item)

  Whether the item is currently selected in the combo box.

  Parameters:

  item - the item to check

  Returns:

  true if the item is selected, false otherwise

• refreshValue

  protected abstract void refreshValue()

  Refresh value / selection of the web component after changes that might affect the presentation / rendering of items

• getRenderManager

  protected com.vaadin.flow.component.combobox.ComboBoxRenderManager<TItem> getRenderManager()

  Accesses the render manager that is managing the custom renderer

  Returns:

  the render manager

• getDataController

  protected com.vaadin.flow.component.combobox.ComboBoxDataController<TItem> getDataController()

  Accesses the data controller that is managing data communication with the web component

  Can be null if the constructor has not run yet

  Returns:

  the data controller

• getDataCommunicator

  protected ComboBoxDataCommunicator<TItem> getDataCommunicator()

  Accesses the data communicator that is managed by the data controller

  Can be null if the no data source has been set yet, or if the constructor has not run yet

  Returns:

  the data communicator

• getDataGenerator

  protected CompositeDataGenerator<TItem> getDataGenerator()

  Accesses the data generator that is managed by the data controller

  Can be null if the constructor has not run yet

  Returns:

  the data generator

• getKeyMapper

  protected DataKeyMapper<TItem> getKeyMapper()

  Accesses the key mapper that is managed by the data controller

  Can be null if the no data source has been set yet, or if the constructor has not run yet

  Returns:

  the key mapper

• runBeforeClientResponse

  protected void runBeforeClientResponse(SerializableConsumer<UI> command)

  Helper for running a command in the before client response hook

  Parameters:

  command - the command to execute

• setManualValidation

  public void setManualValidation(boolean enabled)

  Description copied from interface: HasValidation

  Sets whether manual validation mode is enabled for the component.

  When enabled, the component doesn't perform its built-in constraint validation on value change, blur, and other events. This allows manually controlling the invalid state and error messages using the HasValidation.setInvalid(boolean) and HasValidation.setErrorMessage(String) methods. Manual mode is helpful when there is a need for a totally custom validation logic that cannot be achieved with Binder.

  Example:

   Field field = new Field();
   field.setManualValidation(true);
   field.addValueChangeListener(event -> {
       if (Objects.equal(event.getValue(), "")) {
           field.setInvalid(true);
           field.setErrorMessage("The field is required.");
       } else {
           field.setInvalid(false);
       }
   });
   

  For components that don't have built-in validation, the method has no effect.

  Specified by:

  setManualValidation in interface HasValidation

  Parameters:

  enabled - whether to enable manual validation mode.

• getDefaultValidator

  public Validator<TValue> getDefaultValidator()

  Description copied from interface: HasValidator

  Returns a validator that checks the state of the Value. This should be overridden for components with internal value conversion or validation, e.g. when the user is providing a string that has to be parsed into a date. An invalid input from user will be exposed to a Binder and can be seen as a validation failure.

  Specified by:

  getDefaultValidator in interface HasValidator<TComponent extends ComboBoxBase<TComponent,TItem,TValue>>

  Returns:

  state validator

• validate

  protected void validate()

  Validates the current value against the constraints and sets the invalid property and the errorMessage property based on the result. If a custom error message is provided with HasValidationProperties.setErrorMessage(String), it is used. Otherwise, the error message defined in the i18n object is used.

  The method does nothing if the manual validation mode is enabled.

• getI18n

  protected ComboBoxBaseI18n getI18n()

  Gets the internationalization object previously set for this component.

  NOTE: Updating the instance that is returned from this method will not update the component if not set again using setI18n(ComboBoxBaseI18n)

  Returns:

  the i18n object or null if no i18n object has been set

• setI18n

  protected void setI18n(ComboBoxBaseI18n i18n)

  Sets the internationalization object for this component.

  Parameters:

  i18n - the i18n object, not null