com.vaadin.ui.Grid Maven / Gradle / Ivy
/*
* Copyright (C) 2000-2024 Vaadin Ltd
*
* This program is available under Vaadin Commercial License and Service Terms.
*
* See for the full
* license.
*/
package com.vaadin.ui;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Attributes;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import com.vaadin.data.BeanPropertySet;
import com.vaadin.data.Binder;
import com.vaadin.data.Binder.Binding;
import com.vaadin.data.HasDataProvider;
import com.vaadin.data.HasValue;
import com.vaadin.data.PropertyDefinition;
import com.vaadin.data.PropertySet;
import com.vaadin.data.ValueProvider;
import com.vaadin.data.provider.CallbackDataProvider;
import com.vaadin.data.provider.DataCommunicator;
import com.vaadin.data.provider.DataGenerator;
import com.vaadin.data.provider.DataProvider;
import com.vaadin.data.provider.GridSortOrder;
import com.vaadin.data.provider.GridSortOrderBuilder;
import com.vaadin.data.provider.InMemoryDataProvider;
import com.vaadin.data.provider.Query;
import com.vaadin.data.provider.QuerySortOrder;
import com.vaadin.event.ConnectorEvent;
import com.vaadin.event.ContextClickEvent;
import com.vaadin.event.HasUserOriginated;
import com.vaadin.event.SortEvent;
import com.vaadin.event.SortEvent.SortListener;
import com.vaadin.event.SortEvent.SortNotifier;
import com.vaadin.event.selection.MultiSelectionListener;
import com.vaadin.event.selection.SelectionListener;
import com.vaadin.event.selection.SingleSelectionListener;
import com.vaadin.server.AbstractExtension;
import com.vaadin.server.EncodeResult;
import com.vaadin.server.Extension;
import com.vaadin.server.JsonCodec;
import com.vaadin.server.SerializableComparator;
import com.vaadin.server.SerializableSupplier;
import com.vaadin.server.Setter;
import com.vaadin.server.VaadinServiceClassLoaderUtil;
import com.vaadin.shared.Connector;
import com.vaadin.shared.MouseEventDetails;
import com.vaadin.shared.Registration;
import com.vaadin.shared.data.DataCommunicatorConstants;
import com.vaadin.shared.data.sort.SortDirection;
import com.vaadin.shared.ui.ContentMode;
import com.vaadin.shared.ui.grid.AbstractGridExtensionState;
import com.vaadin.shared.ui.grid.ColumnResizeMode;
import com.vaadin.shared.ui.grid.ColumnState;
import com.vaadin.shared.ui.grid.DetailsManagerState;
import com.vaadin.shared.ui.grid.GridClientRpc;
import com.vaadin.shared.ui.grid.GridConstants;
import com.vaadin.shared.ui.grid.GridConstants.Section;
import com.vaadin.shared.ui.grid.GridConstants.SidebarColumnOrder;
import com.vaadin.shared.ui.grid.GridServerRpc;
import com.vaadin.shared.ui.grid.GridState;
import com.vaadin.shared.ui.grid.GridStaticCellType;
import com.vaadin.shared.ui.grid.HeightMode;
import com.vaadin.shared.ui.grid.ScrollDestination;
import com.vaadin.shared.ui.grid.SectionState;
import com.vaadin.ui.components.grid.ColumnReorderListener;
import com.vaadin.ui.components.grid.ColumnResizeListener;
import com.vaadin.ui.components.grid.ColumnVisibilityChangeListener;
import com.vaadin.ui.components.grid.DetailsGenerator;
import com.vaadin.ui.components.grid.Editor;
import com.vaadin.ui.components.grid.EditorImpl;
import com.vaadin.ui.components.grid.Footer;
import com.vaadin.ui.components.grid.FooterRow;
import com.vaadin.ui.components.grid.GridMultiSelect;
import com.vaadin.ui.components.grid.GridSelectionModel;
import com.vaadin.ui.components.grid.GridSingleSelect;
import com.vaadin.ui.components.grid.Header;
import com.vaadin.ui.components.grid.Header.Row;
import com.vaadin.ui.components.grid.HeaderCell;
import com.vaadin.ui.components.grid.HeaderRow;
import com.vaadin.ui.components.grid.ItemClickListener;
import com.vaadin.ui.components.grid.MultiSelectionModel;
import com.vaadin.ui.components.grid.MultiSelectionModelImpl;
import com.vaadin.ui.components.grid.NoSelectionModel;
import com.vaadin.ui.components.grid.SingleSelectionModel;
import com.vaadin.ui.components.grid.SingleSelectionModelImpl;
import com.vaadin.ui.components.grid.SortOrderProvider;
import com.vaadin.ui.declarative.DesignAttributeHandler;
import com.vaadin.ui.declarative.DesignContext;
import com.vaadin.ui.declarative.DesignException;
import com.vaadin.ui.declarative.DesignFormatter;
import com.vaadin.ui.renderers.AbstractRenderer;
import com.vaadin.ui.renderers.ComponentRenderer;
import com.vaadin.ui.renderers.HtmlRenderer;
import com.vaadin.ui.renderers.Renderer;
import com.vaadin.ui.renderers.TextRenderer;
import com.vaadin.util.ReflectTools;
import elemental.json.Json;
import elemental.json.JsonObject;
import elemental.json.JsonValue;
/**
* A grid component for displaying tabular data.
*
* @author Vaadin Ltd
* @since 8.0
*
* @param
* the grid bean type
*/
public class Grid extends AbstractListing implements HasComponents,
HasDataProvider, SortNotifier> {
private static final String DECLARATIVE_DATA_ITEM_TYPE = "data-item-type";
/**
* A callback method for fetching items. The callback is provided with a
* list of sort orders, offset index and limit.
*
* @param
* the grid bean type
*/
@FunctionalInterface
public interface FetchItemsCallback extends Serializable {
/**
* Returns a stream of items ordered by given sort orders, limiting the
* results with given offset and limit.
*
* This method is called after the size of the data set is asked from a
* related size callback. The offset and limit are promised to be within
* the size of the data set.
*
* @param sortOrder
* a list of sort orders
* @param offset
* the first index to fetch
* @param limit
* the fetched item count
* @return stream of items
*/
public Stream fetchItems(List sortOrder, int offset,
int limit);
}
@Deprecated
private static final Method COLUMN_REORDER_METHOD = ReflectTools.findMethod(
ColumnReorderListener.class, "columnReorder",
ColumnReorderEvent.class);
private static final Method SORT_ORDER_CHANGE_METHOD = ReflectTools
.findMethod(SortListener.class, "sort", SortEvent.class);
@Deprecated
private static final Method COLUMN_RESIZE_METHOD = ReflectTools.findMethod(
ColumnResizeListener.class, "columnResize",
ColumnResizeEvent.class);
@Deprecated
private static final Method ITEM_CLICK_METHOD = ReflectTools
.findMethod(ItemClickListener.class, "itemClick", ItemClick.class);
@Deprecated
private static final Method COLUMN_VISIBILITY_METHOD = ReflectTools
.findMethod(ColumnVisibilityChangeListener.class,
"columnVisibilityChanged",
ColumnVisibilityChangeEvent.class);
/**
* Selection mode representing the built-in selection models in grid.
*
* These enums can be used in {@link Grid#setSelectionMode(SelectionMode)}
* to easily switch between the build-in selection models.
*
* @see Grid#setSelectionMode(SelectionMode)
* @see Grid#setSelectionModel(GridSelectionModel)
*/
public enum SelectionMode {
/**
* Single selection mode that maps to build-in
* {@link SingleSelectionModel}.
*
* @see SingleSelectionModelImpl
*/
SINGLE {
@Override
protected GridSelectionModel createModel() {
return new SingleSelectionModelImpl<>();
}
},
/**
* Multiselection mode that maps to build-in {@link MultiSelectionModel}
* .
*
* @see MultiSelectionModelImpl
*/
MULTI {
@Override
protected GridSelectionModel createModel() {
return new MultiSelectionModelImpl<>();
}
},
/**
* Selection model that doesn't allow selection.
*
* @see NoSelectionModel
*/
NONE {
@Override
protected GridSelectionModel createModel() {
return new NoSelectionModel<>();
}
};
/**
* Creates the selection model to use with this enum.
*
* @param
* the type of items in the grid
* @return the selection model
*/
protected abstract GridSelectionModel createModel();
}
/**
* An event that is fired when the columns are reordered.
*/
public static class ColumnReorderEvent extends Component.Event
implements HasUserOriginated {
private final boolean userOriginated;
/**
*
* @param source
* the grid where the event originated from
* @param userOriginated
* true if event is a result of user
* interaction, false if from API call
*/
public ColumnReorderEvent(Grid source, boolean userOriginated) {
super(source);
this.userOriginated = userOriginated;
}
/**
* Returns true if the column reorder was done by the user,
* false if not and it was triggered by server side code.
*
* @return true if event is a result of user interaction
*/
@Override
public boolean isUserOriginated() {
return userOriginated;
}
}
/**
* An event that is fired when a column is resized, either programmatically
* or by the user.
*/
public static class ColumnResizeEvent extends Component.Event
implements HasUserOriginated {
private final Column column;
private final boolean userOriginated;
/**
*
* @param source
* the grid where the event originated from
* @param column
* the column that was resized
* @param userOriginated
* true if event is a result of user
* interaction, false if from API call
*/
public ColumnResizeEvent(Grid source, Column column,
boolean userOriginated) {
super(source);
this.column = column;
this.userOriginated = userOriginated;
}
/**
* Returns the column that was resized.
*
* @return the resized column.
*/
public Column getColumn() {
return column;
}
/**
* Returns true if the column resize was done by the user,
* false if not and it was triggered by server side code.
*
* @return true if event is a result of user interaction
*/
@Override
public boolean isUserOriginated() {
return userOriginated;
}
}
/**
* An event fired when an item in the Grid has been clicked.
*
* @param
* the grid bean type
*/
public static class ItemClick extends ConnectorEvent {
private final T item;
private final Column column;
private final MouseEventDetails mouseEventDetails;
private final int rowIndex;
/**
* Creates a new {@code ItemClick} event containing the given item and
* Column originating from the given Grid.
*
* @param source
* the grid where the event originated from
* @param column
* the column that contains the clicked cell
* @param item
* the item that was clicked
* @param mouseEventDetails
* mouse event details about the click
* @param rowIndex
* the index of the row that contains the clicked cell
*/
public ItemClick(Grid source, Column column, T item,
MouseEventDetails mouseEventDetails, int rowIndex) {
super(source);
this.column = column;
this.item = item;
this.mouseEventDetails = mouseEventDetails;
this.rowIndex = rowIndex;
}
/**
* Returns the clicked item.
*
* @return the clicked item
*/
public T getItem() {
return item;
}
/**
* Returns the clicked column.
*
* @return the clicked column
*/
public Column getColumn() {
return column;
}
/**
* Returns the source Grid.
*
* @return the grid
*/
@Override
@SuppressWarnings("unchecked")
public Grid getSource() {
return (Grid) super.getSource();
}
/**
* Returns the mouse event details.
*
* @return the mouse event details
*/
public MouseEventDetails getMouseEventDetails() {
return mouseEventDetails;
}
/**
* Returns the clicked rowIndex.
*
* @return the clicked rowIndex
* @since 8.4
*/
public int getRowIndex() {
return rowIndex;
}
}
/**
* ContextClickEvent for the Grid Component.
*
*
* Usage:
*
*
* grid.addContextClickListener(event -> Notification.show(
* ((GridContextClickEvent<Person>) event).getItem() + " Clicked"));
*
*
* @param
* the grid bean type
*/
public static class GridContextClickEvent extends ContextClickEvent {
private final T item;
private final int rowIndex;
private final Column column;
private final Section section;
/**
* Creates a new context click event.
*
* @param source
* the grid where the context click occurred
* @param mouseEventDetails
* details about mouse position
* @param section
* the section of the grid which was clicked
* @param rowIndex
* the index of the row which was clicked
* @param item
* the item which was clicked
* @param column
* the column which was clicked
*/
public GridContextClickEvent(Grid source,
MouseEventDetails mouseEventDetails, Section section,
int rowIndex, T item, Column column) {
super(source, mouseEventDetails);
this.item = item;
this.section = section;
this.column = column;
this.rowIndex = rowIndex;
}
/**
* Returns the item of context clicked row.
*
* @return item of clicked row; null if header or footer
*/
public T getItem() {
return item;
}
/**
* Returns the clicked column.
*
* @return the clicked column
*/
public Column getColumn() {
return column;
}
/**
* Return the clicked section of Grid.
*
* @return section of grid
*/
public Section getSection() {
return section;
}
/**
* Returns the clicked row index.
*
* Header and Footer rows for index can be fetched with
* {@link Grid#getHeaderRow(int)} and {@link Grid#getFooterRow(int)}.
*
* @return row index in section
*/
public int getRowIndex() {
return rowIndex;
}
@Override
@SuppressWarnings("unchecked")
public Grid getComponent() {
return (Grid) super.getComponent();
}
}
/**
* An event that is fired when a column's visibility changes.
*
* @since 7.5.0
*/
public static class ColumnVisibilityChangeEvent extends Component.Event
implements HasUserOriginated {
private final Column column;
private final boolean userOriginated;
private final boolean hidden;
/**
* Constructor for a column visibility change event.
*
* @param source
* the grid from which this event originates
* @param column
* the column that changed its visibility
* @param hidden
* true if the column was hidden,
* false if it became visible
* @param isUserOriginated
* true if the event was triggered by an UI
* interaction
*/
public ColumnVisibilityChangeEvent(Grid source, Column column,
boolean hidden, boolean isUserOriginated) {
super(source);
this.column = column;
this.hidden = hidden;
userOriginated = isUserOriginated;
}
/**
* Gets the column that became hidden or visible.
*
* @return the column that became hidden or visible.
* @see Column#isHidden()
*/
public Column getColumn() {
return column;
}
/**
* Was the column set hidden or visible.
*
* @return true if the column was hidden false
* if it was set visible
*/
public boolean isHidden() {
return hidden;
}
@Override
public boolean isUserOriginated() {
return userOriginated;
}
}
/**
* A helper base class for creating extensions for the Grid component.
*
* @param
*/
public abstract static class AbstractGridExtension
extends AbstractListingExtension {
@Override
public void extend(AbstractListing grid) {
if (!(grid instanceof Grid)) {
throw new IllegalArgumentException(
getClass().getSimpleName() + " can only extend Grid");
}
super.extend(grid);
}
/**
* Adds given component to the connector hierarchy of Grid.
*
* @param c
* the component to add
*/
protected void addComponentToGrid(Component c) {
getParent().addExtensionComponent(c);
}
/**
* Removes given component from the connector hierarchy of Grid.
*
* @param c
* the component to remove
*/
protected void removeComponentFromGrid(Component c) {
getParent().removeExtensionComponent(c);
}
@Override
public Grid getParent() {
return (Grid) super.getParent();
}
@Override
protected AbstractGridExtensionState getState() {
return (AbstractGridExtensionState) super.getState();
}
@Override
protected AbstractGridExtensionState getState(boolean markAsDirty) {
return (AbstractGridExtensionState) super.getState(markAsDirty);
}
/**
* Returns the internal id for given column. This id should not be
* confused with the user-defined identifier.
*
* @param column
* the column
* @return internal id of given column
*/
protected String getInternalIdForColumn(Column column) {
return getParent().getInternalIdForColumn(column);
}
}
private final class GridServerRpcImpl implements GridServerRpc {
@Override
public void sort(String[] columnInternalIds, SortDirection[] directions,
boolean isUserOriginated) {
assert columnInternalIds.length == directions.length : "Column and sort direction counts don't match.";
List> list = new ArrayList<>(directions.length);
for (int i = 0; i < columnInternalIds.length; ++i) {
Column column = columnKeys.get(columnInternalIds[i]);
list.add(new GridSortOrder<>(column, directions[i]));
}
setSortOrder(list, isUserOriginated);
}
@Override
public void itemClick(String rowKey, String columnInternalId,
MouseEventDetails details, int rowIndex) {
Column column = getColumnByInternalId(columnInternalId);
T item = getDataCommunicator().getKeyMapper().get(rowKey);
fireEvent(new ItemClick<>(Grid.this, column, item, details,
rowIndex));
}
@Override
public void contextClick(int rowIndex, String rowKey,
String columnInternalId, Section section,
MouseEventDetails details) {
T item = null;
if (rowKey != null) {
item = getDataCommunicator().getKeyMapper().get(rowKey);
}
fireEvent(new GridContextClickEvent<>(Grid.this, details, section,
rowIndex, item, getColumnByInternalId(columnInternalId)));
}
@Override
public void columnsReordered(List newColumnOrder,
List oldColumnOrder) {
final String diffStateKey = "columnOrder";
ConnectorTracker connectorTracker = getUI().getConnectorTracker();
JsonObject diffState = connectorTracker.getDiffState(Grid.this);
// discard the change if the columns have been reordered from
// the server side, as the server side is always right
if (getState(false).columnOrder.equals(oldColumnOrder)) {
// Don't mark as dirty since client has the state already
getState(false).columnOrder = newColumnOrder;
// write changes to diffState so that possible reverting the
// column order is sent to client
assert diffState
.hasKey(diffStateKey) : "Field name has changed";
Type type = null;
try {
type = getState(false).getClass().getField(diffStateKey)
.getGenericType();
} catch (NoSuchFieldException | SecurityException e) {
e.printStackTrace();
}
EncodeResult encodeResult = JsonCodec.encode(
getState(false).columnOrder, diffState, type,
connectorTracker);
diffState.put(diffStateKey, encodeResult.getEncodedValue());
fireColumnReorderEvent(true);
} else {
// make sure the client is reverted to the order that the
// server thinks it is
diffState.remove(diffStateKey);
markAsDirty();
}
}
@Override
public void columnVisibilityChanged(String internalId, boolean hidden) {
Column column = getColumnByInternalId(internalId);
column.checkColumnIsAttached();
if (column.isHidden() != hidden) {
column.getState().hidden = hidden;
fireColumnVisibilityChangeEvent(column, hidden, true);
}
}
@Override
public void columnResized(String internalId, double pixels) {
final Column column = getColumnByInternalId(internalId);
if (column != null && column.isResizable()) {
column.getState().width = pixels;
fireColumnResizeEvent(column, true);
}
}
}
/**
* Class for managing visible details rows.
*
* @param
* the grid bean type
*/
public static class DetailsManager extends AbstractGridExtension {
private final Set visibleDetails = new HashSet<>();
private final Map components = new HashMap<>();
private DetailsGenerator generator;
/**
* Sets the details component generator.
*
* @param generator
* the generator for details components
*/
public void setDetailsGenerator(DetailsGenerator generator) {
if (this.generator != generator) {
removeAllComponents();
}
getState().hasDetailsGenerator = generator != null;
this.generator = generator;
visibleDetails.forEach(this::refresh);
}
@Override
public void remove() {
removeAllComponents();
super.remove();
}
private void removeAllComponents() {
// Clean up old components
components.values().forEach(this::removeComponentFromGrid);
components.clear();
}
@Override
public void generateData(T item, JsonObject jsonObject) {
if (generator == null || !visibleDetails.contains(item)) {
return;
}
if (!components.containsKey(item)) {
Component detailsComponent = generator.apply(item);
Objects.requireNonNull(detailsComponent,
"Details generator can't create null components");
if (detailsComponent.getParent() != null) {
throw new IllegalStateException(
"Details component was already attached");
}
addComponentToGrid(detailsComponent);
components.put(item, detailsComponent);
}
jsonObject.put(GridState.JSONKEY_DETAILS_VISIBLE,
components.get(item).getConnectorId());
}
@Override
public void destroyData(T item) {
// No clean up needed. Components are removed when hiding details
// and/or changing details generator
}
/**
* Sets the visibility of details component for given item.
*
* @param item
* the item to show details for
* @param visible
* {@code true} if details component should be visible;
* {@code false} if it should be hidden
*/
public void setDetailsVisible(T item, boolean visible) {
boolean refresh = false;
if (!visible) {
refresh = visibleDetails.remove(item);
if (components.containsKey(item)) {
removeComponentFromGrid(components.remove(item));
}
} else {
refresh = visibleDetails.add(item);
}
if (refresh) {
refresh(item);
}
}
/**
* Returns the visibility of details component for given item.
*
* @param item
* the item to show details for
*
* @return {@code true} if details component should be visible;
* {@code false} if it should be hidden
*/
public boolean isDetailsVisible(T item) {
return visibleDetails.contains(item);
}
@Override
public Grid getParent() {
return super.getParent();
}
@Override
protected DetailsManagerState getState() {
return (DetailsManagerState) super.getState();
}
@Override
protected DetailsManagerState getState(boolean markAsDirty) {
return (DetailsManagerState) super.getState(markAsDirty);
}
}
/**
* This extension manages the configuration and data communication for a
* Column inside of a Grid component.
*
* @param
* the grid bean type
* @param
* the column value type
*/
public static class Column extends AbstractExtension {
/**
* Behavior when parsing nested properties which may contain
* null values in the property chain.
*/
public enum NestedNullBehavior {
/**
* Throw a NullPointerException if there is a nested
* null value.
*/
THROW,
/**
* Silently ignore any exceptions caused by nested null
* values.
*/
ALLOW_NULLS
}
private final ValueProvider valueProvider;
private ValueProvider presentationProvider;
private SortOrderProvider sortOrderProvider = direction -> {
String id = getId();
if (id == null) {
return Stream.empty();
}
return Stream.of(new QuerySortOrder(id, direction));
};
private NestedNullBehavior nestedNullBehavior = NestedNullBehavior.THROW;
private boolean sortable = true;
private SerializableComparator comparator;
private StyleGenerator styleGenerator = item -> null;
private DescriptionGenerator descriptionGenerator;
private DataGenerator dataGenerator = new DataGenerator() {
@Override
public void generateData(T item, JsonObject jsonObject) {
ColumnState state = getState(false);
String communicationId = getConnectorId();
assert communicationId != null : "No communication ID set for column "
+ state.caption;
JsonObject obj = getDataObject(jsonObject,
DataCommunicatorConstants.DATA);
obj.put(communicationId, generateRendererValue(item,
presentationProvider, state.renderer));
String style = styleGenerator.apply(item);
if (style != null && !style.isEmpty()) {
JsonObject styleObj = getDataObject(jsonObject,
GridState.JSONKEY_CELLSTYLES);
styleObj.put(communicationId, style);
}
if (descriptionGenerator != null) {
String description = descriptionGenerator.apply(item);
if (description != null && !description.isEmpty()) {
JsonObject descriptionObj = getDataObject(jsonObject,
GridState.JSONKEY_CELLDESCRIPTION);
descriptionObj.put(communicationId, description);
}
}
}
@Override
public void destroyData(T item) {
removeComponent(getGrid().getDataProvider().getId(item));
}
@Override
public void destroyAllData() {
// Make a defensive copy of keys, as the map gets cleared when
// removing components.
new HashSet<>(activeComponents.keySet())
.forEach(component -> removeComponent(component));
}
};
private Binding editorBinding;
private Map activeComponents = new HashMap<>();
private String userId;
/**
* Constructs a new Column configuration with given renderer and value
* provider.
*
* @param valueProvider
* the function to get values from items, not
* null
* @param renderer
* the value renderer, not null
*/
protected Column(ValueProvider valueProvider,
Renderer renderer) {
this(valueProvider, ValueProvider.identity(), renderer);
}
/**
* Constructs a new Column configuration with given renderer and value
* provider.
*
* For a more complete explanation on presentation provider, see
* {@link #setRenderer(ValueProvider, Renderer)}.
*
* @param valueProvider
* the function to get values from items, not
* null
* @param presentationProvider
* the function to get presentations from the value of this
* column, not null. For more details, see
* {@link #setRenderer(ValueProvider, Renderer)}
* @param renderer
* the presentation renderer, not null
* @param
* the presentation type
*
* @since 8.1
*/
protected
Column(ValueProvider valueProvider,
ValueProvider presentationProvider,
Renderer renderer) {
Objects.requireNonNull(valueProvider,
"Value provider can't be null");
Objects.requireNonNull(presentationProvider,
"Presentation provider can't be null");
Objects.requireNonNull(renderer, "Renderer can't be null");
ColumnState state = getState();
this.valueProvider = valueProvider;
this.presentationProvider = presentationProvider;
state.renderer = renderer;
state.caption = "";
// Add the renderer as a child extension of this extension, thus
// ensuring the renderer will be unregistered when this column is
// removed
addExtension(renderer);
Class valueType = renderer.getPresentationType();
if (Comparable.class.isAssignableFrom(valueType)) {
comparator = (a, b) -> compareComparables(
valueProvider.apply(a), valueProvider.apply(b));
} else if (Number.class.isAssignableFrom(valueType)) {
/*
* Value type will be Number whenever using NumberRenderer.
* Provide explicit comparison support in this case even though
* Number itself isn't Comparable.
*/
comparator = (a, b) -> compareNumbers(
(Number) valueProvider.apply(a),
(Number) valueProvider.apply(b));
} else {
comparator = (a, b) -> compareMaybeComparables(
valueProvider.apply(a), valueProvider.apply(b));
}
}
/**
* Constructs a new Column configuration with given renderer and value
* provider.
*
* For a more complete explanation on presentation provider, see
* {@link #setRenderer(ValueProvider, Renderer)}.
*
* @param valueProvider
* the function to get values from items, not
* null
* @param presentationProvider
* the function to get presentations from the value of this
* column, not null. For more details, see
* {@link #setRenderer(ValueProvider, Renderer)}
* @param nestedNullBehavior
* behavior on encountering nested null values
* when reading the value from the bean
* @param renderer
* the presentation renderer, not null
* @param
* the presentation type
*
* @since 8.8
*/
protected
Column(ValueProvider valueProvider,
ValueProvider presentationProvider,
Renderer renderer,
NestedNullBehavior nestedNullBehavior) {
this(valueProvider, presentationProvider, renderer);
this.nestedNullBehavior = nestedNullBehavior;
}
private static int compareMaybeComparables(Object a, Object b) {
if (hasCommonComparableBaseType(a, b)) {
return compareComparables(a, b);
}
return compareComparables(Objects.toString(a, ""),
Objects.toString(b, ""));
}
private static boolean hasCommonComparableBaseType(Object a, Object b) {
if (a instanceof Comparable && b instanceof Comparable) {
Class aClass = a.getClass();
Class bClass = b.getClass();
if (aClass == bClass) {
return true;
}
Class baseType = ReflectTools.findCommonBaseType(aClass,
bClass);
if (Comparable.class.isAssignableFrom(baseType)) {
return true;
}
}
if ((a == null && b instanceof Comparable)
|| (b == null && a instanceof Comparable)) {
return true;
}
return false;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
private static int compareComparables(Object a, Object b) {
return ((Comparator) Comparator
.nullsLast(Comparator.naturalOrder())).compare(a, b);
}
@SuppressWarnings("unchecked")
private static int compareNumbers(Number a, Number b) {
Number valueA = a != null ? a : Double.POSITIVE_INFINITY;
Number valueB = b != null ? b : Double.POSITIVE_INFINITY;
// Most Number implementations are Comparable
if (valueA instanceof Comparable
&& valueA.getClass().isInstance(valueB)) {
return ((Comparable) valueA).compareTo(valueB);
}
if (valueA.equals(valueB)) {
return 0;
}
// Fall back to comparing based on potentially truncated values
int compare = Long.compare(valueA.longValue(), valueB.longValue());
if (compare == 0) {
// This might still produce 0 even though the values are not
// equals, but there's nothing more we can do about that
compare = Double.compare(valueA.doubleValue(),
valueB.doubleValue());
}
return compare;
}
@SuppressWarnings("unchecked")
private JsonValue generateRendererValue(T item,
ValueProvider presentationProvider, Connector renderer) {
V value;
try {
value = valueProvider.apply(item);
} catch (NullPointerException npe) {
value = null;
if (NestedNullBehavior.THROW == nestedNullBehavior) {
throw npe;
}
}
P presentationValue = presentationProvider.apply(value);
// Make Grid track components.
if (renderer instanceof ComponentRenderer
&& presentationValue instanceof Component) {
addComponent(getGrid().getDataProvider().getId(item),
(Component) presentationValue);
}
return ((Renderer) renderer).encode(presentationValue);
}
private void addComponent(Object item, Component component) {
if (activeComponents.containsKey(item)) {
if (activeComponents.get(item).equals(component)) {
// Reusing old component
return;
}
removeComponent(item);
}
activeComponents.put(item, component);
getGrid().addExtensionComponent(component);
}
private void removeComponent(Object item) {
Component component = activeComponents.remove(item);
if (component != null) {
getGrid().removeExtensionComponent(component);
}
}
/**
* Gets a data object with the given key from the given JsonObject. If
* there is no object with the key, this method creates a new
* JsonObject.
*
* @param jsonObject
* the json object
* @param key
* the key where the desired data object is stored
* @return data object for the given key
*/
private JsonObject getDataObject(JsonObject jsonObject, String key) {
if (!jsonObject.hasKey(key)) {
jsonObject.put(key, Json.createObject());
}
return jsonObject.getObject(key);
}
@Override
protected ColumnState getState() {
return getState(true);
}
@Override
protected ColumnState getState(boolean markAsDirty) {
return (ColumnState) super.getState(markAsDirty);
}
/**
* This method extends the given Grid with this Column.
*
* @param grid
* the grid to extend
*/
private void extend(Grid grid) {
super.extend(grid);
}
/**
* Returns the identifier used with this Column in communication.
*
* @return the identifier string
*/
private String getInternalId() {
return getState(false).internalId;
}
/**
* Sets the identifier to use with this Column in communication.
*
* @param id
* the identifier string
*/
private void setInternalId(String id) {
Objects.requireNonNull(id, "Communication ID can't be null");
getState().internalId = id;
}
/**
* Returns the user-defined identifier for this column.
*
* @return the identifier string
*/
public String getId() {
return userId;
}
/**
* Sets the user-defined identifier to map this column. The identifier
* can be used for example in {@link Grid#getColumn(String)}.
*
* The id is also used as the {@link #setSortProperty(String...) backend
* sort property} for this column if no sort property or sort order
* provider has been set for this column.
*
* @see #setSortProperty(String...)
* @see #setSortOrderProvider(SortOrderProvider)
*
* @param id
* the identifier string
* @return this column
*/
public Column setId(String id) {
Objects.requireNonNull(id, "Column identifier cannot be null");
if (userId != null) {
throw new IllegalStateException(
"Column identifier cannot be changed");
}
userId = id;
getGrid().setColumnId(id, this);
updateSortable();
return this;
}
private void updateSortable() {
boolean inMemory = getGrid().getDataProvider().isInMemory();
boolean hasSortOrder = getSortOrder(SortDirection.ASCENDING)
.count() != 0;
getState().sortable = this.sortable && (inMemory || hasSortOrder);
}
/**
* Gets the function used to produce the value for data in this column
* based on the row item.
*
* @return the value provider function
*
* @since 8.0.3
*/
public ValueProvider getValueProvider() {
return valueProvider;
}
/**
* Gets the function to get presentations from the value of data in this
* column, based on the row item.
*
* @return the presentation provider function
*
* @since 8.13
*/
public ValueProvider getPresentationProvider() {
return presentationProvider;
}
/**
* Sets whether the user can sort this column or not. Whether the column
* is actually sortable after {@code setSortable(true)} depends on the
* {@link DataProvider} and the defined sort order for this column. When
* using an {@link InMemoryDataProvider} sorting can be automatic.
*
* @param sortable
* {@code true} to enable sorting for this column;
* {@code false} to disable it
* @return this column
*/
public Column setSortable(boolean sortable) {
if (this.sortable != sortable) {
this.sortable = sortable;
updateSortable();
}
return this;
}
/**
* Gets whether sorting is enabled for this column.
*
* @return {@code true} if the sorting is enabled for this column;
* {@code false} if not
*/
public boolean isSortable() {
return sortable;
}
/**
* Gets whether the user can actually sort this column.
*
* @return {@code true} if the column can be sorted by the user;
* {@code false} if not
*
* @since 8.3.2
*/
public boolean isSortableByUser() {
return getState(false).sortable;
}
/**
* Sets the header aria-label for this column.
*
* @param caption
* the header aria-label, null removes the aria-label from
* this column
*
* @return this column
*
* @since 8.2
*/
public Column setAssistiveCaption(String caption) {
if (Objects.equals(caption, getAssistiveCaption())) {
return this;
}
getState().assistiveCaption = caption;
return this;
}
/**
* Gets the header caption for this column.
*
* @return header caption
*
* @since 8.2
*/
public String getAssistiveCaption() {
return getState(false).assistiveCaption;
}
/**
* Sets the header caption for this column.
*
* @param caption
* the header caption, not null
*
* @return this column
*/
public Column setCaption(String caption) {
Objects.requireNonNull(caption, "Header caption can't be null");
caption = Jsoup.parse(caption).text();
if (caption.equals(getState(false).caption)) {
return this;
}
getState().caption = caption;
HeaderRow row = getGrid().getDefaultHeaderRow();
if (row != null) {
row.getCell(this).setText(caption);
}
return this;
}
/**
* Gets the header caption for this column.
*
* @return header caption
*/
public String getCaption() {
return getState(false).caption;
}
/**
* Sets a comparator to use with in-memory sorting with this column.
* Sorting with a back-end is done using
* {@link Column#setSortProperty(String...)}.
*
* @param comparator
* the comparator to use when sorting data in this column
* @return this column
*/
public Column setComparator(
SerializableComparator comparator) {
Objects.requireNonNull(comparator, "Comparator can't be null");
this.comparator = comparator;
return this;
}
/**
* Gets the comparator to use with in-memory sorting for this column
* when sorting in the given direction.
*
* @param sortDirection
* the direction this column is sorted by
* @return comparator for this column
*/
public SerializableComparator getComparator(
SortDirection sortDirection) {
Objects.requireNonNull(comparator,
"No comparator defined for sorted column.");
boolean reverse = sortDirection != SortDirection.ASCENDING;
return reverse ? (t1, t2) -> comparator.reversed().compare(t1, t2)
: comparator;
}
/**
* Sets strings describing back end properties to be used when sorting
* this column.
*
* By default, the {@link #setId(String) column id} will be used as the
* sort property.
*
* @param properties
* the array of strings describing backend properties
* @return this column
*/
public Column setSortProperty(String... properties) {
Objects.requireNonNull(properties, "Sort properties can't be null");
return setSortOrderProvider(dir -> Arrays.stream(properties)
.map(s -> new QuerySortOrder(s, dir)));
}
/**
* Sets the sort orders when sorting this column. The sort order
* provider is a function which provides {@link QuerySortOrder} objects
* to describe how to sort by this column.
*
* By default, the {@link #setId(String) column id} will be used as the
* sort property.
*
* @param provider
* the function to use when generating sort orders with the
* given direction
* @return this column
*/
public Column setSortOrderProvider(SortOrderProvider provider) {
Objects.requireNonNull(provider,
"Sort order provider can't be null");
sortOrderProvider = provider;
// Update state
updateSortable();
return this;
}
/**
* Gets the sort orders to use with back-end sorting for this column
* when sorting in the given direction.
*
* @see #setSortProperty(String...)
* @see #setId(String)
* @see #setSortOrderProvider(SortOrderProvider)
*
* @param direction
* the sorting direction
* @return stream of sort orders
*/
public Stream getSortOrder(SortDirection direction) {
return sortOrderProvider.apply(direction);
}
/**
* Sets the style generator that is used for generating class names for
* cells in this column. Returning null from the generator results in no
* custom style name being set.
*
* Note: The style generator is applied only to the body cells, not to
* the Editor.
*
* @param cellStyleGenerator
* the cell style generator to set, not null
* @return this column
* @throws NullPointerException
* if {@code cellStyleGenerator} is {@code null}
*/
public Column setStyleGenerator(
StyleGenerator cellStyleGenerator) {
Objects.requireNonNull(cellStyleGenerator,
"Cell style generator must not be null");
this.styleGenerator = cellStyleGenerator;
getGrid().getDataCommunicator().reset();
return this;
}
/**
* Gets the style generator that is used for generating styles for
* cells.
*
* @return the cell style generator
*/
public StyleGenerator getStyleGenerator() {
return styleGenerator;
}
/**
* Sets the description generator that is used for generating
* descriptions for cells in this column. This method uses the
* {@link ContentMode#PREFORMATTED} content mode.
*
* @see #setDescriptionGenerator(DescriptionGenerator, ContentMode)
*
* @param cellDescriptionGenerator
* the cell description generator to set, or {@code null} to
* remove a previously set generator
* @return this column
*/
public Column setDescriptionGenerator(
DescriptionGenerator cellDescriptionGenerator) {
return setDescriptionGenerator(cellDescriptionGenerator,
ContentMode.PREFORMATTED);
}
/**
* Sets the description generator that is used for generating
* descriptions for cells in this column. This method uses the given
* content mode.
*
* @see #setDescriptionGenerator(DescriptionGenerator)
*
* @param cellDescriptionGenerator
* the cell description generator to set, or {@code null} to
* remove a previously set generator
* @param tooltipContentMode
* the content mode for tooltips
* @return this column
*
* @since 8.2
*/
public Column setDescriptionGenerator(
DescriptionGenerator cellDescriptionGenerator,
ContentMode tooltipContentMode) {
this.descriptionGenerator = cellDescriptionGenerator;
getState().tooltipContentMode = tooltipContentMode;
getGrid().getDataCommunicator().reset();
return this;
}
/**
* Gets the description generator that is used for generating
* descriptions for cells.
*
* @return the cell description generator, or null if no
* generator is set
*/
public DescriptionGenerator getDescriptionGenerator() {
return descriptionGenerator;
}
/**
* Sets the ratio with which the column expands.
*
* By default, all columns expand equally (treated as if all of them had
* an expand ratio of 1). Once at least one column gets a defined expand
* ratio, the implicit expand ratio is removed, and only the defined
* expand ratios are taken into account.
*
* If a column has a defined width ({@link #setWidth(double)}), it
* overrides this method's effects.
*
* Example: A grid with three columns, with expand ratios 0, 1
* and 2, respectively. The column with a ratio of 0 is exactly
* as wide as its contents requires. The column with a ratio of
* 1 is as wide as it needs, plus a third of any excess
* space, because we have 3 parts total, and this column
* reserves only one of those. The column with a ratio of 2, is as wide
* as it needs to be, plus two thirds of the excess
* width.
*
* @param expandRatio
* the expand ratio of this column. {@code 0} to not have it
* expand at all. A negative number to clear the expand
* value.
* @return this column
* @throws IllegalStateException
* if the column is no longer attached to any grid
* @see #setWidth(double)
*/
public Column setExpandRatio(int expandRatio)
throws IllegalStateException {
checkColumnIsAttached();
if (expandRatio != getExpandRatio()) {
getState().expandRatio = expandRatio;
getGrid().markAsDirty();
}
return this;
}
/**
* Returns the column's expand ratio.
*
* @return the column's expand ratio
* @see #setExpandRatio(int)
*/
public int getExpandRatio() {
return getState(false).expandRatio;
}
/**
* Clears the expand ratio for this column.
*
* Equal to calling {@link #setExpandRatio(int) setExpandRatio(-1)}
*
* @return this column
* @throws IllegalStateException
* if the column is no longer attached to any grid
*/
public Column clearExpandRatio() throws IllegalStateException {
return setExpandRatio(-1);
}
/**
* Returns the width (in pixels). By default a column width is
* {@value com.vaadin.shared.ui.grid.GridConstants#DEFAULT_COLUMN_WIDTH_PX}
* (undefined).
*
* @return the width in pixels of the column
* @throws IllegalStateException
* if the column is no longer attached to any grid
*/
public double getWidth() throws IllegalStateException {
checkColumnIsAttached();
return getState(false).width;
}
/**
* Sets the width (in pixels).
*
* This overrides any configuration set by any of
* {@link #setExpandRatio(int)}, {@link #setMinimumWidth(double)} or
* {@link #setMaximumWidth(double)}.
*
* @param pixelWidth
* the new pixel width of the column
* @return the column itself
*
* @throws IllegalStateException
* if the column is no longer attached to any grid
* @throws IllegalArgumentException
* thrown if pixel width is less than zero
*/
public Column setWidth(double pixelWidth)
throws IllegalStateException, IllegalArgumentException {
checkColumnIsAttached();
if (pixelWidth < 0) {
throw new IllegalArgumentException(
"Pixel width should be greated than 0 (in " + toString()
+ ")");
}
if (pixelWidth != getWidth()) {
getState().width = pixelWidth;
getGrid().markAsDirty();
getGrid().fireColumnResizeEvent(this, false);
}
return this;
}
/**
* Returns whether this column has an undefined width.
*
* @since 7.6
* @return whether the width is undefined
* @throws IllegalStateException
* if the column is no longer attached to any grid
*/
public boolean isWidthUndefined() {
checkColumnIsAttached();
return getState(false).width < 0;
}
/**
* Marks the column width as undefined. An undefined width means the
* grid is free to resize the column based on the cell contents and
* available space in the grid.
*
* @return the column itself
*/
public Column setWidthUndefined() {
checkColumnIsAttached();
if (!isWidthUndefined()) {
getState().width = -1;
getGrid().markAsDirty();
getGrid().fireColumnResizeEvent(this, false);
}
return this;
}
/**
* Sets the minimum width for this column.
*
* This defines the minimum guaranteed pixel width of the column
* when it is set to expand.
*
* Note: Value -1 is not accepted, use {@link #setWidthUndefined()}
* instead.
*
* @param pixels
* the minimum width for the column
* @throws IllegalStateException
* if the column is no longer attached to any grid
* @see #setExpandRatio(int)
* @return the column itself
*/
public Column setMinimumWidth(double pixels)
throws IllegalStateException {
checkColumnIsAttached();
final double maxwidth = getMaximumWidth();
if (pixels >= 0 && pixels > maxwidth && maxwidth >= 0) {
throw new IllegalArgumentException("New minimum width ("
+ pixels + ") was greater than maximum width ("
+ maxwidth + ")");
}
getState().minWidth = pixels;
getGrid().markAsDirty();
return this;
}
/**
* Return the minimum width for this column.
*
* @return the minimum width for this column
* @see #setMinimumWidth(double)
*/
public double getMinimumWidth() {
return getState(false).minWidth;
}
/**
* Sets whether the width of the contents in the column should be
* considered minimum width for this column.
*
* If this is set to true (default for backwards
* compatibility), then a column will not shrink to smaller than the
* width required to show the contents available when calculating the
* widths (only the widths of the initially rendered rows are
* considered).
*
* If this is set to false and the column has been set to
* expand using #setExpandRatio(int), then the contents of the column
* will be ignored when calculating the width, and the column will thus
* shrink down to the minimum width defined by #setMinimumWidth(double)
* if necessary.
*
* @param minimumWidthFromContent
* true to reserve space for all contents,
* false to allow the column to shrink smaller
* than the contents
* @return the column itself
* @throws IllegalStateException
* if the column is no longer attached to any grid
* @see #setMinimumWidth(double)
* @since 8.1
*/
public Column setMinimumWidthFromContent(
boolean minimumWidthFromContent) throws IllegalStateException {
checkColumnIsAttached();
if (isMinimumWidthFromContent() != minimumWidthFromContent) {
getState().minimumWidthFromContent = minimumWidthFromContent;
getGrid().markAsDirty();
}
return this;
}
/**
* Gets whether the width of the contents in the column should be
* considered minimum width for this column.
*
* @return true to reserve space for all contents,
* false to allow the column to shrink smaller than
* the contents
* @see #setMinimumWidthFromContent(boolean)
* @since 8.1
*/
public boolean isMinimumWidthFromContent() {
return getState(false).minimumWidthFromContent;
}
/**
* Sets the maximum width for this column.
*
* This defines the maximum allowed pixel width of the column when
* it is set to expand.
*
* @param pixels
* the maximum width
* @return this column
* @throws IllegalStateException
* if the column is no longer attached to any grid
* @see #setExpandRatio(int)
*/
public Column setMaximumWidth(double pixels) {
checkColumnIsAttached();
final double minwidth = getMinimumWidth();
if (pixels >= 0 && pixels < minwidth && minwidth >= 0) {
throw new IllegalArgumentException("New maximum width ("
+ pixels + ") was less than minimum width (" + minwidth
+ ")");
}
getState().maxWidth = pixels;
getGrid().markAsDirty();
return this;
}
/**
* Returns the maximum width for this column.
*
* @return the maximum width for this column
* @see #setMaximumWidth(double)
*/
public double getMaximumWidth() {
return getState(false).maxWidth;
}
/**
* Sets whether this column can be resized by the user.
*
* @since 7.6
* @param resizable
* {@code true} if this column should be resizable,
* {@code false} otherwise
* @return this column
* @throws IllegalStateException
* if the column is no longer attached to any grid
*/
public Column setResizable(boolean resizable) {
checkColumnIsAttached();
if (resizable != isResizable()) {
getState().resizable = resizable;
getGrid().markAsDirty();
}
return this;
}
/**
* Gets the caption of the hiding toggle for this column.
*
* @since 7.5.0
* @see #setHidingToggleCaption(String)
* @return the caption for the hiding toggle for this column
*/
public String getHidingToggleCaption() {
return getState(false).hidingToggleCaption;
}
/**
* Sets the caption of the hiding toggle for this column. Shown in the
* toggle for this column in the grid's sidebar when the column is
* {@link #isHidable() hidable}.
*
* The default value is null, and in that case the column's
* {@link #getCaption() header caption} is used.
*
* NOTE: setting this to empty string might cause the hiding
* toggle to not render correctly.
*
* @since 7.5.0
* @param hidingToggleCaption
* the text to show in the column hiding toggle
* @return the column itself
*/
public Column setHidingToggleCaption(String hidingToggleCaption) {
if (hidingToggleCaption != getHidingToggleCaption()) {
getState().hidingToggleCaption = hidingToggleCaption;
}
return this;
}
/**
* Hides or shows the column. By default columns are visible before
* explicitly hiding them.
*
* @since 7.5.0
* @param hidden
* true to hide the column, false
* to show
* @return this column
* @throws IllegalStateException
* if the column is no longer attached to any grid
*/
public Column setHidden(boolean hidden) {
checkColumnIsAttached();
if (hidden != isHidden()) {
getState().hidden = hidden;
getGrid().fireColumnVisibilityChangeEvent(this, hidden, false);
}
return this;
}
/**
* Returns whether this column is hidden. Default is {@code false}.
*
* @since 7.5.0
* @return true if the column is currently hidden,
* false otherwise
*/
public boolean isHidden() {
return getState(false).hidden;
}
/**
* Sets whether this column can be hidden by the user. Hidable columns
* can be hidden and shown via the sidebar menu.
*
* @since 7.5.0
* @param hidable
* true if the column may be hidable by the user
* via UI interaction
* @return this column
*/
public Column setHidable(boolean hidable) {
if (hidable != isHidable()) {
getState().hidable = hidable;
}
return this;
}
/**
* Returns whether this column can be hidden by the user. Default is
* {@code false}.
*
* Note: the column can be programmatically hidden using
* {@link #setHidden(boolean)} regardless of the returned value.
*
* @since 7.5.0
* @return true if the user can hide the column,
* false if not
*/
public boolean isHidable() {
return getState(false).hidable;
}
/**
* Returns whether this column can be resized by the user. Default is
* {@code true}.
*
* Note: the column can be programmatically resized using
* {@link #setWidth(double)} and {@link #setWidthUndefined()} regardless
* of the returned value.
*
* @since 7.6
* @return {@code true} if this column is resizable, {@code false}
* otherwise
*/
public boolean isResizable() {
return getState(false).resizable;
}
/**
* Sets whether this Column has a component displayed in Editor or not.
* A column can only be editable if an editor component or binding has
* been set.
*
* @param editable
* {@code true} if column is editable; {@code false} if not
* @return this column
* @throws IllegalStateException
* if editable is true and column has no editor binding or
* component defined
*
* @see #setEditorComponent(HasValue, Setter)
* @see #setEditorBinding(Binding)
*/
public Column setEditable(boolean editable)
throws IllegalStateException {
if (editable && editorBinding == null) {
throw new IllegalStateException(
"Column has no editor binding or component defined");
}
getState().editable = editable;
return this;
}
/**
* Gets whether this Column has a component displayed in Editor or not.
*
* @return {@code true} if the column displays an editor component;
* {@code false} if not
*/
public boolean isEditable() {
return getState(false).editable;
}
/**
* Sets an editor binding for this column. The {@link Binding} is used
* when a row is in editor mode to define how to populate an editor
* component based on the edited row and how to update an item based on
* the value in the editor component.
*
* To create a binding to use with a column, define a binding for the
* editor binder (grid.getEditor().getBinder()) using e.g.
* {@link Binder#forField(HasValue)}. You can also use
* {@link #setEditorComponent(HasValue, Setter)} if no validator or
* converter is needed for the binding.
*
* The {@link HasValue} that the binding is defined to use must be a
* {@link Component}.
*
* @param binding
* the binding to use for this column
* @return this column
*
* @see #setEditorComponent(HasValue, Setter)
* @see Binding
* @see Grid#getEditor()
* @see Editor#getBinder()
*/
public Column setEditorBinding(Binding binding) {
Objects.requireNonNull(binding, "null is not a valid editor field");
if (!(binding.getField() instanceof Component)) {
throw new IllegalArgumentException(
"Binding target must be a component.");
}
this.editorBinding = binding;
return setEditable(true);
}
/**
* Gets the binder binding that is currently used for this column.
*
* @return the used binder binding, or null if no binding
* is configured
*
* @see #setEditorBinding(Binding)
*/
public Binding getEditorBinding() {
return editorBinding;
}
/**
* Sets a component and setter to use for editing values of this column
* in the editor row. This is a shorthand for use in simple cases where
* no validator or converter is needed. Use
* {@link #setEditorBinding(Binding)} to support more complex cases.
*
* Note: The same component cannot be used for multiple
* columns.
*
* @param
* a class that extends both {@link HasValue} and
* {@link Component}
* @param editorComponent
* the editor component
* @param setter
* a setter that stores the component value in the row item
* @return this column
*
* @see #setEditorBinding(Binding)
* @see Grid#getEditor()
* @see Binder#bind(HasValue, ValueProvider, Setter)
*/
public & Component> Column setEditorComponent(
C editorComponent, Setter setter) {
Objects.requireNonNull(editorComponent,
"Editor component cannot be null");
Objects.requireNonNull(setter, "Setter cannot be null");
Binding binding = getGrid().getEditor().getBinder()
.bind(editorComponent, valueProvider::apply, setter);
return setEditorBinding(binding);
}
/**
* Sets a component to use for editing values of this columns in the
* editor row. This method can only be used if the column has an
* {@link #setId(String) id} and the {@link Grid} has been created using
* {@link Grid#Grid(Class)} or some other way that allows finding
* properties based on property names.
*
* This is a shorthand for use in simple cases where no validator or
* converter is needed. Use {@link #setEditorBinding(Binding)} to
* support more complex cases.
*
* Note: The same component cannot be used for multiple
* columns.
*
* @param
* a value type
* @param
* a class that extends both {@link HasValue} (for type
* {@code }) and {@link Component}
* @param editorComponent
* the editor component
* @return this column
*
* @see #setEditorBinding(Binding)
* @see Grid#getEditor()
* @see Binder#bind(HasValue, String)
* @see Grid#Grid(Class)
*/
public & Component> Column setEditorComponent(
C editorComponent) {
Objects.requireNonNull(editorComponent,
"Editor component cannot be null");
String propertyName = getId();
if (propertyName == null) {
throw new IllegalStateException(
"setEditorComponent without a setter can only be used if the column has an id. "
+ "Use another setEditorComponent(Component, Setter) or setEditorBinding(Binding) instead.");
}
Binding binding = getGrid().getEditor().getBinder()
.bind(editorComponent, propertyName);
return setEditorBinding(binding);
}
/**
* Sets the Renderer for this Column. Setting the renderer will cause
* all currently available row data to be recreated and sent to the
* client.
*
* Note: Setting a new renderer will reset presentation provider if it
* exists.
*
* @param renderer
* the new renderer
* @return this column
*
* @since 8.0.3
*/
public Column setRenderer(Renderer renderer) {
return setRenderer(ValueProvider.identity(), renderer);
}
/**
* Sets the Renderer for this Column. Setting the renderer will cause
* all currently available row data to be recreated and sent to the
* client.
*
* The presentation provider is a method that takes the value of this
* column on a single row, and maps that to a value that the renderer
* accepts. This feature can be used for storing a complex value in a
* column for editing, but providing a simplified presentation for the
* user when not editing.
*
* @param presentationProvider
* the function to get presentations from the value of this
* column, not {@code null}
* @param renderer
* the new renderer, not {@code null}
*
* @param
* the presentation type
*
* @return this column
*
* @since 8.1
*/
public
Column setRenderer(
ValueProvider presentationProvider,
Renderer renderer) {
Objects.requireNonNull(renderer, "Renderer can not be null");
Objects.requireNonNull(presentationProvider,
"Presentation provider can not be null");
// Remove old renderer
Connector oldRenderer = getState().renderer;
if (oldRenderer instanceof Extension) {
removeExtension((Extension) oldRenderer);
}
// Set new renderer
getState().renderer = renderer;
addExtension(renderer);
this.presentationProvider = presentationProvider;
// Trigger redraw
getGrid().getDataCommunicator().reset();
return this;
}
/**
* Gets the Renderer for this Column.
*
* @return the renderer
* @since 8.1
*/
public Renderer getRenderer() {
return (Renderer) getState().renderer;
}
/**
* Sets whether Grid should handle events in this Column from Components
* and Widgets rendered by certain Renderers. By default the events are
* not handled.
*
* Note: Enabling this feature will for example select
* a row when a component is clicked. For example in the case of a
* {@link ComboBox} or {@link TextField} it might be problematic as the
* component gets re-rendered and might lose focus.
*
* @param handleWidgetEvents
* {@code true} to handle events; {@code false} to not
* @return this column
* @since 8.3
*/
public Column setHandleWidgetEvents(boolean handleWidgetEvents) {
getState().handleWidgetEvents = handleWidgetEvents;
return this;
}
/**
* Gets whether Grid is handling the events in this Column from
* Component and Widgets.
*
* @see #setHandleWidgetEvents(boolean)
*
* @return {@code true} if handling events; {@code false} if not
* @since 8.3
*/
public boolean isHandleWidgetEvents() {
return getState(false).handleWidgetEvents;
}
/**
* Gets the grid that this column belongs to.
*
* @return the grid that this column belongs to, or null if
* this column has not yet been associated with any grid
*/
@SuppressWarnings("unchecked")
protected Grid getGrid() {
return (Grid) getParent();
}
/**
* Checks if column is attached and throws an
* {@link IllegalStateException} if it is not.
*
* @throws IllegalStateException
* if the column is no longer attached to any grid
*/
protected void checkColumnIsAttached() throws IllegalStateException {
if (getGrid() == null) {
throw new IllegalStateException(
"Column is no longer attached to a grid.");
}
}
/**
* Writes the design attributes for this column into given element.
*
* @since 7.5.0
*
* @param element
* Element to write attributes into
*
* @param designContext
* the design context
*/
protected void writeDesign(Element element,
DesignContext designContext) {
Attributes attributes = element.attributes();
ColumnState defaultState = new ColumnState();
if (getId() == null) {
setId("column" + getGrid().getColumns().indexOf(this));
}
DesignAttributeHandler.writeAttribute("column-id", attributes,
getId(), null, String.class, designContext);
// Sortable is a special attribute that depends on the data
// provider.
DesignAttributeHandler.writeAttribute("sortable", attributes,
isSortable(), null, boolean.class, designContext);
DesignAttributeHandler.writeAttribute("editable", attributes,
isEditable(), defaultState.editable, boolean.class,
designContext);
DesignAttributeHandler.writeAttribute("resizable", attributes,
isResizable(), defaultState.resizable, boolean.class,
designContext);
DesignAttributeHandler.writeAttribute("hidable", attributes,
isHidable(), defaultState.hidable, boolean.class,
designContext);
DesignAttributeHandler.writeAttribute("hidden", attributes,
isHidden(), defaultState.hidden, boolean.class,
designContext);
DesignAttributeHandler.writeAttribute("hiding-toggle-caption",
attributes, getHidingToggleCaption(),
defaultState.hidingToggleCaption, String.class,
designContext);
DesignAttributeHandler.writeAttribute("width", attributes,
getWidth(), defaultState.width, Double.class,
designContext);
DesignAttributeHandler.writeAttribute("min-width", attributes,
getMinimumWidth(), defaultState.minWidth, Double.class,
designContext);
DesignAttributeHandler.writeAttribute("max-width", attributes,
getMaximumWidth(), defaultState.maxWidth, Double.class,
designContext);
DesignAttributeHandler.writeAttribute("expand", attributes,
getExpandRatio(), defaultState.expandRatio, Integer.class,
designContext);
}
/**
* Reads the design attributes for this column from given element.
*
* @since 7.5.0
* @param design
* Element to read attributes from
* @param designContext
* the design context
*/
@SuppressWarnings("unchecked")
protected void readDesign(Element design, DesignContext designContext) {
Attributes attributes = design.attributes();
if (design.hasAttr("sortable")) {
setSortable(DesignAttributeHandler.readAttribute("sortable",
attributes, boolean.class));
} else {
setSortable(false);
}
if (design.hasAttr("editable")) {
/**
* This is a fake editor just to have something (otherwise
* "setEditable" throws an exception.
*
* Let's use TextField here because we support only Strings as
* inline data type. It will work incorrectly for other types
* but we don't support them anyway.
*/
setEditorComponent((HasValue & Component) new TextField(),
(item, value) -> {
// Ignore user value since we don't know the setter
});
setEditable(DesignAttributeHandler.readAttribute("editable",
attributes, boolean.class));
}
if (design.hasAttr("resizable")) {
setResizable(DesignAttributeHandler.readAttribute("resizable",
attributes, boolean.class));
}
if (design.hasAttr("hidable")) {
setHidable(DesignAttributeHandler.readAttribute("hidable",
attributes, boolean.class));
}
if (design.hasAttr("hidden")) {
setHidden(DesignAttributeHandler.readAttribute("hidden",
attributes, boolean.class));
}
if (design.hasAttr("hiding-toggle-caption")) {
setHidingToggleCaption(DesignAttributeHandler.readAttribute(
"hiding-toggle-caption", attributes, String.class));
}
if (design.hasAttr("assistive-caption")) {
setAssistiveCaption(DesignAttributeHandler.readAttribute(
"assistive-caption", attributes, String.class));
}
// Read size info where necessary.
if (design.hasAttr("width")) {
setWidth(DesignAttributeHandler.readAttribute("width",
attributes, Double.class));
}
if (design.hasAttr("min-width")) {
setMinimumWidth(DesignAttributeHandler
.readAttribute("min-width", attributes, Double.class));
}
if (design.hasAttr("max-width")) {
setMaximumWidth(DesignAttributeHandler
.readAttribute("max-width", attributes, Double.class));
}
if (design.hasAttr("expand")) {
if (design.attr("expand").isEmpty()) {
setExpandRatio(1);
} else {
setExpandRatio(DesignAttributeHandler.readAttribute(
"expand", attributes, Integer.class));
}
}
}
/**
* Gets the DataGenerator for this Column.
*
* @return data generator
*/
private DataGenerator getDataGenerator() {
return dataGenerator;
}
}
private class HeaderImpl extends Header {
@Override
protected Grid getGrid() {
return Grid.this;
}
@Override
protected SectionState getState(boolean markAsDirty) {
return Grid.this.getState(markAsDirty).header;
}
@Override
protected Column getColumnByInternalId(String internalId) {
return getGrid().getColumnByInternalId(internalId);
}
@Override
@SuppressWarnings("unchecked")
protected String getInternalIdForColumn(Column column) {
return getGrid().getInternalIdForColumn((Column) column);
}
};
private class FooterImpl extends Footer {
@Override
protected Grid getGrid() {
return Grid.this;
}
@Override
protected SectionState getState(boolean markAsDirty) {
return Grid.this.getState(markAsDirty).footer;
}
@Override
protected Column getColumnByInternalId(String internalId) {
return getGrid().getColumnByInternalId(internalId);
}
@Override
@SuppressWarnings("unchecked")
protected String getInternalIdForColumn(Column column) {
return getGrid().getInternalIdForColumn((Column) column);
}
};
private final Set> columnSet = new LinkedHashSet<>();
private final Map> columnKeys = new HashMap<>();
private final Map> columnIds = new HashMap<>();
private final List> sortOrder = new ArrayList<>();
private final DetailsManager detailsManager;
private final Set extensionComponents = new HashSet<>();
private StyleGenerator styleGenerator = item -> null;
private DescriptionGenerator descriptionGenerator;
private final Header header = new HeaderImpl();
private final Footer footer = new FooterImpl();
private int counter = 0;
private GridSelectionModel selectionModel;
private Editor editor;
private PropertySet propertySet;
private Class beanType = null;
/**
* Creates a new grid without support for creating columns based on property
* names. Use an alternative constructor, such as {@link Grid#Grid(Class)},
* to create a grid that automatically sets up columns based on the type of
* presented data.
*
* @see #Grid(Class)
* @see #withPropertySet(PropertySet)
*/
public Grid() {
this(new DataCommunicator<>());
}
/**
* Creates a new grid that uses reflection based on the provided bean type
* to automatically set up an initial set of columns. All columns will be
* configured using the same {@link Object#toString()} renderer that is used
* by {@link #addColumn(ValueProvider)}.
*
* @param beanType
* the bean type to use, not null
* @see #Grid()
* @see #withPropertySet(PropertySet)
*/
public Grid(Class beanType) {
this(beanType, new DataCommunicator<>());
}
/**
* Creates a new grid that uses custom data communicator and provided bean
* type
*
* It uses reflection of the provided bean type to automatically set up an
* initial set of columns. All columns will be configured using the same
* {@link Object#toString()} renderer that is used by
* {@link #addColumn(ValueProvider)}.
*
* @param beanType
* the bean type to use, not null
* @param dataCommunicator
* the data communicator to use, notnull
* @since 8.0.7
*/
protected Grid(Class beanType, DataCommunicator dataCommunicator) {
this(BeanPropertySet.get(beanType), dataCommunicator);
this.beanType = beanType;
}
/**
* Creates a new grid with the given data communicator and without support
* for creating columns based on property names.
*
* @param dataCommunicator
* the custom data communicator to set
* @see #Grid()
* @see #Grid(PropertySet, DataCommunicator)
* @since 8.0.7
*/
protected Grid(DataCommunicator dataCommunicator) {
this(new PropertySet() {
@Override
public Stream> getProperties() {
// No columns configured by default
return Stream.empty();
}
@Override
public Optional> getProperty(String name) {
throw new IllegalStateException(
"A Grid created without a bean type class literal or a custom property set"
+ " doesn't support finding properties by name.");
}
}, dataCommunicator);
}
/**
* Creates a grid using a custom {@link PropertySet} implementation for
* configuring the initial columns and resolving property names for
* {@link #addColumn(String)} and
* {@link Column#setEditorComponent(HasValue)}.
*
* @see #withPropertySet(PropertySet)
*
* @param propertySet
* the property set implementation to use, not null.
*/
protected Grid(PropertySet propertySet) {
this(propertySet, new DataCommunicator<>());
}
/**
* Creates a grid using a custom {@link PropertySet} implementation and
* custom data communicator.
*
* Property set is used for configuring the initial columns and resolving
* property names for {@link #addColumn(String)} and
* {@link Column#setEditorComponent(HasValue)}.
*
* @see #withPropertySet(PropertySet)
*
* @param propertySet
* the property set implementation to use, not null.
* @param dataCommunicator
* the data communicator to use, notnull
* @since 8.0.7
*/
protected Grid(PropertySet propertySet,
DataCommunicator dataCommunicator) {
super(dataCommunicator);
registerRpc(new GridServerRpcImpl());
setDefaultHeaderRow(appendHeaderRow());
setSelectionModel(new SingleSelectionModelImpl<>());
detailsManager = new DetailsManager<>();
addExtension(detailsManager);
addDataGenerator(detailsManager);
addDataGenerator((item, json) -> {
String styleName = styleGenerator.apply(item);
if (styleName != null && !styleName.isEmpty()) {
json.put(GridState.JSONKEY_ROWSTYLE, styleName);
}
if (descriptionGenerator != null) {
String description = descriptionGenerator.apply(item);
if (description != null && !description.isEmpty()) {
json.put(GridState.JSONKEY_ROWDESCRIPTION, description);
}
}
});
setPropertySet(propertySet);
// Automatically add columns for all available properties
propertySet.getProperties().map(PropertyDefinition::getName)
.forEach(this::addColumn);
}
@Override
public void beforeClientResponse(boolean initial) {
super.beforeClientResponse(initial);
if (initial && editor.isOpen()) {
// Re-attaching grid. Any old editor should be closed.
editor.cancel();
}
}
/**
* Sets the property set to use for this grid. Does not create or update
* columns in any way but will delete and re-create the editor.
*
* This is only meant to be called from constructors and readDesign, at a
* stage where it does not matter if you throw away the editor.
*
* @param propertySet
* the property set to use
*
* @since 8.0.3
*/
protected void setPropertySet(PropertySet propertySet) {
Objects.requireNonNull(propertySet, "propertySet cannot be null");
this.propertySet = propertySet;
if (editor instanceof Extension) {
removeExtension((Extension) editor);
}
editor = createEditor();
if (editor instanceof Extension) {
addExtension((Extension) editor);
}
}
/**
* Returns the property set used by this grid.
*
* @return propertySet the property set to return
* @since 8.4
*/
protected PropertySet getPropertySet() {
return propertySet;
}
/**
* Creates a grid using a custom {@link PropertySet} implementation for
* creating a default set of columns and for resolving property names with
* {@link #addColumn(String)} and
* {@link Column#setEditorComponent(HasValue)}.
*
* This functionality is provided as static method instead of as a public
* constructor in order to make it possible to use a custom property set
* without creating a subclass while still leaving the public constructors
* focused on the common use cases.
*
* @see Grid#Grid()
* @see Grid#Grid(Class)
*
* @param
* the grid bean type
* @param propertySet
* the property set implementation to use, not null.
* @return a new grid using the provided property set, not null
*/
public static Grid withPropertySet(
PropertySet propertySet) {
return new Grid<>(propertySet);
}
/**
* Creates a new {@code Grid} using the given caption.
*
* @param caption
* the caption of the grid
*/
public Grid(String caption) {
this();
setCaption(caption);
}
/**
* Creates a new {@code Grid} using the given caption and
* {@code DataProvider}.
*
* @param caption
* the caption of the grid
* @param dataProvider
* the data provider, not {@code null}
*/
public Grid(String caption, DataProvider dataProvider) {
this(caption);
setDataProvider(dataProvider);
}
/**
* Creates a new {@code Grid} using the given {@code DataProvider}.
*
* @param dataProvider
* the data provider, not {@code null}
*/
public Grid(DataProvider dataProvider) {
this();
setDataProvider(dataProvider);
}
/**
* Creates a new {@code Grid} using the given caption and collection of
* items.
*
* @param caption
* the caption of the grid
* @param items
* the data items to use, not {@code null}
*/
public Grid(String caption, Collection items) {
this(caption, DataProvider.ofCollection(items));
}
/**
* Gets the bean type used by this grid.
*
* The bean type is used to automatically set up a column added using a
* property name.
*
* @return the used bean type or null if no bean type has been
* defined
*
* @since 8.0.3
*/
public Class getBeanType() {
return beanType;
}
/**
* Sends a {@link ColumnVisibilityChangeEvent} to all listeners.
*
* @param
* the column value type
* @param column
* the column that changed its visibility
* @param hidden
* {@code true} if the column was hidden, {@code false} if it
* became visible
* @param userOriginated
* {@code true} if the event was triggered by an UI interaction,
* {@code false} otherwise
*/
public void fireColumnVisibilityChangeEvent(Column column,
boolean hidden, boolean userOriginated) {
fireEvent(new ColumnVisibilityChangeEvent(this, column, hidden,
userOriginated));
}
/**
* Adds a new column with the given property name. The column will use a
* {@link TextRenderer}. The value is converted to a String using
* {@link Object#toString()}. The property name will be used as the
* {@link Column#getId() column id} and the {@link Column#getCaption()
* column caption} will be set based on the property definition.
*
* This method can only be used for a Grid created using
* {@link Grid#Grid(Class)} or {@link #withPropertySet(PropertySet)}.
*
* You can add columns for nested properties with dot notation, eg.
* "property.nestedProperty"
*
* @param propertyName
* the property name of the new column, not null
* @return the newly added column, not null
*/
public Column addColumn(String propertyName) {
return addColumn(propertyName, new TextRenderer());
}
/**
* Adds a new column with the given property name and renderer. The property
* name will be used as the {@link Column#getId() column id} and the
* {@link Column#getCaption() column caption} will be set based on the
* property definition.
*
* This method can only be used for a Grid created using
* {@link Grid#Grid(Class)} or {@link #withPropertySet(PropertySet)}.
*
* You can add columns for nested properties with dot notation, eg.
* "property.nestedProperty"
*
*
* @param propertyName
* the property name of the new column, not null
* @param renderer
* the renderer to use, not null
* @return the newly added column, not null
*/
public Column addColumn(String propertyName,
AbstractRenderer renderer) {
Objects.requireNonNull(propertyName, "Property name cannot be null");
Objects.requireNonNull(renderer, "Renderer cannot be null");
if (getColumn(propertyName) != null) {
throw new IllegalStateException(
"There is already a column for " + propertyName);
}
PropertyDefinition definition = propertySet
.getProperty(propertyName)
.orElseThrow(() -> new IllegalArgumentException(
"Could not resolve property name " + propertyName
+ " from " + propertySet));
if (!renderer.getPresentationType()
.isAssignableFrom(definition.getType())) {
throw new IllegalArgumentException(
renderer + " cannot be used with a property of type "
+ definition.getType().getName());
}
@SuppressWarnings({ "unchecked", "rawtypes" })
Column column = addColumn(definition.getGetter(),
(AbstractRenderer) renderer).setId(definition.getName())
.setCaption(definition.getCaption());
return column;
}
/**
* Adds a new column with the given property name and renderer. The property
* name will be used as the {@link Column#getId() column id} and the
* {@link Column#getCaption() column caption} will be set based on the
* property definition.
*
* This method can only be used for a Grid created using
* {@link Grid#Grid(Class)} or {@link #withPropertySet(PropertySet)}.
*
* You can add columns for nested properties with dot notation, eg.
* "property.nestedProperty"
*
* @param propertyName
* the property name of the new column, not null
* @param renderer
* the renderer to use, not null
* @param nestedNullBehavior
* the behavior when
* @return the newly added column, not null
*
* @since 8.8
*/
public Column addColumn(String propertyName,
AbstractRenderer renderer,
Column.NestedNullBehavior nestedNullBehavior) {
Objects.requireNonNull(propertyName, "Property name cannot be null");
Objects.requireNonNull(renderer, "Renderer cannot be null");
if (getColumn(propertyName) != null) {
throw new IllegalStateException(
"There is already a column for " + propertyName);
}
PropertyDefinition definition = propertySet
.getProperty(propertyName)
.orElseThrow(() -> new IllegalArgumentException(
"Could not resolve property name " + propertyName
+ " from " + propertySet));
if (!renderer.getPresentationType()
.isAssignableFrom(definition.getType())) {
throw new IllegalArgumentException(
renderer + " cannot be used with a property of type "
+ definition.getType().getName());
}
@SuppressWarnings({ "unchecked", "rawtypes" })
Column column = createColumn(definition.getGetter(),
ValueProvider.identity(), (AbstractRenderer) renderer,
nestedNullBehavior);
String generatedIdentifier = getGeneratedIdentifier();
addColumn(generatedIdentifier, column);
column.setId(definition.getName()).setCaption(definition.getCaption());
return column;
}
/**
* Adds a new text column to this {@link Grid} with a value provider. The
* column will use a {@link TextRenderer}. The value is converted to a
* String using {@link Object#toString()}. In-memory sorting will use the
* natural ordering of elements if they are mutually comparable and
* otherwise fall back to comparing the string representations of the
* values.
*
* @param valueProvider
* the value provider
* @param
* the column value type
*
* @return the new column
*/
public Column addColumn(ValueProvider valueProvider) {
return addColumn(valueProvider, new TextRenderer());
}
/**
* Adds a new column to this {@link Grid} with typed renderer and value
* provider.
*
* @param valueProvider
* the value provider
* @param renderer
* the column value renderer
* @param
* the column value type
*
* @return the new column
*
* @see AbstractRenderer
*/
public Column addColumn(ValueProvider valueProvider,
AbstractRenderer renderer) {
return addColumn(valueProvider, ValueProvider.identity(), renderer);
}
/**
* Adds a new column to this {@link Grid} with value provider and
* presentation provider.
*
* Note: The presentation type for this method is set to be
* String. To use any custom renderer with the presentation provider, use
* {@link #addColumn(ValueProvider, ValueProvider, AbstractRenderer)}.
*
* @param valueProvider
* the value provider
* @param presentationProvider
* the value presentation provider
* @param
* the column value type
*
* @see #addColumn(ValueProvider, ValueProvider, AbstractRenderer)
*
* @return the new column
* @since 8.1
*/
public Column addColumn(ValueProvider valueProvider,
ValueProvider presentationProvider) {
return addColumn(valueProvider, presentationProvider,
new TextRenderer());
}
/**
* Adds a new column to this {@link Grid} with value provider, presentation
* provider and typed renderer.
*
*
* The presentation provider is a method that takes the value from the value
* provider, and maps that to a value that the renderer accepts. This
* feature can be used for storing a complex value in a column for editing,
* but providing a simplified presentation for the user when not editing.
*
* @param valueProvider
* the value provider
* @param presentationProvider
* the value presentation provider
* @param renderer
* the column value renderer
* @param
* the column value type
* @param
* the column presentation type
*
* @return the new column
*
* @see AbstractRenderer
* @since 8.1
*/
public Column addColumn(ValueProvider valueProvider,
ValueProvider presentationProvider,
AbstractRenderer renderer) {
String generatedIdentifier = getGeneratedIdentifier();
Column column = createColumn(valueProvider, presentationProvider,
renderer);
addColumn(generatedIdentifier, column);
return column;
}
/**
* Adds a column that shows components.
*
* This is a shorthand for {@link #addColumn(String)} and its variants with a
* {@link ComponentRenderer}.
*
* @param componentProvider
* a value provider that will return a component for the given
* item
* @return the new column
* @param
* the column value type, extends component
* @since 8.1
*/
public Column addComponentColumn(
ValueProvider componentProvider) {
return addColumn(componentProvider, new ComponentRenderer());
}
/**
* Creates a column instance from a value provider, presentation provider
* and a renderer.
*
* @param valueProvider
* the value provider
* @param presentationProvider
* the presentation provider
* @param renderer
* the renderer
* @return a new column instance
* @param
* the column value type
* @param
* the column presentation type
*
* @since 8.1
*/
protected Column createColumn(
ValueProvider valueProvider,
ValueProvider presentationProvider,
AbstractRenderer renderer) {
return new Column<>(valueProvider, presentationProvider, renderer);
}
/**
* Creates a column instance from a value provider, presentation provider
* and a renderer.
*
* @param valueProvider
* the value provider
* @param presentationProvider
* the presentation provider
* @param renderer
* the renderer
* @param nestedNullBehavior
* the behavior when facing nested null values
* @return a new column instance
* @param
* the column value type
* @param
* the column presentation type
*
* @since 8.8
*/
private Column createColumn(ValueProvider valueProvider,
ValueProvider presentationProvider,
AbstractRenderer renderer,
Column.NestedNullBehavior nestedNullBehavior) {
return new Column<>(valueProvider, presentationProvider, renderer,
nestedNullBehavior);
}
private void addColumn(String identifier, Column column) {
if (getColumns().contains(column)) {
return;
}
column.extend(this);
columnSet.add(column);
columnKeys.put(identifier, column);
column.setInternalId(identifier);
addDataGenerator(column.getDataGenerator());
getState().columnOrder.add(identifier);
getHeader().addColumn(identifier);
getFooter().addColumn(identifier);
if (getDefaultHeaderRow() != null) {
getDefaultHeaderRow().getCell(column).setText(column.getCaption());
}
column.updateSortable();
}
/**
* Removes the given column from this {@link Grid}.
*
* Note: If you have Editor with binding in this Grid to this property, you
* need to remove that using removeBinding method provided by Binder.
*
* @param column
* the column to remove
*
* @throws IllegalArgumentException
* if the column is not a valid one
*/
public void removeColumn(Column column) {
if (columnSet.remove(column)) {
String columnId = column.getInternalId();
int displayIndex = getState(false).columnOrder.indexOf(columnId);
assert displayIndex != -1 : "Tried to remove a column which is not included in columnOrder. This should not be possible as all columns should be in columnOrder.";
columnKeys.remove(columnId);
columnIds.remove(column.getId());
column.remove();
removeDataGenerator(column.getDataGenerator());
getHeader().removeColumn(columnId);
getFooter().removeColumn(columnId);
getState(true).columnOrder.remove(columnId);
// Remove column from sorted columns.
List> filteredSortOrder = sortOrder.stream()
.filter(order -> !order.getSorted().equals(column))
.collect(Collectors.toList());
if (filteredSortOrder.size() < sortOrder.size()) {
setSortOrder(filteredSortOrder);
}
if (displayIndex < getFrozenColumnCount()) {
setFrozenColumnCount(getFrozenColumnCount() - 1);
}
} else {
throw new IllegalArgumentException("Column with id "
+ column.getId() + " cannot be removed from the grid");
}
}
/**
* Removes the column with the given column id.
*
* @see #removeColumn(Column)
* @see Column#setId(String)
*
* @param columnId
* the id of the column to remove, not null
*/
public void removeColumn(String columnId) {
removeColumn(getColumnOrThrow(columnId));
}
/**
* Removes all columns from this Grid.
*
* @since 8.0.2
*/
public void removeAllColumns() {
for (Column column : getColumns()) {
removeColumn(column);
}
}
/**
* Set the order of the columns visible in the sidebar menu. Order defaults
* to {@link SidebarColumnOrder#DEFAULT}, i.e. "present column list in the
* order they were added".
*
* @param order new ordering mode
*
* @since 8.25
*/
public void setSidebarColumnOrder(SidebarColumnOrder order) {
getState().sidebarColumnOrder = order;
}
/**
* Get the current sidebar column order. Order defaults to
* {@link SidebarColumnOrder#DEFAULT}, i.e. "present column list in the
* order they were added".
*
* @return a {@link SidebarColumnOrder} value
*/
public SidebarColumnOrder getSidebarColumnOrder() {
return getState(false).sidebarColumnOrder;
}
/**
* Requests that the column widths should be recalculated.
*