/** * Creates a new data provider backed by a collection. * <p> * The collection is used as-is. Changes in the collection will be visible * via the created data provider. The caller should copy the collection if * necessary. * * @param <T> * the data item type * @param items * the collection of data, not <code>null</code> * @return a new list data provider */ public static <T> ListDataProvider<T> ofCollection(Collection<T> items) { return new ListDataProvider<>(items); }
@Override public void setFilter(SerializablePredicate<T> filter) { this.filter = filter; refreshAll(); } }
@Override public int size(Query<T, SerializablePredicate<T>> query) { return (int) getFilteredStream(query).count(); }
new ListDataProvider<>(tasks); Task task = new Task(false, "New task"); tasks.add(task); dataProvider.refreshAll(); Set<Task> selectedItems = tasksGrid.getSelectedItems(); tasks.removeAll(selectedItems); dataProvider.refreshAll(); Iterator<Task> iterator = dataProvider.getItems().iterator(); if (iterator.hasNext()) { tasksGrid.select(iterator.next());
private void handleTargetGridDrop(GridDropEvent<T> event, final int index, Collection<T> droppedItems) { Grid<T> target = getGridDropTarget().getGrid(); if (getTargetDataProviderUpdater() != null) { getTargetDataProviderUpdater().onDrop(event.getDropEffect(), target.getDataProvider(), index, droppedItems); return; } ListDataProvider<T> listDataProvider = (ListDataProvider<T>) target .getDataProvider(); // update the existing to keep filters etc. List<T> targetItems = (List<T>) listDataProvider.getItems(); if (index != Integer.MAX_VALUE) { targetItems.addAll(index, droppedItems); } else { targetItems.addAll(droppedItems); } // instead of using setItems or creating a new data provider, // refresh the existing one to keep filters etc. in place listDataProvider.refreshAll(); // if dropped to the end of the grid, the grid should scroll there so // that the dropped row is visible, but that is just recommended in // documentation and left for the users to take into use }
private void onFilter( final ValueChangeEvent event) { this.dataProvider.clearFilters(); this.dataProvider.addFilter(getFilter(event)); }
private int calculateDropIndex(GridDropEvent<T> event) { // use custom calculator if present if (getDropIndexCalculator() != null) { return getDropIndexCalculator().calculateDropIndex(event); } // if the source and target grids are the same, then the index has been // calculated before removing the items. In this case the drop location // is always above, since the items will be starting from that point on if (shiftedDropIndex != -1) { return shiftedDropIndex; } ListDataProvider<T> targetDataProvider = (ListDataProvider<T>) getGridDropTarget() .getGrid().getDataProvider(); List<T> items = (List<T>) targetDataProvider.getItems(); int index = items.size(); Optional<T> dropTargetRow = event.getDropTargetRow(); if (dropTargetRow.isPresent()) { index = items.indexOf(dropTargetRow.get()) + (event.getDropLocation() == DropLocation.BELOW ? 1 : 0); } return index; }
@Override public void handleAction( final Object sender, final Object target) { textField.setValue(""); textField.dataProvider.clearFilters(); } }
void addFilter( final FilterModel filter) { /* Ensure that the filter value is not null */ if (filter != null && filter.getValue() != null) { this.appliedFilters.add(filter); this.dataProvider.addFilter(FilterPredicateBuilder.build(filter)); getEventRouter().fireEvent(FilterChangeEvent.ADD(this, filter)); } }
private void handleSourceGridDrop(GridDropEvent<T> event, final Collection<T> droppedItems) { Grid<T> source = getGridDragSource().getGrid(); if (getSourceDataProviderUpdater() != null) { getSourceDataProviderUpdater().removeItems(event.getDropEffect(), source.getDataProvider(), droppedItems); return; } ListDataProvider<T> listDataProvider = (ListDataProvider<T>) source .getDataProvider(); // use the existing data source to keep filters and sort orders etc. in // place. Collection<T> sourceItems = listDataProvider.getItems(); // if reordering the same grid and dropping on top of one of the dragged // rows, need to calculate the new drop index before removing the items if (getGridDragSource().getGrid() == getGridDropTarget().getGrid() && event.getDropTargetRow().isPresent() && getDraggedItems().contains(event.getDropTargetRow().get())) { List<T> sourceItemsList = (List<T>) sourceItems; shiftedDropIndex = sourceItemsList .indexOf(event.getDropTargetRow().get()); shiftedDropIndex -= getDraggedItems().stream().filter( item -> sourceItemsList.indexOf(item) < shiftedDropIndex) .count(); } sourceItems.removeAll(droppedItems); listDataProvider.refreshAll(); }
private void onFilter(final ValueChangeEvent event) { this.dataProvider.clearFilters(); this.dataProvider.addFilter(getFilter(event)); }
@SuppressWarnings("unchecked") private void verifySourceDataProvider() { if (getSourceDataProviderUpdater() != null) { return; // custom updater is always fine } if (!(getSourceDataProvider() instanceof ListDataProvider)) { throwUnsupportedOperationExceptionForUnsupportedDataProvider(true); } if (!(((ListDataProvider<T>) getSourceDataProvider()) .getItems() instanceof List)) { throwUnsupportedOperationExceptionForUnsupportedCollectionInListDataProvider( true); } }
void removeFilters() { this.textField.clear(); this.options.clear(); this.appliedFilters.clear(); this.dataProvider.clearFilters(); }
/** * Creates a new data provider from the given items. * <p> * The items are copied into a new backing list, so structural changes to * the provided array will not be visible via the created data provider. * * @param <T> * the data item type * @param items * the data items * @return a new list data provider */ @SafeVarargs public static <T> ListDataProvider<T> ofItems(T... items) { return new ListDataProvider<>(new ArrayList<>(Arrays.asList(items))); }
@Override public void setSortComparator(SerializableComparator<T> comparator) { this.sortOrder = comparator; refreshAll(); }
void removeFilter( final FilterModel filter) { this.dataProvider.clearFilters(); this.appliedFilters.remove(filter); this.appliedFilters.forEach(f -> this.dataProvider.addFilter(FilterPredicateBuilder.build(f))); }
@SuppressWarnings("unchecked") private void verifyTargetDataProvider() { if (getTargetDataProviderUpdater() != null && getDropIndexCalculator() != null) { return; // custom updater and calculator is always fine } if (!(getTargetDataProvider() instanceof ListDataProvider)) { throwUnsupportedOperationExceptionForUnsupportedDataProvider(false); } if (!(((ListDataProvider<T>) getTargetDataProvider()) .getItems() instanceof List)) { throwUnsupportedOperationExceptionForUnsupportedCollectionInListDataProvider( false); } }
@Override public void handleAction(final Object sender, final Object target) { field.setSelectedItem(null); field.dataProvider.clearFilters(); } }
@Override public Stream<T> fetch(Query<T, SerializablePredicate<T>> query) { Stream<T> stream = getFilteredStream(query); Optional<Comparator<T>> comparing = Stream .of(query.getInMemorySorting(), sortOrder) .filter(c -> c != null) .reduce((c1, c2) -> c1.thenComparing(c2)); if (comparing.isPresent()) { stream = stream.sorted(comparing.get()); } return stream.skip(query.getOffset()).limit(query.getLimit()); }
/** * Creates a new data provider from the given stream. <b>All items in the * stream are eagerly collected to a list.</b> * <p> * This is a shorthand for using {@link #ofCollection(Collection)} after * collecting the items in the stream to a list with e.g. * {@code stream.collect(Collectors.toList));}. * <p> * <strong>Using big streams is not recommended, you should instead use a * lazy data provider.</strong> See * {@link #fromCallbacks(FetchCallback, CountCallback)} or * {@link BackEndDataProvider} for more info. * * @param <T> * the data item type * @param items * a stream of data items, not {@code null} * @return a new list data provider */ public static <T> ListDataProvider<T> fromStream(Stream<T> items) { return new ListDataProvider<>(items.collect(Collectors.toList())); }