Java tutorial
/* * Copyright 2000-2018 Vaadin Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ package com.vaadin.v7.ui; import java.io.Serializable; import java.lang.reflect.Method; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; import java.util.StringTokenizer; import java.util.logging.Level; import java.util.logging.Logger; import org.jsoup.nodes.Element; import org.jsoup.select.Elements; import com.vaadin.event.Action; import com.vaadin.event.Action.Handler; import com.vaadin.event.ContextClickEvent; import com.vaadin.event.MouseEvents.ClickEvent; import com.vaadin.event.dd.DragAndDropEvent; import com.vaadin.event.dd.DragSource; import com.vaadin.event.dd.DropHandler; import com.vaadin.event.dd.DropTarget; import com.vaadin.event.dd.acceptcriteria.ServerSideCriterion; import com.vaadin.server.KeyMapper; import com.vaadin.server.LegacyCommunicationManager; import com.vaadin.server.LegacyPaint; import com.vaadin.server.PaintException; import com.vaadin.server.PaintTarget; import com.vaadin.server.Resource; import com.vaadin.shared.MouseEventDetails; import com.vaadin.shared.ui.MultiSelectMode; import com.vaadin.shared.util.SharedUtil; import com.vaadin.ui.Component; import com.vaadin.ui.Grid; import com.vaadin.ui.HasChildMeasurementHint; import com.vaadin.ui.UniqueSerializable; 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.util.ReflectTools; import com.vaadin.v7.data.Container; import com.vaadin.v7.data.Item; import com.vaadin.v7.data.Property; import com.vaadin.v7.data.util.ContainerOrderedWrapper; import com.vaadin.v7.data.util.IndexedContainer; import com.vaadin.v7.data.util.converter.Converter; import com.vaadin.v7.data.util.converter.ConverterUtil; import com.vaadin.v7.event.DataBoundTransferable; import com.vaadin.v7.event.ItemClickEvent; import com.vaadin.v7.event.ItemClickEvent.ItemClickListener; import com.vaadin.v7.event.ItemClickEvent.ItemClickNotifier; import com.vaadin.v7.shared.ui.table.CollapseMenuContent; import com.vaadin.v7.shared.ui.table.TableConstants; import com.vaadin.v7.shared.ui.table.TableConstants.Section; import com.vaadin.v7.shared.ui.table.TableServerRpc; import com.vaadin.v7.shared.ui.table.TableState; /** * <p> * <code>Table</code> is used for representing data or components in a pageable * and selectable table. * </p> * * <p> * Scalability of the Table is largely dictated by the container. A table does * not have a limit for the number of items and is just as fast with hundreds of * thousands of items as with just a few. The current GWT implementation with * scrolling however limits the number of rows to around 500000, depending on * the browser and the pixel height of rows. * </p> * * <p> * Components in a Table will not have their caption nor icon rendered. * </p> * * @author Vaadin Ltd. * @since 3.0 * * @deprecated As of 8.0, use {@link Grid} instead */ @Deprecated @SuppressWarnings({ "deprecation" }) public class Table extends AbstractSelect implements Action.Container, Container.Sortable, ItemClickNotifier, DragSource, DropTarget, HasChildMeasurementHint { private transient Logger logger = null; /** * Modes that Table support as drag sourse. */ @Deprecated public enum TableDragMode { /** * Table does not start drag and drop events. HTM5 style events started * by browser may still happen. */ NONE, /** * Table starts drag with a one row only. */ ROW, /** * Table drags selected rows, if drag starts on a selected rows. Else it * starts like in ROW mode. Note, that in Transferable there will still * be only the row on which the drag started, other dragged rows need to * be checked from the source Table. */ MULTIROW } protected static final int CELL_KEY = 0; protected static final int CELL_HEADER = 1; protected static final int CELL_ICON = 2; protected static final int CELL_ITEMID = 3; protected static final int CELL_GENERATED_ROW = 4; protected static final int CELL_FIRSTCOL = 5; @Deprecated public enum Align { /** * Left column alignment. <b>This is the default behavior. </b> */ LEFT("b"), /** * Center column alignment. */ CENTER("c"), /** * Right column alignment. */ RIGHT("e"); private String alignment; private Align(String alignment) { this.alignment = alignment; } @Override public String toString() { return alignment; } public Align convertStringToAlign(String string) { if (string == null) { return null; } if (string.equals("b")) { return Align.LEFT; } else if (string.equals("c")) { return Align.CENTER; } else if (string.equals("e")) { return Align.RIGHT; } else { return null; } } } /** * @deprecated As of 7.0, use {@link Align#LEFT} instead */ @Deprecated public static final Align ALIGN_LEFT = Align.LEFT; /** * @deprecated As of 7.0, use {@link Align#CENTER} instead */ @Deprecated public static final Align ALIGN_CENTER = Align.CENTER; /** * @deprecated As of 7.0, use {@link Align#RIGHT} instead */ @Deprecated public static final Align ALIGN_RIGHT = Align.RIGHT; @Deprecated public enum ColumnHeaderMode { /** * Column headers are hidden. */ HIDDEN, /** * Property ID:s are used as column headers. */ ID, /** * Column headers are explicitly specified with * {@link #setColumnHeaders(String[])}. */ EXPLICIT, /** * Column headers are explicitly specified with * {@link #setColumnHeaders(String[])}. If a header is not specified for * a given property, its property id is used instead. * <p> * <b>This is the default behavior. </b> */ EXPLICIT_DEFAULTS_ID } /** * @deprecated As of 7.0, use {@link ColumnHeaderMode#HIDDEN} instead */ @Deprecated public static final ColumnHeaderMode COLUMN_HEADER_MODE_HIDDEN = ColumnHeaderMode.HIDDEN; /** * @deprecated As of 7.0, use {@link ColumnHeaderMode#ID} instead */ @Deprecated public static final ColumnHeaderMode COLUMN_HEADER_MODE_ID = ColumnHeaderMode.ID; /** * @deprecated As of 7.0, use {@link ColumnHeaderMode#EXPLICIT} instead */ @Deprecated public static final ColumnHeaderMode COLUMN_HEADER_MODE_EXPLICIT = ColumnHeaderMode.EXPLICIT; /** * @deprecated As of 7.0, use {@link ColumnHeaderMode#EXPLICIT_DEFAULTS_ID} * instead */ @Deprecated public static final ColumnHeaderMode COLUMN_HEADER_MODE_EXPLICIT_DEFAULTS_ID = ColumnHeaderMode.EXPLICIT_DEFAULTS_ID; @Deprecated public enum RowHeaderMode { /** * Row caption mode: The row headers are hidden. <b>This is the default * mode. </b> */ HIDDEN(null), /** * Row caption mode: Items Id-objects toString is used as row caption. */ ID(ItemCaptionMode.ID), /** * Row caption mode: Item-objects toString is used as row caption. */ ITEM(ItemCaptionMode.ITEM), /** * Row caption mode: Index of the item is used as item caption. The * index mode can only be used with the containers implementing the * {@link Container.Indexed} interface. */ INDEX(ItemCaptionMode.INDEX), /** * Row caption mode: Item captions are explicitly specified, but if the * caption is missing, the item id objects <code>toString()</code> is * used instead. */ EXPLICIT_DEFAULTS_ID(ItemCaptionMode.EXPLICIT_DEFAULTS_ID), /** * Row caption mode: Item captions are explicitly specified. */ EXPLICIT(ItemCaptionMode.EXPLICIT), /** * Row caption mode: Only icons are shown, the captions are hidden. */ ICON_ONLY(ItemCaptionMode.ICON_ONLY), /** * Row caption mode: Item captions are read from property specified with * {@link #setItemCaptionPropertyId(Object)} . */ PROPERTY(ItemCaptionMode.PROPERTY); ItemCaptionMode mode; private RowHeaderMode(ItemCaptionMode mode) { this.mode = mode; } public ItemCaptionMode getItemCaptionMode() { return mode; } } /** * @deprecated As of 7.0, use {@link RowHeaderMode#HIDDEN} instead */ @Deprecated public static final RowHeaderMode ROW_HEADER_MODE_HIDDEN = RowHeaderMode.HIDDEN; /** * @deprecated As of 7.0, use {@link RowHeaderMode#ID} instead */ @Deprecated public static final RowHeaderMode ROW_HEADER_MODE_ID = RowHeaderMode.ID; /** * @deprecated As of 7.0, use {@link RowHeaderMode#ITEM} instead */ @Deprecated public static final RowHeaderMode ROW_HEADER_MODE_ITEM = RowHeaderMode.ITEM; /** * @deprecated As of 7.0, use {@link RowHeaderMode#INDEX} instead */ @Deprecated public static final RowHeaderMode ROW_HEADER_MODE_INDEX = RowHeaderMode.INDEX; /** * @deprecated As of 7.0, use {@link RowHeaderMode#EXPLICIT_DEFAULTS_ID} * instead */ @Deprecated public static final RowHeaderMode ROW_HEADER_MODE_EXPLICIT_DEFAULTS_ID = RowHeaderMode.EXPLICIT_DEFAULTS_ID; /** * @deprecated As of 7.0, use {@link RowHeaderMode#EXPLICIT} instead */ @Deprecated public static final RowHeaderMode ROW_HEADER_MODE_EXPLICIT = RowHeaderMode.EXPLICIT; /** * @deprecated As of 7.0, use {@link RowHeaderMode#ICON_ONLY} instead */ @Deprecated public static final RowHeaderMode ROW_HEADER_MODE_ICON_ONLY = RowHeaderMode.ICON_ONLY; /** * @deprecated As of 7.0, use {@link RowHeaderMode#PROPERTY} instead */ @Deprecated public static final RowHeaderMode ROW_HEADER_MODE_PROPERTY = RowHeaderMode.PROPERTY; /** * The default rate that table caches rows for smooth scrolling. */ private static final double CACHE_RATE_DEFAULT = 2; private static final String ROW_HEADER_COLUMN_KEY = "0"; private static final Object ROW_HEADER_FAKE_PROPERTY_ID = new UniqueSerializable() { }; /** * How layout manager should behave when measuring Table's child components */ private ChildMeasurementHint childMeasurementHint = ChildMeasurementHint.MEASURE_ALWAYS; /* Private table extensions to Select */ /** * True if column collapsing is allowed. */ private boolean columnCollapsingAllowed = false; /** * True if reordering of columns is allowed on the client side. */ private boolean columnReorderingAllowed = false; /** * Keymapper for column ids. */ private final KeyMapper<Object> columnIdMap = new KeyMapper<Object>(); /** * Holds visible column propertyIds - in order. */ private LinkedList<Object> visibleColumns = new LinkedList<Object>(); /** * Holds noncollapsible columns. */ private HashSet<Object> noncollapsibleColumns = new HashSet<Object>(); /** * Holds propertyIds of currently collapsed columns. */ private final HashSet<Object> collapsedColumns = new HashSet<Object>(); /** * Holds headers for visible columns (by propertyId). */ private final Map<Object, String> columnHeaders = new HashMap<Object, String>(); /** * Holds footers for visible columns (by propertyId). */ private final Map<Object, String> columnFooters = new HashMap<Object, String>(); /** * Holds icons for visible columns (by propertyId). */ private final Map<Object, Resource> columnIcons = new HashMap<Object, Resource>(); /** * Holds alignments for visible columns (by propertyId). */ private Map<Object, Align> columnAlignments = new HashMap<Object, Align>(); /** * Holds column widths in pixels for visible columns (by propertyId). */ private final Map<Object, Integer> columnWidths = new HashMap<Object, Integer>(); /** * Holds column expand rations for visible columns (by propertyId). */ private final Map<Object, Float> columnExpandRatios = new HashMap<Object, Float>(); /** * Holds column generators */ private final Map<Object, ColumnGenerator> columnGenerators = new LinkedHashMap<Object, ColumnGenerator>(); /** * Holds value of property pageLength. 0 disables paging. */ private int pageLength = 15; /** * Id the first item on the current page. */ private Object currentPageFirstItemId = null; /* * If all rows get removed then scroll position of the previous container * can be restored after re-adding/replacing rows via addAll(). This * resolves #14581. */ private int repairOnReAddAllRowsDataScrollPositionItemIndex = -1; /** * Index of the first item on the current page. */ private int currentPageFirstItemIndex = 0; /** * Index of the "first" item on the last page if a user has used * setCurrentPageFirstItemIndex to scroll down. -1 if not set. */ private int currentPageFirstItemIndexOnLastPage = -1; /** * Holds value of property selectable. */ private Boolean selectable; /** * Holds value of property columnHeaderMode. */ private ColumnHeaderMode columnHeaderMode = ColumnHeaderMode.EXPLICIT_DEFAULTS_ID; /** * Holds value of property rowHeaderMode. */ private RowHeaderMode rowHeaderMode = RowHeaderMode.EXPLICIT_DEFAULTS_ID; /** * Should the Table footer be visible? */ private boolean columnFootersVisible = false; /** * Page contents buffer used in buffered mode. */ private Object[][] pageBuffer = null; /** * Set of properties listened - the list is kept to release the listeners * later. */ private HashSet<Property<?>> listenedProperties = null; /** * Set of visible components - the is used for needsRepaint calculation. */ private HashSet<Component> visibleComponents = null; /** * List of action handlers. */ private LinkedList<Handler> actionHandlers = null; /** * Action mapper. */ private KeyMapper<Action> actionMapper = null; /** * Table cell editor factory. */ private TableFieldFactory fieldFactory = DefaultFieldFactory.get(); /** * Is table editable. */ private boolean editable = false; /** * Current sorting direction. */ private boolean sortAscending = true; /** * Currently table is sorted on this propertyId. */ private Object sortContainerPropertyId = null; /** * Is table sorting by the user enabled. */ private boolean sortEnabled = true; /** * Number of rows explicitly requested by the client to be painted on next * paint. This is -1 if no request by the client is made. Painting the * component will automatically reset this to -1. */ private int reqRowsToPaint = -1; /** * Index of the first rows explicitly requested by the client to be painted. * This is -1 if no request by the client is made. Painting the component * will automatically reset this to -1. */ private int reqFirstRowToPaint = -1; private int firstToBeRenderedInClient = -1; private int lastToBeRenderedInClient = -1; private boolean isContentRefreshesEnabled = true; private int pageBufferFirstIndex; private boolean containerChangeToBeRendered = false; /** * Table cell specific style generator */ private CellStyleGenerator cellStyleGenerator = null; /** * Table cell specific tooltip generator */ private ItemDescriptionGenerator itemDescriptionGenerator; /* * EXPERIMENTAL feature: will tell the client to re-calculate column widths * if set to true. Currently no setter: extend to enable. */ protected boolean alwaysRecalculateColumnWidths = false; private double cacheRate = CACHE_RATE_DEFAULT; private TableDragMode dragMode = TableDragMode.NONE; private DropHandler dropHandler; private MultiSelectMode multiSelectMode = MultiSelectMode.DEFAULT; private boolean rowCacheInvalidated; private RowGenerator rowGenerator = null; private final Map<Field<?>, Property<?>> associatedProperties = new HashMap<Field<?>, Property<?>>(); private boolean painted = false; private Map<Object, Converter<String, Object>> propertyValueConverters = new HashMap<Object, Converter<String, Object>>(); /** * Set to true if the client-side should be informed that the key mapper has * been reset so it can avoid sending back references to keys that are no * longer present. */ private boolean keyMapperReset; private List<Throwable> exceptionsDuringCachePopulation = new ArrayList<Throwable>(); private boolean isBeingPainted; /* Table constructors */ /** * Creates a new empty table. */ public Table() { setRowHeaderMode(ROW_HEADER_MODE_HIDDEN); registerRpc(new TableServerRpc() { @Override public void contextClick(String rowKey, String colKey, Section section, MouseEventDetails details) { Object itemId = itemIdMapper.get(rowKey); Object propertyId = columnIdMap.get(colKey); fireEvent(new TableContextClickEvent(Table.this, details, itemId, propertyId, section)); } }); } /** * Creates a new empty table with caption. * * @param caption */ public Table(String caption) { this(); setCaption(caption); } /** * Creates a new table with caption and connect it to a Container. * * @param caption * @param dataSource */ public Table(String caption, Container dataSource) { this(); setCaption(caption); setContainerDataSource(dataSource); } /* Table functionality */ /** * Gets the array of visible column id:s, including generated columns. * * <p> * The columns are show in the order of their appearance in this array. * </p> * * @return an array of currently visible propertyIds and generated column * ids. */ public Object[] getVisibleColumns() { if (visibleColumns == null) { return null; } return visibleColumns.toArray(); } /** * Sets the array of visible column property id:s. * * <p> * The columns are show in the order of their appearance in this array. * </p> * * @param visibleColumns * the Array of shown property id:s. */ public void setVisibleColumns(Object... visibleColumns) { // Visible columns must exist if (visibleColumns == null) { throw new NullPointerException("Can not set visible columns to null value"); } final LinkedList<Object> newVC = new LinkedList<Object>(); // Checks that the new visible columns contains no nulls, properties // exist and that there are no duplicates before adding them to newVC. final Collection<?> properties = getContainerPropertyIds(); for (Object id : visibleColumns) { if (id == null) { throw new NullPointerException("Ids must be non-nulls"); } else if (!properties.contains(id) && !columnGenerators.containsKey(id)) { throw new IllegalArgumentException( "Ids must exist in the Container or as a generated column, missing id: " + id); } else if (newVC.contains(id)) { throw new IllegalArgumentException("Ids must be unique, duplicate id: " + id); } else { newVC.add(id); } } this.visibleColumns = newVC; // Assures visual refresh refreshRowCache(); } /** * Gets the headers of the columns. * * <p> * The headers match the property id:s given by the set visible column * headers. The table must be set in either * {@link #COLUMN_HEADER_MODE_EXPLICIT} or * {@link #COLUMN_HEADER_MODE_EXPLICIT_DEFAULTS_ID} mode to show the * headers. In the defaults mode any nulls in the headers array are replaced * with id.toString(). * </p> * * @return the Array of column headers. */ public String[] getColumnHeaders() { if (columnHeaders == null) { return null; } final String[] headers = new String[visibleColumns.size()]; int i = 0; for (final Object column : visibleColumns) { headers[i++] = getColumnHeader(column); } return headers; } /** * Sets the headers of the columns. * * <p> * The headers match the property id:s given by the set visible column * headers. The table must be set in either * {@link #COLUMN_HEADER_MODE_EXPLICIT} or * {@link #COLUMN_HEADER_MODE_EXPLICIT_DEFAULTS_ID} mode to show the * headers. In the defaults mode any nulls in the headers array are replaced * with id.toString() outputs when rendering. * </p> * * @param columnHeaders * the Array of column headers that match the * {@link #getVisibleColumns()} method. */ public void setColumnHeaders(String... columnHeaders) { if (columnHeaders.length != visibleColumns.size()) { throw new IllegalArgumentException( "The length of the headers array must match the number of visible columns"); } this.columnHeaders.clear(); int i = 0; for (final Object column : visibleColumns) { if (i >= columnHeaders.length) { break; } this.columnHeaders.put(column, columnHeaders[i++]); } markAsDirty(); } /** * Gets the icons of the columns. * * <p> * The icons in headers match the property id:s given by the set visible * column headers. The table must be set in either * {@link #COLUMN_HEADER_MODE_EXPLICIT} or * {@link #COLUMN_HEADER_MODE_EXPLICIT_DEFAULTS_ID} mode to show the headers * with icons. * </p> * * @return the Array of icons that match the {@link #getVisibleColumns()}. */ public Resource[] getColumnIcons() { if (columnIcons == null) { return null; } final Resource[] icons = new Resource[visibleColumns.size()]; int i = 0; for (final Object column : visibleColumns) { icons[i++] = columnIcons.get(column); } return icons; } /** * Sets the icons of the columns. * * <p> * The icons in headers match the property id:s given by the set visible * column headers. The table must be set in either * {@link #COLUMN_HEADER_MODE_EXPLICIT} or * {@link #COLUMN_HEADER_MODE_EXPLICIT_DEFAULTS_ID} mode to show the headers * with icons. * </p> * * @param columnIcons * the Array of icons that match the {@link #getVisibleColumns()} * . */ public void setColumnIcons(Resource... columnIcons) { if (columnIcons.length != visibleColumns.size()) { throw new IllegalArgumentException( "The length of the icons array must match the number of visible columns"); } this.columnIcons.clear(); int i = 0; for (final Object column : visibleColumns) { if (i >= columnIcons.length) { break; } this.columnIcons.put(column, columnIcons[i++]); } markAsDirty(); } /** * Gets the array of column alignments. * * <p> * The items in the array must match the properties identified by * {@link #getVisibleColumns()}. The possible values for the alignments * include: * <ul> * <li>{@link Align#LEFT}: Left alignment</li> * <li>{@link Align#CENTER}: Centered</li> * <li>{@link Align#RIGHT}: Right alignment</li> * </ul> * The alignments default to {@link Align#LEFT}: any null values are * rendered as align lefts. * </p> * * @return the Column alignments array. */ public Align[] getColumnAlignments() { if (columnAlignments == null) { return null; } final Align[] alignments = new Align[visibleColumns.size()]; int i = 0; for (final Object column : visibleColumns) { alignments[i++] = getColumnAlignment(column); } return alignments; } /** * Sets the column alignments. * * <p> * The amount of items in the array must match the amount of properties * identified by {@link #getVisibleColumns()}. The possible values for the * alignments include: * <ul> * <li>{@link Align#LEFT}: Left alignment</li> * <li>{@link Align#CENTER}: Centered</li> * <li>{@link Align#RIGHT}: Right alignment</li> * </ul> * The alignments default to {@link Align#LEFT} * </p> * * @param columnAlignments * the Column alignments array. */ public void setColumnAlignments(Align... columnAlignments) { if (columnAlignments.length != visibleColumns.size()) { throw new IllegalArgumentException( "The length of the alignments array must match the number of visible columns"); } // Resets the alignments final Map<Object, Align> newCA = new HashMap<Object, Align>(); int i = 0; for (final Object column : visibleColumns) { if (i >= columnAlignments.length) { break; } newCA.put(column, columnAlignments[i++]); } this.columnAlignments = newCA; // Assures the visual refresh. No need to reset the page buffer before // as the content has not changed, only the alignments. refreshRenderedCells(); } /** * Sets columns width (in pixels). Theme may not necessarily respect very * small or very big values. Setting width to -1 (default) means that theme * will make decision of width. * * <p> * Column can either have a fixed width or expand ratio. The latter one set * is used. See @link {@link #setColumnExpandRatio(Object, float)}. * * @param propertyId * columns property id * @param width * width to be reserved for columns content * @since 4.0.3 */ public void setColumnWidth(Object propertyId, int width) { if (propertyId == null) { // Since propertyId is null, this is the row header. Use the magic // id to store the width of the row header. propertyId = ROW_HEADER_FAKE_PROPERTY_ID; } // Setting column width should remove any expand ratios as well columnExpandRatios.remove(propertyId); if (width < 0) { columnWidths.remove(propertyId); } else { columnWidths.put(propertyId, width); } markAsDirty(); } /** * Sets the column expand ratio for given column. * <p> * Expand ratios can be defined to customize the way how excess space is * divided among columns. Table can have excess space if it has its width * defined and there is horizontally more space than columns consume * naturally. Excess space is the space that is not used by columns with * explicit width (see {@link #setColumnWidth(Object, int)}) or with natural * width (no width nor expand ratio). * * <p> * By default (without expand ratios) the excess space is divided * proportionally to columns natural widths. * * <p> * Only expand ratios of visible columns are used in final calculations. * * <p> * Column can either have a fixed width or expand ratio. The latter one set * is used. * * <p> * A column with expand ratio is considered to be minimum width by default * (if no excess space exists). The minimum width is defined by terminal * implementation. * * <p> * If terminal implementation supports re-sizable columns the column becomes * fixed width column if users resizes the column. * * @param propertyId * columns property id * @param expandRatio * the expandRatio used to divide excess space for this column */ public void setColumnExpandRatio(Object propertyId, float expandRatio) { if (propertyId == null) { // Since propertyId is null, this is the row header. Use the magic // id to store the width of the row header. propertyId = ROW_HEADER_FAKE_PROPERTY_ID; } // Setting the column expand ratio should remove and defined column // width columnWidths.remove(propertyId); if (expandRatio < 0) { columnExpandRatios.remove(propertyId); } else { columnExpandRatios.put(propertyId, expandRatio); } requestRepaint(); } /** * Gets the column expand ratio for a column. See * {@link #setColumnExpandRatio(Object, float)} * * @param propertyId * columns property id * @return the expandRatio used to divide excess space for this column */ public float getColumnExpandRatio(Object propertyId) { final Float width = columnExpandRatios.get(propertyId); if (width == null) { return -1; } return width.floatValue(); } /** * Gets the pixel width of column. * * @param propertyId * @return width of column or -1 when value not set */ public int getColumnWidth(Object propertyId) { if (propertyId == null) { // Since propertyId is null, this is the row header. Use the magic // id to retrieve the width of the row header. propertyId = ROW_HEADER_FAKE_PROPERTY_ID; } final Integer width = columnWidths.get(propertyId); if (width == null) { return -1; } return width.intValue(); } /** * Gets the page length. * * <p> * Setting page length 0 disables paging. * </p> * * @return the Length of one page. */ public int getPageLength() { return pageLength; } /** * Sets the page length. * * <p> * Setting page length 0 disables paging. The page length defaults to 15. * </p> * * <p> * If Table has height set ({@link #setHeight(float, Unit)} ) the client * side may update the page length automatically the correct value. * </p> * * @param pageLength * the length of one page. */ public void setPageLength(int pageLength) { if (pageLength >= 0 && this.pageLength != pageLength) { this.pageLength = pageLength; // Assures the visual refresh refreshRowCache(); } } /** * This method adjusts a possible caching mechanism of table implementation. * * <p> * Table component may fetch and render some rows outside visible area. With * complex tables (for example containing layouts and components), the * client side may become unresponsive. Setting the value lower, UI will * become more responsive. With higher values scrolling in client will hit * server less frequently. * * <p> * The amount of cached rows will be cacheRate multiplied with pageLength ( * {@link #setPageLength(int)} both below and above visible area.. * * @param cacheRate * a value over 0 (fastest rendering time). Higher value will * cache more rows on server (smoother scrolling). Default value * is 2. */ public void setCacheRate(double cacheRate) { if (cacheRate < 0) { throw new IllegalArgumentException("cacheRate cannot be less than zero"); } if (this.cacheRate != cacheRate) { this.cacheRate = cacheRate; markAsDirty(); } } /** * @see #setCacheRate(double) * * @return the current cache rate value */ public double getCacheRate() { return cacheRate; } /** * Getter for property currentPageFirstItem. * * @return the Value of property currentPageFirstItem. */ public Object getCurrentPageFirstItemId() { // Prioritise index over id if indexes are supported if (items instanceof Container.Indexed) { final int index = getCurrentPageFirstItemIndex(); Object id = null; if (index >= 0 && index < size()) { id = getIdByIndex(index); } if (id != null && !id.equals(currentPageFirstItemId)) { currentPageFirstItemId = id; } } // If there is no item id at all, use the first one if (currentPageFirstItemId == null) { currentPageFirstItemId = firstItemId(); } return currentPageFirstItemId; } /** * Returns the item ID for the item represented by the index given. Assumes * that the current container implements {@link Container.Indexed}. * * See {@link Container.Indexed#getIdByIndex(int)} for more information * about the exceptions that can be thrown. * * @param index * the index for which the item ID should be fetched * @return the item ID for the given index * * @throws ClassCastException * if container does not implement {@link Container.Indexed} * @throws IndexOutOfBoundsException * thrown by {@link Container.Indexed#getIdByIndex(int)} if the * index is invalid */ protected Object getIdByIndex(int index) { return ((Container.Indexed) items).getIdByIndex(index); } /** * Setter for property currentPageFirstItemId. * * @param currentPageFirstItemId * the New value of property currentPageFirstItemId. */ public void setCurrentPageFirstItemId(Object currentPageFirstItemId) { // Gets the corresponding index int index = -1; if (items instanceof Container.Indexed) { index = indexOfId(currentPageFirstItemId); } else { // If the table item container does not have index, we have to // calculates the index by hand Object id = firstItemId(); while (id != null && !id.equals(currentPageFirstItemId)) { index++; id = nextItemId(id); } if (id == null) { index = -1; } } // If the search for item index was successful if (index >= 0) { /* * The table is not capable of displaying an item in the container * as the first if there are not enough items following the selected * item so the whole table (pagelength) is filled. */ int maxIndex = size() - pageLength; if (maxIndex < 0) { maxIndex = 0; } if (index > maxIndex) { // Note that we pass index, not maxIndex, letting // setCurrentPageFirstItemIndex handle the situation. setCurrentPageFirstItemIndex(index); return; } this.currentPageFirstItemId = currentPageFirstItemId; currentPageFirstItemIndex = index; } // Assures the visual refresh refreshRowCache(); } protected int indexOfId(Object itemId) { return ((Container.Indexed) items).indexOfId(itemId); } /** * Gets the icon Resource for the specified column. * * @param propertyId * the propertyId identifying the column. * @return the icon for the specified column; null if the column has no icon * set, or if the column is not visible. */ public Resource getColumnIcon(Object propertyId) { return columnIcons.get(propertyId); } /** * Sets the icon Resource for the specified column. * <p> * Throws IllegalArgumentException if the specified column is not visible. * </p> * * @param propertyId * the propertyId identifying the column. * @param icon * the icon Resource to set. */ public void setColumnIcon(Object propertyId, Resource icon) { if (icon == null) { columnIcons.remove(propertyId); } else { columnIcons.put(propertyId, icon); } markAsDirty(); } /** * Gets the header for the specified column. * * @param propertyId * the propertyId identifying the column. * @return the header for the specified column if it has one. */ public String getColumnHeader(Object propertyId) { if (getColumnHeaderMode() == ColumnHeaderMode.HIDDEN) { return null; } String header = columnHeaders.get(propertyId); if ((header == null && getColumnHeaderMode() == ColumnHeaderMode.EXPLICIT_DEFAULTS_ID) || getColumnHeaderMode() == ColumnHeaderMode.ID) { header = propertyId.toString(); } return header; } /** * Sets the column header for the specified column. * * @param propertyId * the propertyId identifying the column. * @param header * the header to set. */ public void setColumnHeader(Object propertyId, String header) { if (header == null) { columnHeaders.remove(propertyId); } else { columnHeaders.put(propertyId, header); } markAsDirty(); } /** * Gets the specified column's alignment. * * @param propertyId * the propertyID identifying the column. * @return the specified column's alignment if it as one; {@link Align#LEFT} * otherwise. */ public Align getColumnAlignment(Object propertyId) { final Align a = columnAlignments.get(propertyId); return a == null ? Align.LEFT : a; } /** * Sets the specified column's alignment. * * <p> * Throws IllegalArgumentException if the alignment is not one of the * following: {@link Align#LEFT}, {@link Align#CENTER} or * {@link Align#RIGHT} * </p> * * @param propertyId * the propertyID identifying the column. * @param alignment * the desired alignment. */ public void setColumnAlignment(Object propertyId, Align alignment) { if (alignment == null || alignment == Align.LEFT) { columnAlignments.remove(propertyId); } else { columnAlignments.put(propertyId, alignment); } // Assures the visual refresh. No need to reset the page buffer before // as the content has not changed, only the alignments. refreshRenderedCells(); } /** * Checks if the specified column is collapsed. * * @param propertyId * the propertyID identifying the column. * @return true if the column is collapsed; false otherwise; */ public boolean isColumnCollapsed(Object propertyId) { return collapsedColumns != null && collapsedColumns.contains(propertyId); } /** * Sets whether the specified column is collapsed or not. * * * @param propertyId * the propertyID identifying the column. * @param collapsed * the desired collapsedness. * @throws IllegalStateException * if column collapsing is not allowed * @throws IllegalArgumentException * if the property id does not exist */ public void setColumnCollapsed(Object propertyId, boolean collapsed) throws IllegalStateException { if (!isColumnCollapsingAllowed()) { throw new IllegalStateException("Column collapsing not allowed!"); } if (collapsed && noncollapsibleColumns.contains(propertyId)) { throw new IllegalStateException("The column is noncollapsible!"); } if (!getContainerPropertyIds().contains(propertyId) && !columnGenerators.containsKey(propertyId)) { throw new IllegalArgumentException("Property '" + propertyId + "' was not found in the container"); } if (collapsed) { if (collapsedColumns.add(propertyId)) { fireColumnCollapseEvent(propertyId); } } else { if (collapsedColumns.remove(propertyId)) { fireColumnCollapseEvent(propertyId); } } // Assures the visual refresh refreshRowCache(); } /** * Checks if column collapsing is allowed. * * @return true if columns can be collapsed; false otherwise. */ public boolean isColumnCollapsingAllowed() { return columnCollapsingAllowed; } /** * Sets whether column collapsing is allowed or not. * * @param collapsingAllowed * specifies whether column collapsing is allowed. */ public void setColumnCollapsingAllowed(boolean collapsingAllowed) { columnCollapsingAllowed = collapsingAllowed; if (!collapsingAllowed) { collapsedColumns.clear(); } // Assures the visual refresh. No need to reset the page buffer before // as the content has not changed, only the alignments. refreshRenderedCells(); } /** * Sets whether the given column is collapsible. Note that collapsible * columns can only be actually collapsed (via UI or with * {@link #setColumnCollapsed(Object, boolean) setColumnCollapsed()}) if * {@link #isColumnCollapsingAllowed()} is true. By default all columns are * collapsible. * * @param propertyId * the propertyID identifying the column. * @param collapsible * true if the column should be collapsible, false otherwise. */ public void setColumnCollapsible(Object propertyId, boolean collapsible) { if (collapsible) { noncollapsibleColumns.remove(propertyId); } else { noncollapsibleColumns.add(propertyId); collapsedColumns.remove(propertyId); } refreshRowCache(); } /** * Checks if the given column is collapsible. Note that even if this method * returns <code>true</code>, the column can only be actually collapsed (via * UI or with {@link #setColumnCollapsed(Object, boolean) * setColumnCollapsed()}) if {@link #isColumnCollapsingAllowed()} is also * true. * * @return true if the column can be collapsed; false otherwise. */ public boolean isColumnCollapsible(Object propertyId) { return !noncollapsibleColumns.contains(propertyId); } /** * Checks if column reordering is allowed. * * @return true if columns can be reordered; false otherwise. */ public boolean isColumnReorderingAllowed() { return columnReorderingAllowed; } /** * Sets whether column reordering is allowed or not. * * @param columnReorderingAllowed * specifies whether column reordering is allowed. */ public void setColumnReorderingAllowed(boolean columnReorderingAllowed) { if (columnReorderingAllowed != this.columnReorderingAllowed) { this.columnReorderingAllowed = columnReorderingAllowed; markAsDirty(); } } /* * Arranges visible columns according to given columnOrder. Silently ignores * colimnId:s that are not visible columns, and keeps the internal order of * visible columns left out of the ordering (trailing). Silently does * nothing if columnReordering is not allowed. */ private void setColumnOrder(Object[] columnOrder) { if (columnOrder == null || !isColumnReorderingAllowed()) { return; } final LinkedList<Object> newOrder = new LinkedList<Object>(); for (Object id : columnOrder) { if (id != null && visibleColumns.contains(id)) { visibleColumns.remove(id); newOrder.add(id); } } for (final Object columnId : visibleColumns) { if (!newOrder.contains(columnId)) { newOrder.add(columnId); } } visibleColumns = newOrder; // Assure visual refresh refreshRowCache(); } /** * Getter for property currentPageFirstItem. * * @return the Value of property currentPageFirstItem. */ public int getCurrentPageFirstItemIndex() { return currentPageFirstItemIndex; } void setCurrentPageFirstItemIndex(int newIndex, boolean needsPageBufferReset) { if (newIndex < 0) { newIndex = 0; } /* * minimize Container.size() calls which may be expensive. For example * it may cause sql query. */ final int size = size(); /* * The table is not capable of displaying an item in the container as * the first if there are not enough items following the selected item * so the whole table (pagelength) is filled. */ int maxIndex = size - pageLength; if (maxIndex < 0) { maxIndex = 0; } /* * If the new index is on the last page we set the index to be the first * item on that last page and make a note of the real index for the * client side to be able to move the scroll position to the correct * position. */ int indexOnLastPage = -1; if (newIndex > maxIndex) { indexOnLastPage = newIndex; newIndex = maxIndex; } // Refresh first item id if (items instanceof Container.Indexed) { try { currentPageFirstItemId = getIdByIndex(newIndex); } catch (final IndexOutOfBoundsException e) { currentPageFirstItemId = null; } currentPageFirstItemIndex = newIndex; if (needsPageBufferReset) { /* * The flag currentPageFirstItemIndexOnLastPage denotes a user * set scrolling position on the last page via * setCurrentPageFirstItemIndex() and shouldn't be changed by * the table component internally changing the firstvisible item * on lazy row fetching. Doing so would make the scrolling * position not be updated correctly when the lazy rows are * finally rendered. */ boolean isLastRowPossiblyPartiallyVisible = true; if (indexOnLastPage != -1) { /* * If the requested row was greater than maxIndex, the last * row should be fully visible (See * TestCurrentPageFirstItem). */ isLastRowPossiblyPartiallyVisible = false; } int extraRows = isLastRowPossiblyPartiallyVisible ? 0 : 1; currentPageFirstItemIndexOnLastPage = currentPageFirstItemIndex + extraRows; } else { currentPageFirstItemIndexOnLastPage = -1; } } else { // For containers not supporting indexes, we must iterate the // container forwards / backwards // next available item forward or backward currentPageFirstItemId = firstItemId(); // Go forwards in the middle of the list (respect borders) while (currentPageFirstItemIndex < newIndex && !isLastId(currentPageFirstItemId)) { currentPageFirstItemIndex++; currentPageFirstItemId = nextItemId(currentPageFirstItemId); } // If we did hit the border if (isLastId(currentPageFirstItemId)) { currentPageFirstItemIndex = size - 1; } // Go backwards in the middle of the list (respect borders) while (currentPageFirstItemIndex > newIndex && !isFirstId(currentPageFirstItemId)) { currentPageFirstItemIndex--; currentPageFirstItemId = prevItemId(currentPageFirstItemId); } // If we did hit the border if (isFirstId(currentPageFirstItemId)) { currentPageFirstItemIndex = 0; } // Go forwards once more while (currentPageFirstItemIndex < newIndex && !isLastId(currentPageFirstItemId)) { currentPageFirstItemIndex++; currentPageFirstItemId = nextItemId(currentPageFirstItemId); } // If for some reason we do hit border again, override // the user index request if (isLastId(currentPageFirstItemId)) { newIndex = currentPageFirstItemIndex = size - 1; } } if (needsPageBufferReset) { // Assures the visual refresh refreshRowCache(); } } /** * Setter for property currentPageFirstItem. * * @param newIndex * the New value of property currentPageFirstItem. */ public void setCurrentPageFirstItemIndex(int newIndex) { setCurrentPageFirstItemIndex(newIndex, true); } /** * Returns whether table is selectable. * * <p> * The table is not selectable until it's explicitly set as selectable or at * least one {@link ValueChangeListener} is added. * </p> * * @return whether table is selectable. */ public boolean isSelectable() { if (selectable == null) { return hasListeners(ValueChangeEvent.class); } return selectable; } /** * Setter for property selectable. * * <p> * The table is not selectable until it's explicitly set as selectable via * this method or alternatively at least one {@link ValueChangeListener} is * added. * </p> * * @param selectable * the New value of property selectable. */ public void setSelectable(boolean selectable) { if (!SharedUtil.equals(this.selectable, selectable)) { this.selectable = selectable; markAsDirty(); } } /** * Getter for property columnHeaderMode. * * @return the Value of property columnHeaderMode. */ public ColumnHeaderMode getColumnHeaderMode() { return columnHeaderMode; } /** * Setter for property columnHeaderMode. * * @param columnHeaderMode * the New value of property columnHeaderMode. */ public void setColumnHeaderMode(ColumnHeaderMode columnHeaderMode) { if (columnHeaderMode == null) { throw new IllegalArgumentException("Column header mode can not be null"); } if (columnHeaderMode != this.columnHeaderMode) { this.columnHeaderMode = columnHeaderMode; markAsDirty(); } } /** * Refreshes the rows in the internal cache. Only if * {@link #resetPageBuffer()} is called before this then all values are * guaranteed to be recreated. */ protected void refreshRenderedCells() { if (!isAttached()) { return; } if (!isContentRefreshesEnabled) { return; } // Collects the basic facts about the table page final int pagelen = getPageLength(); int rows, totalRows; rows = totalRows = size(); int firstIndex = Math.min(getCurrentPageFirstItemIndex(), totalRows - 1); if (rows > 0 && firstIndex >= 0) { rows -= firstIndex; } if (pagelen > 0 && pagelen < rows) { rows = pagelen; } // If "to be painted next" variables are set, use them if (lastToBeRenderedInClient - firstToBeRenderedInClient > 0) { rows = lastToBeRenderedInClient - firstToBeRenderedInClient + 1; } if (firstToBeRenderedInClient >= 0) { if (firstToBeRenderedInClient < totalRows) { firstIndex = firstToBeRenderedInClient; } else { firstIndex = totalRows - 1; } } else { // initial load // #8805 send one extra row in the beginning in case a partial // row is shown on the UI if (firstIndex > 0) { firstIndex = firstIndex - 1; rows = rows + 1; } firstToBeRenderedInClient = firstIndex; } if (totalRows > 0) { if (rows + firstIndex > totalRows) { rows = totalRows - firstIndex; } } else { rows = 0; } // Saves the results to internal buffer pageBuffer = getVisibleCellsNoCache(firstIndex, rows, true); if (rows > 0) { pageBufferFirstIndex = firstIndex; } setRowCacheInvalidated(true); markAsDirty(); maybeThrowCacheUpdateExceptions(); } private void maybeThrowCacheUpdateExceptions() { if (!exceptionsDuringCachePopulation.isEmpty()) { Throwable[] causes = new Throwable[exceptionsDuringCachePopulation.size()]; exceptionsDuringCachePopulation.toArray(causes); exceptionsDuringCachePopulation.clear(); throw new CacheUpdateException(this, "Error during Table cache update.", causes); } } /** * Exception thrown when one or more exceptions occurred during updating of * the Table cache. * <p> * Contains all exceptions which occurred during the cache update. The first * occurred exception is set as the cause of this exception. All occurred * exceptions can be accessed using {@link #getCauses()}. * </p> * */ @Deprecated public static class CacheUpdateException extends RuntimeException { private Throwable[] causes; private Table table; public CacheUpdateException(Table table, String message, Throwable[] causes) { super(maybeSupplementMessage(message, causes.length), causes[0]); this.table = table; this.causes = causes; } private static String maybeSupplementMessage(String message, int causeCount) { if (causeCount > 1) { return message + " Additional causes not shown."; } else { return message; } } /** * Returns the cause(s) for this exception. * * @return the exception(s) which caused this exception */ public Throwable[] getCauses() { return causes; } public Table getTable() { return table; } } /** * Requests that the Table should be repainted as soon as possible. * * Note that a {@code Table} does not necessarily repaint its contents when * this method has been called. See {@link #refreshRowCache()} for forcing * an update of the contents. * * @deprecated As of 7.0, use {@link #markAsDirty()} instead */ @Deprecated @Override public void requestRepaint() { markAsDirty(); } /** * Requests that the Table should be repainted as soon as possible. * * Note that a {@code Table} does not necessarily repaint its contents when * this method has been called. See {@link #refreshRowCache()} for forcing * an update of the contents. */ @Override public void markAsDirty() { // Overridden only for javadoc super.markAsDirty(); } @Override public void markAsDirtyRecursive() { super.markAsDirtyRecursive(); // Avoid sending a partial repaint (#8714) refreshRowCache(); } private void removeRowsFromCacheAndFillBottom(int firstIndex, int rows) { int totalCachedRows = pageBuffer[CELL_ITEMID].length; int totalRows = size(); int firstIndexInPageBuffer = firstIndex - pageBufferFirstIndex; /* * firstIndexInPageBuffer is the first row to be removed. "rows" rows * after that should be removed. If the page buffer does not contain * that many rows, we only remove the rows that actually are in the page * buffer. */ if (firstIndexInPageBuffer + rows > totalCachedRows) { rows = totalCachedRows - firstIndexInPageBuffer; } /* * Unregister components that will no longer be in the page buffer to * make sure that no components leak. */ unregisterComponentsAndPropertiesInRows(firstIndex, rows); /* * The number of rows that should be in the cache after this operation * is done (pageBuffer currently contains the expanded items). */ int newCachedRowCount = totalCachedRows; if (newCachedRowCount + pageBufferFirstIndex > totalRows) { newCachedRowCount = totalRows - pageBufferFirstIndex; } /* * The index at which we should render the first row that does not come * from the previous page buffer. */ int firstAppendedRowInPageBuffer = totalCachedRows - rows; int firstAppendedRow = firstAppendedRowInPageBuffer + pageBufferFirstIndex; /* * Calculate the maximum number of new rows that we can add to the page * buffer. Less than the rows we removed if the container does not * contain that many items afterwards. */ int maxRowsToRender = (totalRows - firstAppendedRow); int rowsToAdd = rows; if (rowsToAdd > maxRowsToRender) { rowsToAdd = maxRowsToRender; } Object[][] cells = null; if (rowsToAdd > 0) { cells = getVisibleCellsNoCache(firstAppendedRow, rowsToAdd, false); } /* * Create the new cache buffer by copying the first rows from the old * buffer, moving the following rows upwards and appending more rows if * applicable. */ Object[][] newPageBuffer = new Object[pageBuffer.length][newCachedRowCount]; for (int i = 0; i < pageBuffer.length; i++) { for (int row = 0; row < firstIndexInPageBuffer; row++) { // Copy the first rows newPageBuffer[i][row] = pageBuffer[i][row]; } for (int row = firstIndexInPageBuffer; row < firstAppendedRowInPageBuffer; row++) { // Move the rows that were after the expanded rows newPageBuffer[i][row] = pageBuffer[i][row + rows]; } for (int row = firstAppendedRowInPageBuffer; row < newCachedRowCount; row++) { // Add the newly rendered rows. Only used if rowsToAdd > 0 // (cells != null) newPageBuffer[i][row] = cells[i][row - firstAppendedRowInPageBuffer]; } } pageBuffer = newPageBuffer; } private Object[][] getVisibleCellsUpdateCacheRows(int firstIndex, int rows) { Object[][] cells = getVisibleCellsNoCache(firstIndex, rows, false); int cacheIx = firstIndex - pageBufferFirstIndex; // update the new rows in the cache. int totalCachedRows = pageBuffer[CELL_ITEMID].length; int end = Math.min(cacheIx + rows, totalCachedRows); for (int ix = cacheIx; ix < end; ix++) { for (int i = 0; i < pageBuffer.length; i++) { pageBuffer[i][ix] = cells[i][ix - cacheIx]; } } return cells; } /** * @param firstIndex * The position where new rows should be inserted * @param rows * The maximum number of rows that should be inserted at position * firstIndex. Less rows will be inserted if the page buffer is * too small. * @return */ private Object[][] getVisibleCellsInsertIntoCache(int firstIndex, int rows) { getLogger().log(Level.FINEST, "Insert {0} rows at index {1} to existing page buffer requested", new Object[] { rows, firstIndex }); int minPageBufferIndex = getMinPageBufferIndex(); int maxPageBufferIndex = getMaxPageBufferIndex(); int maxBufferSize = maxPageBufferIndex - minPageBufferIndex + 1; if (getPageLength() == 0) { // If pageLength == 0 then all rows should be rendered maxBufferSize = pageBuffer[CELL_ITEMID].length + rows; } /* * Number of rows that were previously cached. This is not necessarily * the same as maxBufferSize. */ int currentlyCachedRowCount = pageBuffer[CELL_ITEMID].length; /* If rows > size available in page buffer */ if (firstIndex + rows - 1 > maxPageBufferIndex) { rows = maxPageBufferIndex - firstIndex + 1; } /* * "rows" rows will be inserted at firstIndex. Find out how many old * rows fall outside the new buffer so we can unregister components in * the cache. */ /* * if there are rows before the new pageBuffer limits they must be * removed */ int lastCacheRowToRemove = minPageBufferIndex - 1; int rowsFromBeginning = lastCacheRowToRemove - pageBufferFirstIndex + 1; if (lastCacheRowToRemove >= pageBufferFirstIndex) { unregisterComponentsAndPropertiesInRows(pageBufferFirstIndex, rowsFromBeginning); } else { rowsFromBeginning = 0; } /* * the rows that fall outside of the new pageBuffer limits after the new * rows are inserted must also be removed */ int firstCacheRowToRemove = firstIndex; /* * IF there is space remaining in the buffer after the rows have been * inserted, we can keep more rows. */ int numberOfOldRowsAfterInsertedRows = Math.min(pageBufferFirstIndex + currentlyCachedRowCount + rows, maxPageBufferIndex + 1) - (firstIndex + rows - 1); if (numberOfOldRowsAfterInsertedRows > 0) { firstCacheRowToRemove += numberOfOldRowsAfterInsertedRows; } int rowsFromAfter = currentlyCachedRowCount - (firstCacheRowToRemove - pageBufferFirstIndex); if (rowsFromAfter > 0) { /* * Unregister all components that fall beyond the cache limits after * inserting the new rows. */ unregisterComponentsAndPropertiesInRows(firstCacheRowToRemove, rowsFromAfter); } // Calculate the new cache size int newCachedRowCount = maxBufferSize; if (pageBufferFirstIndex + currentlyCachedRowCount + rows - 1 < maxPageBufferIndex) { // there aren't enough rows to fill the whole potential -> use what // there is newCachedRowCount -= maxPageBufferIndex - (pageBufferFirstIndex + currentlyCachedRowCount + rows - 1); } else if (minPageBufferIndex < pageBufferFirstIndex) { newCachedRowCount -= pageBufferFirstIndex - minPageBufferIndex; } /* * calculate the internal location of the new rows within the new cache */ int firstIndexInNewPageBuffer = firstIndex - pageBufferFirstIndex - rowsFromBeginning; /* Paint the new rows into a separate buffer */ Object[][] cells = getVisibleCellsNoCache(firstIndex, rows, false); /* * Create the new cache buffer and fill it with the data from the old * buffer as well as the inserted rows. */ Object[][] newPageBuffer = new Object[pageBuffer.length][newCachedRowCount]; for (int i = 0; i < pageBuffer.length; i++) { for (int row = 0; row < firstIndexInNewPageBuffer; row++) { // Copy the first rows newPageBuffer[i][row] = pageBuffer[i][rowsFromBeginning + row]; } for (int row = firstIndexInNewPageBuffer; row < firstIndexInNewPageBuffer + rows; row++) { // Copy the newly created rows newPageBuffer[i][row] = cells[i][row - firstIndexInNewPageBuffer]; } for (int row = firstIndexInNewPageBuffer + rows; row < newCachedRowCount; row++) { // Move the old rows down below the newly inserted rows newPageBuffer[i][row] = pageBuffer[i][rowsFromBeginning + row - rows]; } } pageBuffer = newPageBuffer; pageBufferFirstIndex = Math.max(pageBufferFirstIndex + rowsFromBeginning, minPageBufferIndex); if (getLogger().isLoggable(Level.FINEST)) { getLogger().log(Level.FINEST, "Page Buffer now contains {0} rows ({1}-{2})", new Object[] { pageBuffer[CELL_ITEMID].length, pageBufferFirstIndex, (pageBufferFirstIndex + pageBuffer[CELL_ITEMID].length - 1) }); } return cells; } private int getMaxPageBufferIndex() { int total = size(); if (getPageLength() == 0) { // everything is shown at once, no caching return total - 1; } // Page buffer must not become larger than pageLength*cacheRate after // the current page int maxPageBufferIndex = getCurrentPageFirstItemIndex() + (int) (getPageLength() * (1 + getCacheRate())); if (shouldHideNullSelectionItem()) { --total; } if (maxPageBufferIndex >= total) { maxPageBufferIndex = total - 1; } return maxPageBufferIndex; } private int getMinPageBufferIndex() { if (getPageLength() == 0) { // everything is shown at once, no caching return 0; } // Page buffer must not become larger than pageLength*cacheRate before // the current page int minPageBufferIndex = getCurrentPageFirstItemIndex() - (int) (getPageLength() * getCacheRate()); if (minPageBufferIndex < 0) { minPageBufferIndex = 0; } return minPageBufferIndex; } /** * Render rows with index "firstIndex" to "firstIndex+rows-1" to a new * buffer. * * Reuses values from the current page buffer if the rows are found there. * * @param firstIndex * @param rows * @param replaceListeners * @return */ private Object[][] getVisibleCellsNoCache(int firstIndex, int rows, boolean replaceListeners) { if (getLogger().isLoggable(Level.FINEST)) { getLogger().log(Level.FINEST, "Render visible cells for rows {0}-{1}", new Object[] { firstIndex, (firstIndex + rows - 1) }); } final Object[] colids = getVisibleColumns(); final int cols = colids.length; HashSet<Property<?>> oldListenedProperties = listenedProperties; HashSet<Component> oldVisibleComponents = visibleComponents; if (replaceListeners) { // initialize the listener collections, this should only be done if // the entire cache is refreshed (through refreshRenderedCells) listenedProperties = new HashSet<Property<?>>(); visibleComponents = new HashSet<Component>(); } Object[][] cells = new Object[cols + CELL_FIRSTCOL][rows]; if (rows == 0) { unregisterPropertiesAndComponents(oldListenedProperties, oldVisibleComponents); return cells; } final RowHeaderMode headmode = getRowHeaderMode(); final boolean[] iscomponent = new boolean[cols]; for (int i = 0; i < cols; i++) { iscomponent[i] = columnGenerators.containsKey(colids[i]) || Component.class.isAssignableFrom(getType(colids[i])); } int firstIndexNotInCache; if (pageBuffer != null && pageBuffer[CELL_ITEMID].length > 0) { firstIndexNotInCache = pageBufferFirstIndex + pageBuffer[CELL_ITEMID].length; } else { firstIndexNotInCache = -1; } // Creates the page contents int filledRows = 0; if (items instanceof Container.Indexed) { // more efficient implementation for containers supporting access by // index List<?> itemIds = getItemIds(firstIndex, rows); for (int i = 0; i < rows && i < itemIds.size(); i++) { Object id = itemIds.get(i); if (id == null) { throw new IllegalStateException("Null itemId returned from container"); } // Start by parsing the values, id should already be set parseItemIdToCells(cells, id, i, firstIndex, headmode, cols, colids, firstIndexNotInCache, iscomponent, oldListenedProperties); filledRows++; } } else { // slow back-up implementation for cases where the container does // not support access by index // Gets the first item id Object id = firstItemId(); for (int i = 0; i < firstIndex; i++) { id = nextItemId(id); } for (int i = 0; i < rows && id != null; i++) { // Start by parsing the values, id should already be set parseItemIdToCells(cells, id, i, firstIndex, headmode, cols, colids, firstIndexNotInCache, iscomponent, oldListenedProperties); // Gets the next item id for non indexed container id = nextItemId(id); filledRows++; } } // Assures that all the rows of the cell-buffer are valid if (filledRows != cells[0].length) { final Object[][] temp = new Object[cells.length][filledRows]; for (int i = 0; i < cells.length; i++) { for (int j = 0; j < filledRows; j++) { temp[i][j] = cells[i][j]; } } cells = temp; } unregisterPropertiesAndComponents(oldListenedProperties, oldVisibleComponents); return cells; } protected List<Object> getItemIds(int firstIndex, int rows) { return (List<Object>) ((Container.Indexed) items).getItemIds(firstIndex, rows); } /** * Update a cache array for a row, register any relevant listeners etc. * * This is an internal method extracted from * {@link #getVisibleCellsNoCache(int, int, boolean)} and should be removed * when the Table is rewritten. */ private void parseItemIdToCells(Object[][] cells, Object id, int i, int firstIndex, RowHeaderMode headmode, int cols, Object[] colids, int firstIndexNotInCache, boolean[] iscomponent, HashSet<Property<?>> oldListenedProperties) { cells[CELL_ITEMID][i] = id; cells[CELL_KEY][i] = itemIdMapper.key(id); if (headmode != ROW_HEADER_MODE_HIDDEN) { switch (headmode) { case INDEX: cells[CELL_HEADER][i] = String.valueOf(i + firstIndex + 1); break; default: try { cells[CELL_HEADER][i] = getItemCaption(id); } catch (Exception e) { exceptionsDuringCachePopulation.add(e); cells[CELL_HEADER][i] = ""; } } try { cells[CELL_ICON][i] = getItemIcon(id); } catch (Exception e) { exceptionsDuringCachePopulation.add(e); cells[CELL_ICON][i] = null; } } GeneratedRow generatedRow = rowGenerator != null ? rowGenerator.generateRow(this, id) : null; cells[CELL_GENERATED_ROW][i] = generatedRow; for (int j = 0; j < cols; j++) { if (isColumnCollapsed(colids[j])) { continue; } Property<?> p = null; Object value = ""; boolean isGeneratedRow = generatedRow != null; boolean isGeneratedColumn = columnGenerators.containsKey(colids[j]); boolean isGenerated = isGeneratedRow || isGeneratedColumn; if (!isGenerated) { try { p = getContainerProperty(id, colids[j]); } catch (Exception e) { exceptionsDuringCachePopulation.add(e); value = null; } } if (isGeneratedRow) { if (generatedRow.isSpanColumns() && j > 0) { value = null; } else if (generatedRow.isSpanColumns() && j == 0 && generatedRow.getValue() instanceof Component) { value = generatedRow.getValue(); } else if (generatedRow.getText().length > j) { value = generatedRow.getText()[j]; } } else { // check if current pageBuffer already has row int index = firstIndex + i; if (p != null || isGenerated) { int indexInOldBuffer = index - pageBufferFirstIndex; if (index < firstIndexNotInCache && index >= pageBufferFirstIndex && pageBuffer[CELL_GENERATED_ROW][indexInOldBuffer] == null && id.equals(pageBuffer[CELL_ITEMID][indexInOldBuffer])) { // we already have data in our cache, // recycle it instead of fetching it via // getValue/getPropertyValue value = pageBuffer[CELL_FIRSTCOL + j][indexInOldBuffer]; if (!isGeneratedColumn && iscomponent[j] || !(value instanceof Component)) { listenProperty(p, oldListenedProperties); } } else { if (isGeneratedColumn) { ColumnGenerator cg = columnGenerators.get(colids[j]); try { value = cg.generateCell(this, id, colids[j]); } catch (Exception e) { exceptionsDuringCachePopulation.add(e); value = null; } if (value != null && !(value instanceof Component) && !(value instanceof String)) { // Avoid errors if a generator returns // something // other than a Component or a String value = value.toString(); } } else if (iscomponent[j]) { try { value = p.getValue(); } catch (Exception e) { exceptionsDuringCachePopulation.add(e); value = null; } listenProperty(p, oldListenedProperties); } else if (p != null) { try { value = getPropertyValue(id, colids[j], p); } catch (Exception e) { exceptionsDuringCachePopulation.add(e); value = null; } /* * If returned value is Component (via fieldfactory * or overridden getPropertyValue) we expect it to * listen property value changes. Otherwise if * property emits value change events, table will * start to listen them and refresh content when * needed. */ if (!(value instanceof Component)) { listenProperty(p, oldListenedProperties); } } else { try { value = getPropertyValue(id, colids[j], null); } catch (Exception e) { exceptionsDuringCachePopulation.add(e); value = null; } } } } } if (value instanceof Component) { registerComponent((Component) value); } cells[CELL_FIRSTCOL + j][i] = value; } } protected void registerComponent(Component component) { getLogger().log(Level.FINEST, "Registered {0}: {1}", new Object[] { component.getClass().getSimpleName(), component.getCaption() }); if (!equals(component.getParent())) { component.setParent(this); } visibleComponents.add(component); } private void listenProperty(Property<?> p, HashSet<Property<?>> oldListenedProperties) { if (p instanceof Property.ValueChangeNotifier) { if (oldListenedProperties == null || !oldListenedProperties.contains(p)) { ((Property.ValueChangeNotifier) p).addListener(this); } /* * register listened properties, so we can do proper cleanup to free * memory. Essential if table has loads of data and it is used for a * long time. */ listenedProperties.add(p); } } /** * @param firstIx * Index of the first row to process. Global index, not relative * to page buffer. * @param count */ private void unregisterComponentsAndPropertiesInRows(int firstIx, int count) { if (getLogger().isLoggable(Level.FINEST)) { getLogger().log(Level.FINEST, "Unregistering components in rows {0}-{1}", new Object[] { firstIx, (firstIx + count - 1) }); } Object[] colids = getVisibleColumns(); if (pageBuffer != null && pageBuffer[CELL_ITEMID].length > 0) { int bufSize = pageBuffer[CELL_ITEMID].length; int ix = firstIx - pageBufferFirstIndex; ix = ix < 0 ? 0 : ix; if (ix < bufSize) { count = count > bufSize - ix ? bufSize - ix : count; for (int i = 0; i < count; i++) { for (int c = 0; c < colids.length; c++) { Object cellVal = pageBuffer[CELL_FIRSTCOL + c][i + ix]; if (cellVal instanceof Component && visibleComponents.contains(cellVal)) { visibleComponents.remove(cellVal); unregisterComponent((Component) cellVal); } else { Property<?> p = getContainerProperty(pageBuffer[CELL_ITEMID][i + ix], colids[c]); if (p instanceof ValueChangeNotifier && listenedProperties.contains(p)) { listenedProperties.remove(p); ((ValueChangeNotifier) p).removeListener(this); } } } } } } } /** * Helper method to remove listeners and maintain correct component * hierarchy. Detaches properties and components if those are no more * rendered in client. * * @param oldListenedProperties * set of properties that where listened in last render * @param oldVisibleComponents * set of components that where attached in last render */ private void unregisterPropertiesAndComponents(HashSet<Property<?>> oldListenedProperties, HashSet<Component> oldVisibleComponents) { if (oldVisibleComponents != null) { for (final Component c : oldVisibleComponents) { if (!visibleComponents.contains(c)) { unregisterComponent(c); } } } if (oldListenedProperties != null) { for (final Property<?> p : oldListenedProperties) { Property.ValueChangeNotifier o = (ValueChangeNotifier) p; if (!listenedProperties.contains(o)) { o.removeListener(this); } } } } /** * This method cleans up a Component that has been generated when Table is * in editable mode. The component needs to be detached from its parent and * if it is a field, it needs to be detached from its property data source * in order to allow garbage collection to take care of removing the unused * component from memory. * * Override this method and getPropertyValue(Object, Object, Property) with * custom logic if you need to deal with buffered fields. * * @see #getPropertyValue(Object, Object, Property) * * @param component * component that should be unregistered. */ protected void unregisterComponent(Component component) { getLogger().log(Level.FINEST, "Unregistered {0}: {1}", new Object[] { component.getClass().getSimpleName(), component.getCaption() }); component.setParent(null); /* * Also remove property data sources to unregister listeners keeping the * fields in memory. */ if (component instanceof Field) { Field<?> field = (Field<?>) component; Property<?> associatedProperty = associatedProperties.remove(component); if (associatedProperty != null && field.getPropertyDataSource() == associatedProperty) { // Remove the property data source only if it's the one we // added in getPropertyValue field.setPropertyDataSource(null); } } } /** * Sets the row header mode. * <p> * The mode can be one of the following ones: * <ul> * <li>{@link #ROW_HEADER_MODE_HIDDEN}: The row captions are hidden.</li> * <li>{@link #ROW_HEADER_MODE_ID}: Items Id-objects <code>toString()</code> * is used as row caption. * <li>{@link #ROW_HEADER_MODE_ITEM}: Item-objects <code>toString()</code> * is used as row caption. * <li>{@link #ROW_HEADER_MODE_PROPERTY}: Property set with * {@link #setItemCaptionPropertyId(Object)} is used as row header. * <li>{@link #ROW_HEADER_MODE_EXPLICIT_DEFAULTS_ID}: Items Id-objects * <code>toString()</code> is used as row header. If caption is explicitly * specified, it overrides the id-caption. * <li>{@link #ROW_HEADER_MODE_EXPLICIT}: The row headers must be explicitly * specified.</li> * <li>{@link #ROW_HEADER_MODE_INDEX}: The index of the item is used as row * caption. The index mode can only be used with the containers implementing * <code>Container.Indexed</code> interface.</li> * </ul> * The default value is {@link #ROW_HEADER_MODE_HIDDEN} * </p> * * @param mode * the One of the modes listed above. */ public void setRowHeaderMode(RowHeaderMode mode) { if (mode != null) { rowHeaderMode = mode; if (mode != RowHeaderMode.HIDDEN) { setItemCaptionMode(mode.getItemCaptionMode()); } // Assures the visual refresh. No need to reset the page buffer // before // as the content has not changed, only the alignments. refreshRenderedCells(); } } /** * Gets the row header mode. * * @return the Row header mode. * @see #setRowHeaderMode */ public RowHeaderMode getRowHeaderMode() { return rowHeaderMode; } /** * Adds the new row to table and fill the visible cells (except generated * columns) with given values. * * @param cells * the Object array that is used for filling the visible cells * new row. The types must be settable to visible column property * types. * @param itemId * the Id the new row. If null, a new id is automatically * assigned. If given, the table cannot already have a item with * given id. * @return Returns item id for the new row. Returns null if operation fails. */ public Object addItem(Object[] cells, Object itemId) throws UnsupportedOperationException { // remove generated columns from the list of columns being assigned final LinkedList<Object> availableCols = new LinkedList<Object>(); for (Object id : visibleColumns) { if (!columnGenerators.containsKey(id)) { availableCols.add(id); } } // Checks that a correct number of cells are given if (cells.length != availableCols.size()) { return null; } // Creates new item Item item; if (itemId == null) { itemId = items.addItem(); if (itemId == null) { return null; } item = items.getItem(itemId); } else { item = items.addItem(itemId); } if (item == null) { return null; } // Fills the item properties for (int i = 0; i < availableCols.size(); i++) { item.getItemProperty(availableCols.get(i)).setValue(cells[i]); } if (!(items instanceof Container.ItemSetChangeNotifier)) { refreshRowCache(); } return itemId; } /** * Discards and recreates the internal row cache. Call this if you make * changes that affect the rows but the information about the changes are * not automatically propagated to the Table. * <p> * Do not call this e.g. if you have updated the data model through a * Property. These types of changes are automatically propagated to the * Table. * <p> * A typical case when this is needed is if you update a generator (e.g. * CellStyleGenerator) and want to ensure that the rows are redrawn with new * styles. * <p> * <i>Note that calling this method is not cheap so avoid calling it * unnecessarily.</i> * * @since 6.7.2 */ public void refreshRowCache() { resetPageBuffer(); refreshRenderedCells(); } /** * Sets the Container that serves as the data source of the viewer. As a * side-effect the table's selection value is set to null as the old * selection might not exist in new Container.<br> * <br> * All rows and columns are generated as visible using this method. If the * new container contains properties that are not meant to be shown you * should use {@link Table#setContainerDataSource(Container, Collection)} * instead, especially if the table is editable. * <p> * Keeps propertyValueConverters if the corresponding id exists in the new * data source and is of a compatible type. * </p> * * @param newDataSource * the new data source. */ @Override public void setContainerDataSource(Container newDataSource) { if (newDataSource == null) { newDataSource = new IndexedContainer(); } Collection<Object> generated; if (columnGenerators != null) { generated = columnGenerators.keySet(); } else { generated = Collections.emptyList(); } List<Object> visibleIds = new ArrayList<Object>(); if (generated.isEmpty()) { visibleIds.addAll(newDataSource.getContainerPropertyIds()); } else { for (Object id : newDataSource.getContainerPropertyIds()) { // don't add duplicates if (!generated.contains(id)) { visibleIds.add(id); } } // generated columns to the end visibleIds.addAll(generated); } setContainerDataSource(newDataSource, visibleIds); } /** * Sets the container data source and the columns that will be visible. * Columns are shown in the collection's iteration order. * <p> * Keeps propertyValueConverters if the corresponding id exists in the new * data source and is of a compatible type. * </p> * * @see Table#setContainerDataSource(Container) * @see Table#setVisibleColumns(Object[]) * @see Table#setConverter(Object, Converter<String, ?>) * * @param newDataSource * the new data source. * @param visibleIds * IDs of the visible columns */ public void setContainerDataSource(Container newDataSource, Collection<?> visibleIds) { disableContentRefreshing(); if (newDataSource == null) { newDataSource = new IndexedContainer(); } if (visibleIds == null) { visibleIds = new ArrayList<Object>(); } // Retain propertyValueConverters if their corresponding ids are // properties of the new // data source and are of a compatible type if (propertyValueConverters != null) { Collection<?> newPropertyIds = newDataSource.getContainerPropertyIds(); LinkedList<Object> retainableValueConverters = new LinkedList<Object>(); for (Object propertyId : newPropertyIds) { Converter<String, ?> converter = getConverter(propertyId); if (converter != null) { if (typeIsCompatible(converter.getModelType(), newDataSource.getType(propertyId))) { retainableValueConverters.add(propertyId); } } } propertyValueConverters.keySet().retainAll(retainableValueConverters); } // Assures that the data source is ordered by making unordered // containers ordered by wrapping them if (newDataSource instanceof Container.Ordered) { super.setContainerDataSource(newDataSource); } else { super.setContainerDataSource(new ContainerOrderedWrapper(newDataSource)); } // Resets page position currentPageFirstItemId = null; currentPageFirstItemIndex = 0; // Resets column properties if (collapsedColumns != null) { collapsedColumns.clear(); } // don't add the same id twice Collection<Object> col = new LinkedList<Object>(); for (Object id : visibleIds) { if (!col.contains(id)) { col.add(id); } } setVisibleColumns(col.toArray()); // Assure visual refresh resetPageBuffer(); enableContentRefreshing(true); } /** * Checks if class b can be safely assigned to class a. * * @param a * @param b * @return */ private boolean typeIsCompatible(Class<?> a, Class<?> b) { // TODO Implement this check properly // Basically we need to do a a.isAssignableFrom(b) // with special considerations for primitive types. return true; } /** * Gets items ids from a range of key values * * @param itemId * The start key * @param length * amount of items to be retrieved * @return */ private LinkedHashSet<Object> getItemIdsInRange(Object itemId, final int length) { LinkedHashSet<Object> ids = new LinkedHashSet<Object>(); for (int i = 0; i < length; i++) { // should not be null unless client-server are out of sync assert itemId != null; ids.add(itemId); itemId = nextItemId(itemId); } return ids; } /** * Handles selection if selection is a multiselection * * @param variables * The variables */ private void handleSelectedItems(Map<String, Object> variables) { final String[] ka = (String[]) variables.get("selected"); final String[] ranges = (String[]) variables.get("selectedRanges"); Set<Object> renderedButNotSelectedItemIds = getCurrentlyRenderedItemIds(); @SuppressWarnings("unchecked") HashSet<Object> newValue = new LinkedHashSet<Object>((Collection<Object>) getValue()); if (variables.containsKey("clearSelections")) { // the client side has instructed to swipe all previous selections newValue.clear(); } /* * Then add (possibly some of them back) rows that are currently * selected on the client side (the ones that the client side is aware * of). */ for (String k : ka) { // key to id final Object id = itemIdMapper.get(k); if (!isNullSelectionAllowed() && (id == null || id == getNullSelectionItemId())) { // skip empty selection if nullselection is not allowed markAsDirty(); } else if (id != null && containsId(id)) { newValue.add(id); renderedButNotSelectedItemIds.remove(id); } } /* Add range items aka shift clicked multiselection areas */ if (ranges != null) { for (String range : ranges) { String[] split = range.split("-"); Object startItemId = itemIdMapper.get(split[0]); int length = Integer.valueOf(split[1]); LinkedHashSet<Object> itemIdsInRange = getItemIdsInRange(startItemId, length); newValue.addAll(itemIdsInRange); renderedButNotSelectedItemIds.removeAll(itemIdsInRange); } } /* * finally clear all currently rendered rows (the ones that the client * side counterpart is aware of) that the client didn't send as selected */ newValue.removeAll(renderedButNotSelectedItemIds); if (!isNullSelectionAllowed() && newValue.isEmpty()) { // empty selection not allowed, keep old value markAsDirty(); return; } setValue(newValue, true); } private Set<Object> getCurrentlyRenderedItemIds() { HashSet<Object> ids = new HashSet<Object>(); if (pageBuffer != null) { for (Object id : pageBuffer[CELL_ITEMID]) { ids.add(id); } } return ids; } /* Component basics */ /** * Invoked when the value of a variable has changed. * * @see Select#changeVariables(java.lang.Object, java.util.Map) */ @Override public void changeVariables(Object source, Map<String, Object> variables) { boolean clientNeedsContentRefresh = false; handleClickEvent(variables); handleColumnResizeEvent(variables); handleColumnWidthUpdates(variables); disableContentRefreshing(); if (!isSelectable() && variables.containsKey("selected")) { // Not-selectable is a special case, AbstractSelect does not support // TODO could be optimized. variables = new HashMap<String, Object>(variables); variables.remove("selected"); } else if ( /* * The AbstractSelect cannot handle the multiselection properly, instead * we handle it ourself */ isSelectable() && isMultiSelect() && variables.containsKey("selected") && multiSelectMode == MultiSelectMode.DEFAULT) { handleSelectedItems(variables); variables = new HashMap<String, Object>(variables); variables.remove("selected"); } super.changeVariables(source, variables); // Client might update the pagelength if Table height is fixed if (variables.containsKey("pagelength")) { // Sets pageLength directly to avoid repaint that setter causes pageLength = (Integer) variables.get("pagelength"); } // Page start index if (variables.containsKey("firstvisible")) { final Integer value = (Integer) variables.get("firstvisible"); if (value != null) { setCurrentPageFirstItemIndex(value.intValue(), false); } } // Sets requested firstrow and rows for the next paint if (variables.containsKey("reqfirstrow") || variables.containsKey("reqrows")) { try { firstToBeRenderedInClient = ((Integer) variables.get("firstToBeRendered")).intValue(); lastToBeRenderedInClient = ((Integer) variables.get("lastToBeRendered")).intValue(); } catch (Exception e) { // FIXME: Handle exception getLogger().log(Level.FINER, "Could not parse the first and/or last rows.", e); } // respect suggested rows only if table is not otherwise updated // (row caches emptied by other event) if (!containerChangeToBeRendered) { Integer value = (Integer) variables.get("reqfirstrow"); if (value != null) { reqFirstRowToPaint = value.intValue(); } value = (Integer) variables.get("reqrows"); if (value != null) { reqRowsToPaint = value.intValue(); int size = size(); // sanity check if (reqFirstRowToPaint >= size) { reqFirstRowToPaint = size; } if (reqFirstRowToPaint + reqRowsToPaint > size) { reqRowsToPaint = size - reqFirstRowToPaint; } } } if (getLogger().isLoggable(Level.FINEST)) { getLogger().log(Level.FINEST, "Client wants rows {0}-{1}", new Object[] { reqFirstRowToPaint, (reqFirstRowToPaint + reqRowsToPaint - 1) }); } clientNeedsContentRefresh = true; } if (isSortEnabled()) { // Sorting boolean doSort = false; if (variables.containsKey("sortcolumn")) { final String colId = (String) variables.get("sortcolumn"); if (colId != null && !"".equals(colId) && !"null".equals(colId)) { final Object id = columnIdMap.get(colId); setSortContainerPropertyId(id, false); doSort = true; } } if (variables.containsKey("sortascending")) { final boolean state = ((Boolean) variables.get("sortascending")).booleanValue(); if (state != sortAscending) { setSortAscending(state, false); doSort = true; } } if (doSort) { this.sort(); resetPageBuffer(); } } // Dynamic column hide/show and order // Update visible columns if (isColumnCollapsingAllowed()) { if (variables.containsKey("collapsedcolumns")) { try { final Object[] ids = (Object[]) variables.get("collapsedcolumns"); Set<Object> idSet = new HashSet<Object>(); for (Object id : ids) { idSet.add(columnIdMap.get(id.toString())); } for (final Object propertyId : visibleColumns) { if (isColumnCollapsed(propertyId)) { if (!idSet.contains(propertyId)) { setColumnCollapsed(propertyId, false); } } else if (idSet.contains(propertyId)) { setColumnCollapsed(propertyId, true); } } } catch (final Exception e) { // FIXME: Handle exception getLogger().log(Level.FINER, "Could not determine column collapsing state", e); } clientNeedsContentRefresh = true; } } if (isColumnReorderingAllowed()) { if (variables.containsKey("columnorder")) { try { final Object[] ids = (Object[]) variables.get("columnorder"); // need a real Object[], ids can be a String[] final Object[] idsTemp = new Object[ids.length]; for (int i = 0; i < ids.length; i++) { idsTemp[i] = columnIdMap.get(ids[i].toString()); } setColumnOrder(idsTemp); if (hasListeners(ColumnReorderEvent.class)) { fireEvent(new ColumnReorderEvent(this)); } } catch (final Exception e) { // FIXME: Handle exception getLogger().log(Level.FINER, "Could not determine column reordering state", e); } clientNeedsContentRefresh = true; } } enableContentRefreshing(clientNeedsContentRefresh); // Actions if (variables.containsKey("action")) { final StringTokenizer st = new StringTokenizer((String) variables.get("action"), ","); if (st.countTokens() == 2) { final Object itemId = itemIdMapper.get(st.nextToken()); final Action action = actionMapper.get(st.nextToken()); if (action != null && (itemId == null || containsId(itemId)) && actionHandlers != null) { for (Handler ah : actionHandlers) { ah.handleAction(action, this, itemId); } } } } } /** * Handles click event * * @param variables */ private void handleClickEvent(Map<String, Object> variables) { // Item click event if (variables.containsKey("clickEvent")) { String key = (String) variables.get("clickedKey"); Object itemId = itemIdMapper.get(key); Object propertyId = null; String colkey = (String) variables.get("clickedColKey"); // click is not necessary on a property if (colkey != null) { propertyId = columnIdMap.get(colkey); } MouseEventDetails evt = MouseEventDetails.deSerialize((String) variables.get("clickEvent")); Item item = getItem(itemId); if (item != null) { fireEvent(new ItemClickEvent(this, item, itemId, propertyId, evt)); } } else if ( // Header click event variables.containsKey("headerClickEvent")) { MouseEventDetails details = MouseEventDetails.deSerialize((String) variables.get("headerClickEvent")); Object cid = variables.get("headerClickCID"); Object propertyId = null; if (cid != null) { propertyId = columnIdMap.get(cid.toString()); } fireEvent(new HeaderClickEvent(this, propertyId, details)); } else if ( // Footer click event variables.containsKey("footerClickEvent")) { MouseEventDetails details = MouseEventDetails.deSerialize((String) variables.get("footerClickEvent")); Object cid = variables.get("footerClickCID"); Object propertyId = null; if (cid != null) { propertyId = columnIdMap.get(cid.toString()); } fireEvent(new FooterClickEvent(this, propertyId, details)); } } /** * Handles the column resize event sent by the client. * * @param variables */ private void handleColumnResizeEvent(Map<String, Object> variables) { if (variables.containsKey("columnResizeEventColumn")) { Object cid = variables.get("columnResizeEventColumn"); Object propertyId = null; if (cid != null) { propertyId = columnIdMap.get(cid.toString()); Object prev = variables.get("columnResizeEventPrev"); int previousWidth = -1; if (prev != null) { previousWidth = Integer.valueOf(prev.toString()); } Object curr = variables.get("columnResizeEventCurr"); int currentWidth = -1; if (curr != null) { currentWidth = Integer.valueOf(curr.toString()); } fireColumnResizeEvent(propertyId, previousWidth, currentWidth); } } } private void fireColumnCollapseEvent(Object propertyId) { fireEvent(new ColumnCollapseEvent(this, propertyId)); } private void fireColumnResizeEvent(Object propertyId, int previousWidth, int currentWidth) { /* * Update the sizes on the server side. If a column previously had a * expand ratio and the user resized the column then the expand ratio * will be turned into a static pixel size. */ setColumnWidth(propertyId, currentWidth); fireEvent(new ColumnResizeEvent(this, propertyId, previousWidth, currentWidth)); } private void handleColumnWidthUpdates(Map<String, Object> variables) { if (variables.containsKey("columnWidthUpdates")) { String[] events = (String[]) variables.get("columnWidthUpdates"); for (String str : events) { String[] eventDetails = str.split(":"); Object propertyId = columnIdMap.get(eventDetails[0]); if (propertyId == null) { propertyId = ROW_HEADER_FAKE_PROPERTY_ID; } int width = Integer.valueOf(eventDetails[1]); setColumnWidth(propertyId, width); } } } /** * Go to mode where content updates are not done. This is due we want to * bypass expensive content for some reason (like when we know we may have * other content changes on their way). * * @return true if content refresh flag was enabled prior this call */ protected boolean disableContentRefreshing() { boolean wasDisabled = isContentRefreshesEnabled; isContentRefreshesEnabled = false; return wasDisabled; } /** * Go to mode where content content refreshing has effect. * * @param refreshContent * true if content refresh needs to be done */ protected void enableContentRefreshing(boolean refreshContent) { isContentRefreshesEnabled = true; if (refreshContent) { refreshRenderedCells(); // Ensure that client gets a response markAsDirty(); } } @Override public void beforeClientResponse(boolean initial) { super.beforeClientResponse(initial); // Ensure pageBuffer is filled before sending the response to avoid // calls to markAsDirty during paint getVisibleCells(); } @Override public void paintContent(PaintTarget target) throws PaintException { isBeingPainted = true; try { doPaintContent(target); } finally { isBeingPainted = false; } } private void doPaintContent(PaintTarget target) throws PaintException { /* * Body actions - Actions which has the target null and can be invoked * by right clicking on the table body. */ final Set<Action> actionSet = findAndPaintBodyActions(target); final Object[][] cells = getVisibleCells(); int rows = findNumRowsToPaint(target, cells); int total = size(); if (shouldHideNullSelectionItem()) { total--; rows--; } // Table attributes paintTableAttributes(target, rows, total); paintVisibleColumnOrder(target); // Rows if (isPartialRowUpdate() && painted && !target.isFullRepaint()) { paintPartialRowUpdate(target, actionSet); } else if (target.isFullRepaint() || isRowCacheInvalidated()) { paintRows(target, cells, actionSet); setRowCacheInvalidated(false); } /* * Send the page buffer indexes to ensure that the client side stays in * sync. Otherwise we _might_ have the situation where the client side * discards too few or too many rows, causing out of sync issues. */ int pageBufferLastIndex = pageBufferFirstIndex + pageBuffer[CELL_ITEMID].length - 1; target.addAttribute(TableConstants.ATTRIBUTE_PAGEBUFFER_FIRST, pageBufferFirstIndex); target.addAttribute(TableConstants.ATTRIBUTE_PAGEBUFFER_LAST, pageBufferLastIndex); paintSorting(target); resetVariablesAndPageBuffer(target); // Actions paintActions(target, actionSet); paintColumnOrder(target); // Available columns paintAvailableColumns(target); paintVisibleColumns(target); if (keyMapperReset) { keyMapperReset = false; target.addAttribute(TableConstants.ATTRIBUTE_KEY_MAPPER_RESET, true); } if (dropHandler != null) { dropHandler.getAcceptCriterion().paint(target); } painted = true; } private void setRowCacheInvalidated(boolean invalidated) { rowCacheInvalidated = invalidated; } protected boolean isRowCacheInvalidated() { return rowCacheInvalidated; } private void paintPartialRowUpdate(PaintTarget target, Set<Action> actionSet) throws PaintException { paintPartialRowUpdates(target, actionSet); paintPartialRowAdditions(target, actionSet); } private void paintPartialRowUpdates(PaintTarget target, Set<Action> actionSet) throws PaintException { final boolean[] iscomponent = findCellsWithComponents(); int firstIx = getFirstUpdatedItemIndex(); int count = getUpdatedRowCount(); target.startTag("urows"); target.addAttribute("firsturowix", firstIx); target.addAttribute("numurows", count); // Partial row updates bypass the normal caching mechanism. Object[][] cells = getVisibleCellsUpdateCacheRows(firstIx, count); for (int indexInRowbuffer = 0; indexInRowbuffer < count; indexInRowbuffer++) { final Object itemId = cells[CELL_ITEMID][indexInRowbuffer]; if (shouldHideNullSelectionItem()) { // Remove null selection item if null selection is not allowed continue; } paintRow(target, cells, isEditable(), actionSet, iscomponent, indexInRowbuffer, itemId); } target.endTag("urows"); maybeThrowCacheUpdateExceptions(); } private void paintPartialRowAdditions(PaintTarget target, Set<Action> actionSet) throws PaintException { final boolean[] iscomponent = findCellsWithComponents(); int firstIx = getFirstAddedItemIndex(); int count = getAddedRowCount(); target.startTag("prows"); if (!shouldHideAddedRows()) { getLogger().log(Level.FINEST, "Paint rows for add. Index: {0}, count: {1}.", new Object[] { firstIx, count }); // Partial row additions bypass the normal caching mechanism. Object[][] cells = getVisibleCellsInsertIntoCache(firstIx, count); if (cells[0].length < count) { // delete the rows below, since they will fall beyond the cache // page. target.addAttribute("delbelow", true); count = cells[0].length; } for (int indexInRowbuffer = 0; indexInRowbuffer < count; indexInRowbuffer++) { final Object itemId = cells[CELL_ITEMID][indexInRowbuffer]; if (shouldHideNullSelectionItem()) { // Remove null selection item if null selection is not // allowed continue; } paintRow(target, cells, isEditable(), actionSet, iscomponent, indexInRowbuffer, itemId); } } else { getLogger().log(Level.FINEST, "Paint rows for remove. Index: {0}, count: {1}.", new Object[] { firstIx, count }); removeRowsFromCacheAndFillBottom(firstIx, count); target.addAttribute("hide", true); } target.addAttribute("firstprowix", firstIx); target.addAttribute("numprows", count); target.endTag("prows"); maybeThrowCacheUpdateExceptions(); } /** * Subclass and override this to enable partial row updates and additions, * which bypass the normal caching mechanism. This is useful for e.g. * TreeTable. * * @return true if this update is a partial row update, false if not. For * plain Table it is always false. */ protected boolean isPartialRowUpdate() { return false; } /** * Subclass and override this to enable partial row additions, bypassing the * normal caching mechanism. This is useful for e.g. TreeTable, where * expanding a node should only fetch and add the items inside of that node. * * @return The index of the first added item. For plain Table it is always * 0. */ protected int getFirstAddedItemIndex() { return 0; } /** * Subclass and override this to enable partial row additions, bypassing the * normal caching mechanism. This is useful for e.g. TreeTable, where * expanding a node should only fetch and add the items inside of that node. * * @return the number of rows to be added, starting at the index returned by * {@link #getFirstAddedItemIndex()}. For plain Table it is always * 0. */ protected int getAddedRowCount() { return 0; } /** * Subclass and override this to enable removing of rows, bypassing the * normal caching and lazy loading mechanism. This is useful for e.g. * TreeTable, when you need to hide certain rows as a node is collapsed. * * This should return true if the rows pointed to by * {@link #getFirstAddedItemIndex()} and {@link #getAddedRowCount()} should * be hidden instead of added. * * @return whether the rows to add (see {@link #getFirstAddedItemIndex()} * and {@link #getAddedRowCount()}) should be added or hidden. For * plain Table it is always false. */ protected boolean shouldHideAddedRows() { return false; } /** * Subclass and override this to enable partial row updates, bypassing the * normal caching and lazy loading mechanism. This is useful for updating * the state of certain rows, e.g. in the TreeTable the collapsed state of a * single node is updated using this mechanism. * * @return the index of the first item to be updated. For plain Table it is * always 0. */ protected int getFirstUpdatedItemIndex() { return 0; } /** * Subclass and override this to enable partial row updates, bypassing the * normal caching and lazy loading mechanism. This is useful for updating * the state of certain rows, e.g. in the TreeTable the collapsed state of a * single node is updated using this mechanism. * * @return the number of rows to update, starting at the index returned by * {@link #getFirstUpdatedItemIndex()}. For plain table it is always * 0. */ protected int getUpdatedRowCount() { return 0; } private void paintTableAttributes(PaintTarget target, int rows, int total) throws PaintException { paintTabIndex(target); paintDragMode(target); paintSelectMode(target); paintTableChildLayoutMeasureMode(target); if (cacheRate != CACHE_RATE_DEFAULT) { target.addAttribute("cr", cacheRate); } target.addAttribute("cols", getVisibleColumns().length); target.addAttribute("rows", rows); target.addAttribute("firstrow", (reqFirstRowToPaint >= 0 ? reqFirstRowToPaint : firstToBeRenderedInClient)); target.addAttribute("totalrows", total); if (getPageLength() != 0) { target.addAttribute("pagelength", getPageLength()); } if (areColumnHeadersEnabled()) { target.addAttribute("colheaders", true); } if (rowHeadersAreEnabled()) { target.addAttribute("rowheaders", true); } target.addAttribute("colfooters", columnFootersVisible); // The cursors are only shown on pageable table if (getCurrentPageFirstItemIndex() != 0 || getPageLength() > 0) { target.addVariable(this, "firstvisible", getCurrentPageFirstItemIndex()); target.addVariable(this, "firstvisibleonlastpage", currentPageFirstItemIndexOnLastPage); } } /** * Resets and paints "to be painted next" variables. Also reset pageBuffer */ private void resetVariablesAndPageBuffer(PaintTarget target) throws PaintException { reqFirstRowToPaint = -1; reqRowsToPaint = -1; containerChangeToBeRendered = false; target.addVariable(this, "reqrows", reqRowsToPaint); target.addVariable(this, "reqfirstrow", reqFirstRowToPaint); } private boolean areColumnHeadersEnabled() { return getColumnHeaderMode() != ColumnHeaderMode.HIDDEN; } private void paintVisibleColumns(PaintTarget target) throws PaintException { target.startTag("visiblecolumns"); if (rowHeadersAreEnabled()) { target.startTag("column"); target.addAttribute("cid", ROW_HEADER_COLUMN_KEY); paintColumnWidth(target, ROW_HEADER_FAKE_PROPERTY_ID); paintColumnExpandRatio(target, ROW_HEADER_FAKE_PROPERTY_ID); target.endTag("column"); } final Collection<?> sortables = getSortableContainerPropertyIds(); for (Object colId : visibleColumns) { if (colId != null) { target.startTag("column"); target.addAttribute("cid", columnIdMap.key(colId)); final String head = getColumnHeader(colId); target.addAttribute("caption", (head != null ? head : "")); final String foot = getColumnFooter(colId); target.addAttribute("fcaption", (foot != null ? foot : "")); if (isColumnCollapsed(colId)) { target.addAttribute("collapsed", true); } if (areColumnHeadersEnabled()) { if (getColumnIcon(colId) != null) { target.addAttribute("icon", getColumnIcon(colId)); } if (sortables.contains(colId)) { target.addAttribute("sortable", true); } } if (!Align.LEFT.equals(getColumnAlignment(colId))) { target.addAttribute("align", getColumnAlignment(colId).toString()); } paintColumnWidth(target, colId); paintColumnExpandRatio(target, colId); target.endTag("column"); } } target.endTag("visiblecolumns"); } private void paintAvailableColumns(PaintTarget target) throws PaintException { if (columnCollapsingAllowed) { final HashSet<Object> collapsedCols = new HashSet<Object>(); for (Object colId : visibleColumns) { if (isColumnCollapsed(colId)) { collapsedCols.add(colId); } } final String[] collapsedKeys = new String[collapsedCols.size()]; int nextColumn = 0; for (Object colId : visibleColumns) { if (isColumnCollapsed(colId)) { collapsedKeys[nextColumn++] = columnIdMap.key(colId); } } target.addVariable(this, "collapsedcolumns", collapsedKeys); final String[] noncollapsibleKeys = new String[noncollapsibleColumns.size()]; nextColumn = 0; for (Object colId : noncollapsibleColumns) { noncollapsibleKeys[nextColumn++] = columnIdMap.key(colId); } target.addVariable(this, "noncollapsiblecolumns", noncollapsibleKeys); } } private void paintActions(PaintTarget target, final Set<Action> actionSet) throws PaintException { if (!actionSet.isEmpty()) { target.addVariable(this, "action", ""); target.startTag("actions"); for (Action a : actionSet) { target.startTag("action"); if (a.getCaption() != null) { target.addAttribute("caption", a.getCaption()); } if (a.getIcon() != null) { target.addAttribute("icon", a.getIcon()); } target.addAttribute("key", actionMapper.key(a)); target.endTag("action"); } target.endTag("actions"); } } private void paintColumnOrder(PaintTarget target) throws PaintException { if (columnReorderingAllowed) { final String[] colorder = new String[visibleColumns.size()]; int i = 0; for (Object colId : visibleColumns) { colorder[i++] = columnIdMap.key(colId); } target.addVariable(this, "columnorder", colorder); } } private void paintSorting(PaintTarget target) throws PaintException { // Sorting if (getContainerDataSource() instanceof Container.Sortable) { target.addVariable(this, "sortcolumn", columnIdMap.key(sortContainerPropertyId)); target.addVariable(this, "sortascending", sortAscending); } } private void paintRows(PaintTarget target, final Object[][] cells, final Set<Action> actionSet) throws PaintException { final boolean[] iscomponent = findCellsWithComponents(); target.startTag("rows"); // cells array contains all that are supposed to be visible on client, // but we'll start from the one requested by client int start = 0; if (reqFirstRowToPaint != -1 && firstToBeRenderedInClient != -1) { start = reqFirstRowToPaint - firstToBeRenderedInClient; } int end = cells[0].length; if (reqRowsToPaint != -1) { end = start + reqRowsToPaint; } // sanity check if (lastToBeRenderedInClient != -1 && lastToBeRenderedInClient < end) { end = lastToBeRenderedInClient + 1; } if (start > cells[CELL_ITEMID].length || start < 0) { start = 0; } if (end > cells[CELL_ITEMID].length) { end = cells[CELL_ITEMID].length; } for (int indexInRowbuffer = start; indexInRowbuffer < end; indexInRowbuffer++) { final Object itemId = cells[CELL_ITEMID][indexInRowbuffer]; if (shouldHideNullSelectionItem()) { // Remove null selection item if null selection is not allowed continue; } paintRow(target, cells, isEditable(), actionSet, iscomponent, indexInRowbuffer, itemId); } target.endTag("rows"); } private boolean[] findCellsWithComponents() { final boolean[] isComponent = new boolean[visibleColumns.size()]; int ix = 0; for (Object columnId : visibleColumns) { if (columnGenerators.containsKey(columnId)) { isComponent[ix++] = true; } else { final Class<?> colType = getType(columnId); isComponent[ix++] = colType != null && Component.class.isAssignableFrom(colType); } } return isComponent; } private void paintVisibleColumnOrder(PaintTarget target) { // Visible column order final List<String> visibleColOrder = new ArrayList<String>(); for (Object columnId : visibleColumns) { if (!isColumnCollapsed(columnId)) { visibleColOrder.add(columnIdMap.key(columnId)); } } target.addAttribute("vcolorder", visibleColOrder.toArray()); } private Set<Action> findAndPaintBodyActions(PaintTarget target) { Set<Action> actionSet = new LinkedHashSet<Action>(); if (actionHandlers != null) { final List<String> keys = new ArrayList<String>(); for (Handler ah : actionHandlers) { // Getting actions for the null item, which in this case means // the body item final Action[] actions = ah.getActions(null, this); if (actions != null) { for (Action action : actions) { actionSet.add(action); keys.add(actionMapper.key(action)); } } } target.addAttribute("alb", keys.toArray()); } return actionSet; } private boolean shouldHideNullSelectionItem() { return !isNullSelectionAllowed() && getNullSelectionItemId() != null && containsId(getNullSelectionItemId()); } private int findNumRowsToPaint(PaintTarget target, final Object[][] cells) throws PaintException { int rows; if (reqRowsToPaint >= 0) { rows = reqRowsToPaint; } else { rows = cells[0].length; if (alwaysRecalculateColumnWidths) { // TODO experimental feature for now: tell the client to // recalculate column widths. // We'll only do this for paints that do not originate from // table scroll/cache requests (i.e when reqRowsToPaint<0) target.addAttribute("recalcWidths", true); } } return rows; } private void paintSelectMode(PaintTarget target) throws PaintException { if (multiSelectMode != MultiSelectMode.DEFAULT) { target.addAttribute("multiselectmode", multiSelectMode.ordinal()); } if (isSelectable()) { target.addAttribute("selectmode", (isMultiSelect() ? "multi" : "single")); } else { target.addAttribute("selectmode", "none"); } if (!isNullSelectionAllowed()) { target.addAttribute("nsa", false); } // selection support // The select variable is only enabled if selectable if (isSelectable()) { target.addVariable(this, "selected", findSelectedKeys()); } } private String[] findSelectedKeys() { LinkedList<String> selectedKeys = new LinkedList<String>(); if (isMultiSelect()) { HashSet<?> sel = new HashSet<Object>((Set<?>) getValue()); Collection<?> vids = getVisibleItemIds(); for (Object id : vids) { if (sel.contains(id)) { selectedKeys.add(itemIdMapper.key(id)); } } } else { Object value = getValue(); if (value == null) { value = getNullSelectionItemId(); } if (value != null) { selectedKeys.add(itemIdMapper.key(value)); } } return selectedKeys.toArray(new String[selectedKeys.size()]); } private void paintDragMode(PaintTarget target) throws PaintException { if (dragMode != TableDragMode.NONE) { target.addAttribute("dragmode", dragMode.ordinal()); } } private void paintTabIndex(PaintTarget target) throws PaintException { // The tab ordering number if (getTabIndex() > 0) { target.addAttribute("tabindex", getTabIndex()); } } private void paintColumnWidth(PaintTarget target, final Object columnId) throws PaintException { if (columnWidths.containsKey(columnId)) { target.addAttribute("width", getColumnWidth(columnId)); } } private void paintColumnExpandRatio(PaintTarget target, final Object columnId) throws PaintException { if (columnExpandRatios.containsKey(columnId)) { target.addAttribute("er", getColumnExpandRatio(columnId)); } } private void paintTableChildLayoutMeasureMode(PaintTarget target) throws PaintException { target.addAttribute("measurehint", getChildMeasurementHint().ordinal()); } /** * Checks whether row headers are visible. * * @return {@code false} if row headers are hidden, {@code true} otherwise * @since 7.3.9 */ protected boolean rowHeadersAreEnabled() { return getRowHeaderMode() != RowHeaderMode.HIDDEN; } private void paintRow(PaintTarget target, final Object[][] cells, final boolean iseditable, final Set<Action> actionSet, final boolean[] iscomponent, int indexInRowbuffer, final Object itemId) throws PaintException { target.startTag("tr"); paintRowAttributes(target, cells, actionSet, indexInRowbuffer, itemId); // cells int currentColumn = 0; for (final Iterator<Object> it = visibleColumns.iterator(); it.hasNext(); currentColumn++) { final Object columnId = it.next(); if (columnId == null || isColumnCollapsed(columnId)) { continue; } /* * For each cell, if a cellStyleGenerator is specified, get the * specific style for the cell. If there is any, add it to the * target. */ if (cellStyleGenerator != null) { String cellStyle = cellStyleGenerator.getStyle(this, itemId, columnId); if (cellStyle != null && !cellStyle.equals("")) { target.addAttribute("style-" + columnIdMap.key(columnId), cellStyle); } } if ((iscomponent[currentColumn] || iseditable || cells[CELL_GENERATED_ROW][indexInRowbuffer] != null) && Component.class.isInstance(cells[CELL_FIRSTCOL + currentColumn][indexInRowbuffer])) { final Component c = (Component) cells[CELL_FIRSTCOL + currentColumn][indexInRowbuffer]; if (c == null || !LegacyCommunicationManager.isComponentVisibleToClient(c)) { target.addText(""); } else { LegacyPaint.paint(c, target); } } else { target.addText((String) cells[CELL_FIRSTCOL + currentColumn][indexInRowbuffer]); } paintCellTooltips(target, itemId, columnId); } target.endTag("tr"); } private void paintCellTooltips(PaintTarget target, Object itemId, Object columnId) throws PaintException { if (itemDescriptionGenerator != null) { String itemDescription = itemDescriptionGenerator.generateDescription(this, itemId, columnId); if (itemDescription != null && !itemDescription.equals("")) { target.addAttribute("descr-" + columnIdMap.key(columnId), itemDescription); } } } private void paintRowTooltips(PaintTarget target, Object itemId) throws PaintException { if (itemDescriptionGenerator != null) { String rowDescription = itemDescriptionGenerator.generateDescription(this, itemId, null); if (rowDescription != null && !rowDescription.equals("")) { target.addAttribute("rowdescr", rowDescription); } } } private void paintRowAttributes(PaintTarget target, final Object[][] cells, final Set<Action> actionSet, int indexInRowbuffer, final Object itemId) throws PaintException { // tr attributes paintRowIcon(target, cells, indexInRowbuffer); paintRowHeader(target, cells, indexInRowbuffer); paintGeneratedRowInfo(target, cells, indexInRowbuffer); target.addAttribute("key", Integer.parseInt(cells[CELL_KEY][indexInRowbuffer].toString())); if (isSelected(itemId)) { target.addAttribute("selected", true); } // Actions if (actionHandlers != null) { final List<String> keys = new ArrayList<String>(); for (Handler ah : actionHandlers) { final Action[] aa = ah.getActions(itemId, this); if (aa != null) { for (int ai = 0; ai < aa.length; ai++) { final String key = actionMapper.key(aa[ai]); actionSet.add(aa[ai]); keys.add(key); } } } target.addAttribute("al", keys.toArray()); } /* * For each row, if a cellStyleGenerator is specified, get the specific * style for the cell, using null as propertyId. If there is any, add it * to the target. */ if (cellStyleGenerator != null) { String rowStyle = cellStyleGenerator.getStyle(this, itemId, null); if (rowStyle != null && !rowStyle.equals("")) { target.addAttribute("rowstyle", rowStyle); } } paintRowTooltips(target, itemId); paintRowAttributes(target, itemId); } private void paintGeneratedRowInfo(PaintTarget target, Object[][] cells, int indexInRowBuffer) throws PaintException { GeneratedRow generatedRow = (GeneratedRow) cells[CELL_GENERATED_ROW][indexInRowBuffer]; if (generatedRow != null) { target.addAttribute("gen_html", generatedRow.isHtmlContentAllowed()); target.addAttribute("gen_span", generatedRow.isSpanColumns()); target.addAttribute("gen_widget", generatedRow.getValue() instanceof Component); } } protected void paintRowHeader(PaintTarget target, Object[][] cells, int indexInRowbuffer) throws PaintException { if (rowHeadersAreEnabled()) { if (cells[CELL_HEADER][indexInRowbuffer] != null) { target.addAttribute("caption", (String) cells[CELL_HEADER][indexInRowbuffer]); } } } protected void paintRowIcon(PaintTarget target, final Object[][] cells, int indexInRowbuffer) throws PaintException { if (rowHeadersAreEnabled() && cells[CELL_ICON][indexInRowbuffer] != null) { target.addAttribute("icon", (Resource) cells[CELL_ICON][indexInRowbuffer]); } } /** * A method where extended Table implementations may add their custom * attributes for rows. * * @param target * @param itemId */ protected void paintRowAttributes(PaintTarget target, Object itemId) throws PaintException { } /** * Gets the cached visible table contents. * * @return the cached visible table contents. */ private Object[][] getVisibleCells() { if (pageBuffer == null) { refreshRenderedCells(); } return pageBuffer; } /** * Gets the value of property. * * By default if the table is editable the fieldFactory is used to create * editors for table cells. Otherwise formatPropertyValue is used to format * the value representation. * * @param rowId * the Id of the row (same as item Id). * @param colId * the Id of the column. * @param property * the Property to be presented. * @return Object Either formatted value or Component for field. * @see #setTableFieldFactory(TableFieldFactory) */ protected Object getPropertyValue(Object rowId, Object colId, Property property) { if (isEditable() && fieldFactory != null) { final Field<?> f = fieldFactory.createField(getContainerDataSource(), rowId, colId, this); if (f != null) { // Remember that we have made this association so we can remove // it when the component is removed associatedProperties.put(f, property); bindPropertyToField(rowId, colId, property, f); return f; } } return formatPropertyValue(rowId, colId, property); } /** * Binds an item property to a field generated by TableFieldFactory. The * default behavior is to bind property straight to Field. If * Property.Viewer type property (e.g. PropertyFormatter) is already set for * field, the property is bound to that Property.Viewer. * * @param rowId * @param colId * @param property * @param field * @since 6.7.3 */ protected void bindPropertyToField(Object rowId, Object colId, Property property, Field field) { // check if field has a property that is Viewer set. In that case we // expect developer has e.g. PropertyFormatter that he wishes to use and // assign the property to the Viewer instead. boolean hasFilterProperty = field.getPropertyDataSource() != null && (field.getPropertyDataSource() instanceof Property.Viewer); if (hasFilterProperty) { ((Property.Viewer) field.getPropertyDataSource()).setPropertyDataSource(property); } else { field.setPropertyDataSource(property); } } /** * Formats table cell property values. By default the property.toString() * and return a empty string for null properties. * * @param rowId * the Id of the row (same as item Id). * @param colId * the Id of the column. * @param property * the Property to be formatted. * @return the String representation of property and its value. * @since 3.1 */ protected String formatPropertyValue(Object rowId, Object colId, Property<?> property) { if (property == null) { return ""; } Converter<String, Object> converter = null; if (hasConverter(colId)) { converter = getConverter(colId); } else { converter = (Converter) ConverterUtil.getConverter(String.class, property.getType(), getSession()); } Object value = property.getValue(); if (converter != null) { return converter.convertToPresentation(value, String.class, getLocale()); } return (null != value) ? value.toString() : ""; } /* Action container */ /** * Registers a new action handler for this container. * * @see com.vaadin.event.Action.Container#addActionHandler(Action.Handler) */ @Override public void addActionHandler(Action.Handler actionHandler) { if (actionHandler != null) { if (actionHandlers == null) { actionHandlers = new LinkedList<Handler>(); actionMapper = new KeyMapper<Action>(); } if (!actionHandlers.contains(actionHandler)) { actionHandlers.add(actionHandler); // Assures the visual refresh. No need to reset the page buffer // before as the content has not changed, only the action // handlers. refreshRenderedCells(); } } } /** * Removes a previously registered action handler for the contents of this * container. * * @see com.vaadin.event.Action.Container#removeActionHandler(Action.Handler) */ @Override public void removeActionHandler(Action.Handler actionHandler) { if (actionHandlers != null && actionHandlers.contains(actionHandler)) { actionHandlers.remove(actionHandler); if (actionHandlers.isEmpty()) { actionHandlers = null; actionMapper = null; } // Assures the visual refresh. No need to reset the page buffer // before as the content has not changed, only the action // handlers. refreshRenderedCells(); } } /** * Removes all action handlers. */ public void removeAllActionHandlers() { actionHandlers = null; actionMapper = null; // Assures the visual refresh. No need to reset the page buffer // before as the content has not changed, only the action // handlers. refreshRenderedCells(); } /* Property value change listening support */ /** * Notifies this listener that the Property's value has changed. * * Also listens changes in rendered items to refresh content area. * * @see Property.ValueChangeListener#valueChange(Property.ValueChangeEvent) */ @Override public void valueChange(Property.ValueChangeEvent event) { if (equals(event.getProperty()) || event.getProperty() == getPropertyDataSource()) { super.valueChange(event); } else { refreshRowCache(); containerChangeToBeRendered = true; } markAsDirty(); } /** * Clears the current page buffer. Call this before * {@link #refreshRenderedCells()} to ensure that all content is updated * from the properties. */ protected void resetPageBuffer() { firstToBeRenderedInClient = -1; lastToBeRenderedInClient = -1; reqFirstRowToPaint = -1; reqRowsToPaint = -1; pageBuffer = null; } /** * Notifies the component that it is connected to an application. * * @see Component#attach() */ @Override public void attach() { super.attach(); refreshRenderedCells(); } /** * Notifies the component that it is detached from the application. * * @see Component#detach() */ @Override public void detach() { super.detach(); } /** * Removes all Items from the Container. * * @see Container#removeAllItems() */ @Override public boolean removeAllItems() { currentPageFirstItemId = null; currentPageFirstItemIndex = 0; return super.removeAllItems(); } /** * Removes the Item identified by <code>ItemId</code> from the Container. * * @see Container#removeItem(Object) */ @Override public boolean removeItem(Object itemId) { final Object nextItemId = nextItemId(itemId); final boolean ret = super.removeItem(itemId); if (ret && (itemId != null) && (itemId.equals(currentPageFirstItemId))) { currentPageFirstItemId = nextItemId; } if (!(items instanceof Container.ItemSetChangeNotifier)) { refreshRowCache(); } return ret; } /** * Removes a Property specified by the given Property ID from the Container. * * @see Container#removeContainerProperty(Object) */ @Override public boolean removeContainerProperty(Object propertyId) throws UnsupportedOperationException { // If a visible property is removed, remove the corresponding column visibleColumns.remove(propertyId); columnAlignments.remove(propertyId); columnIcons.remove(propertyId); columnHeaders.remove(propertyId); columnFooters.remove(propertyId); // If a propertyValueConverter was defined for the property, remove it. propertyValueConverters.remove(propertyId); return super.removeContainerProperty(propertyId); } /** * Adds a new property to the table and show it as a visible column. * * @param propertyId * the Id of the property. * @param type * the class of the property. * @param defaultValue * the default value given for all existing items. * @see Container#addContainerProperty(Object, Class, Object) */ @Override public boolean addContainerProperty(Object propertyId, Class<?> type, Object defaultValue) throws UnsupportedOperationException { boolean visibleColAdded = false; if (!visibleColumns.contains(propertyId)) { visibleColumns.add(propertyId); visibleColAdded = true; } if (!super.addContainerProperty(propertyId, type, defaultValue)) { if (visibleColAdded) { visibleColumns.remove(propertyId); } return false; } if (!(items instanceof Container.PropertySetChangeNotifier)) { refreshRowCache(); } return true; } /** * Adds a new property to the table and show it as a visible column. * * @param propertyId * the Id of the property * @param type * the class of the property * @param defaultValue * the default value given for all existing items * @param columnHeader * the Explicit header of the column. If explicit header is not * needed, this should be set null. * @param columnIcon * the Icon of the column. If icon is not needed, this should be * set null. * @param columnAlignment * the Alignment of the column. Null implies align left. * @throws UnsupportedOperationException * if the operation is not supported. * @see Container#addContainerProperty(Object, Class, Object) */ public boolean addContainerProperty(Object propertyId, Class<?> type, Object defaultValue, String columnHeader, Resource columnIcon, Align columnAlignment) throws UnsupportedOperationException { if (!this.addContainerProperty(propertyId, type, defaultValue)) { return false; } setColumnAlignment(propertyId, columnAlignment); setColumnHeader(propertyId, columnHeader); setColumnIcon(propertyId, columnIcon); return true; } /** * Adds a generated column to the Table. * <p> * A generated column is a column that exists only in the Table, not as a * property in the underlying Container. It shows up just as a regular * column. * </p> * <p> * A generated column will override a property with the same id, so that the * generated column is shown instead of the column representing the * property. Note that getContainerProperty() will still get the real * property. * </p> * <p> * Table will not listen to value change events from properties overridden * by generated columns. If the content of your generated column depends on * properties that are not directly visible in the table, attach value * change listener to update the content on all depended properties. * Otherwise your UI might not get updated as expected. * </p> * <p> * Also note that getVisibleColumns() will return the generated columns, * while getContainerPropertyIds() will not. * </p> * * @param id * the id of the column to be added * @param generatedColumn * the {@link ColumnGenerator} to use for this column */ public void addGeneratedColumn(Object id, ColumnGenerator generatedColumn) { if (generatedColumn == null) { throw new IllegalArgumentException("Can not add null as a GeneratedColumn"); } if (columnGenerators.containsKey(id)) { throw new IllegalArgumentException("Can not add the same GeneratedColumn twice, id:" + id); } else { columnGenerators.put(id, generatedColumn); /* * add to visible column list unless already there (overriding * column from DS) */ if (!visibleColumns.contains(id)) { visibleColumns.add(id); } refreshRowCache(); } } /** * Returns the ColumnGenerator used to generate the given column. * * @param columnId * The id of the generated column * @return The ColumnGenerator used for the given columnId or null. */ public ColumnGenerator getColumnGenerator(Object columnId) throws IllegalArgumentException { return columnGenerators.get(columnId); } /** * Removes a generated column previously added with addGeneratedColumn. * * @param columnId * id of the generated column to remove * @return true if the column could be removed (existed in the Table) */ public boolean removeGeneratedColumn(Object columnId) { if (columnGenerators.containsKey(columnId)) { columnGenerators.remove(columnId); // remove column from visibleColumns list unless it exists in // container (generator previously overrode this column) if (!items.getContainerPropertyIds().contains(columnId)) { visibleColumns.remove(columnId); } refreshRowCache(); return true; } else { return false; } } /** * Returns item identifiers of the items which are currently rendered on the * client. * <p> * Note, that some due to historical reasons the name of the method is bit * misleading. Some items may be partly or totally out of the viewport of * the table's scrollable area. Actually detecting rows which can be * actually seen by the end user may be problematic due to the client server * architecture. Using {@link #getCurrentPageFirstItemId()} combined with * {@link #getPageLength()} may produce good enough estimates in some * situations. * * @see Select#getVisibleItemIds() */ @Override public Collection<?> getVisibleItemIds() { final LinkedList<Object> visible = new LinkedList<Object>(); final Object[][] cells = getVisibleCells(); // may be null if the table has not been rendered yet (e.g. not attached // to a layout) if (null != cells) { for (Object id : cells[CELL_ITEMID]) { visible.add(id); } } return visible; } /** * Container datasource item set change. Table must flush its buffers on * change. * * @see Container.ItemSetChangeListener#containerItemSetChange(Container.ItemSetChangeEvent) */ @Override public void containerItemSetChange(Container.ItemSetChangeEvent event) { if (isBeingPainted) { return; } super.containerItemSetChange(event); // super method clears the key map, must inform client about this to // avoid getting invalid keys back (#8584) keyMapperReset = true; int currentFirstItemIndex = getCurrentPageFirstItemIndex(); if (event.getContainer().size() == 0) { repairOnReAddAllRowsDataScrollPositionItemIndex = getCurrentPageFirstItemIndex(); } else { if (repairOnReAddAllRowsDataScrollPositionItemIndex != -1) { currentFirstItemIndex = repairOnReAddAllRowsDataScrollPositionItemIndex; /* * Reset repairOnReAddAllRowsDataScrollPositionItemIndex. * * Next string should be commented (removed) if we want to have * possibility to restore scroll position during adding items to * container one by one via add() but not only addAll(). The * problem in this case: we cannot track what happened between * add() and add()... So it is ambiguous where to stop restore * scroll position. */ repairOnReAddAllRowsDataScrollPositionItemIndex = -1; } } // ensure that page still has first item in page, ignore buffer refresh // (forced in this method) setCurrentPageFirstItemIndex(currentFirstItemIndex, false); refreshRowCache(); } /** * Container datasource property set change. Table must flush its buffers on * change. * * @see Container.PropertySetChangeListener#containerPropertySetChange(Container.PropertySetChangeEvent) */ @Override public void containerPropertySetChange(Container.PropertySetChangeEvent event) { if (isBeingPainted) { return; } disableContentRefreshing(); super.containerPropertySetChange(event); // sanitize visibleColumns. note that we are not adding previously // non-existing properties as columns Collection<?> containerPropertyIds = getContainerDataSource().getContainerPropertyIds(); LinkedList<Object> newVisibleColumns = new LinkedList<Object>(visibleColumns); for (Iterator<Object> iterator = newVisibleColumns.iterator(); iterator.hasNext();) { Object id = iterator.next(); if (!(containerPropertyIds.contains(id) || columnGenerators.containsKey(id))) { iterator.remove(); } } setVisibleColumns(newVisibleColumns.toArray()); // same for collapsed columns for (Iterator<Object> iterator = collapsedColumns.iterator(); iterator.hasNext();) { Object id = iterator.next(); if (!(containerPropertyIds.contains(id) || columnGenerators.containsKey(id))) { iterator.remove(); } } resetPageBuffer(); enableContentRefreshing(true); } /** * Adding new items is not supported. * * @throws UnsupportedOperationException * if set to true. * @see Select#setNewItemsAllowed(boolean) */ @Override public void setNewItemsAllowed(boolean allowNewOptions) throws UnsupportedOperationException { if (allowNewOptions) { throw new UnsupportedOperationException(); } } /** * Gets the ID of the Item following the Item that corresponds to itemId. * * @see Container.Ordered#nextItemId(java.lang.Object) */ @Override public Object nextItemId(Object itemId) { return ((Container.Ordered) items).nextItemId(itemId); } /** * Gets the ID of the Item preceding the Item that corresponds to the * itemId. * * @see Container.Ordered#prevItemId(java.lang.Object) */ @Override public Object prevItemId(Object itemId) { return ((Container.Ordered) items).prevItemId(itemId); } /** * Gets the ID of the first Item in the Container. * * @see Container.Ordered#firstItemId() */ @Override public Object firstItemId() { return ((Container.Ordered) items).firstItemId(); } /** * Gets the ID of the last Item in the Container. * * @see Container.Ordered#lastItemId() */ @Override public Object lastItemId() { return ((Container.Ordered) items).lastItemId(); } /** * Tests if the Item corresponding to the given Item ID is the first Item in * the Container. * * @see Container.Ordered#isFirstId(java.lang.Object) */ @Override public boolean isFirstId(Object itemId) { return ((Container.Ordered) items).isFirstId(itemId); } /** * Tests if the Item corresponding to the given Item ID is the last Item in * the Container. * * @see Container.Ordered#isLastId(java.lang.Object) */ @Override public boolean isLastId(Object itemId) { return ((Container.Ordered) items).isLastId(itemId); } /** * Adds new item after the given item. * * @see Container.Ordered#addItemAfter(java.lang.Object) */ @Override public Object addItemAfter(Object previousItemId) throws UnsupportedOperationException { Object itemId = ((Container.Ordered) items).addItemAfter(previousItemId); if (!(items instanceof Container.ItemSetChangeNotifier)) { refreshRowCache(); } return itemId; } /** * Adds new item after the given item. * * @see Container.Ordered#addItemAfter(java.lang.Object, java.lang.Object) */ @Override public Item addItemAfter(Object previousItemId, Object newItemId) throws UnsupportedOperationException { Item item = ((Container.Ordered) items).addItemAfter(previousItemId, newItemId); if (!(items instanceof Container.ItemSetChangeNotifier)) { refreshRowCache(); } return item; } /** * Sets the TableFieldFactory that is used to create editor for table cells. * * The TableFieldFactory is only used if the Table is editable. By default * the DefaultFieldFactory is used. * * @param fieldFactory * the field factory to set. * @see #isEditable * @see DefaultFieldFactory */ public void setTableFieldFactory(TableFieldFactory fieldFactory) { this.fieldFactory = fieldFactory; // Assure visual refresh refreshRowCache(); } /** * Gets the TableFieldFactory that is used to create editor for table cells. * * The FieldFactory is only used if the Table is editable. * * @return TableFieldFactory used to create the Field instances. * @see #isEditable */ public TableFieldFactory getTableFieldFactory() { return fieldFactory; } /** * Is table editable. * * If table is editable a editor of type Field is created for each table * cell. The assigned FieldFactory is used to create the instances. * * To provide custom editors for table cells create a class implementing the * FieldFactory interface, and assign it to table, and set the editable * property to true. * * @return true if table is editable, false otherwise. * @see Field * @see FieldFactory * */ public boolean isEditable() { return editable; } /** * Sets the editable property. * * If table is editable a editor of type Field is created for each table * cell. The assigned FieldFactory is used to create the instances. * * To provide custom editors for table cells create a class implementing the * FieldFactory interface, and assign it to table, and set the editable * property to true. * * @param editable * true if table should be editable by user. * @see Field * @see FieldFactory * */ public void setEditable(boolean editable) { this.editable = editable; // Assure visual refresh refreshRowCache(); } /** * Sorts the table. * * @throws UnsupportedOperationException * if the container data source does not implement * Container.Sortable * @see Container.Sortable#sort(java.lang.Object[], boolean[]) * */ @Override public void sort(Object[] propertyId, boolean[] ascending) throws UnsupportedOperationException { final Container c = getContainerDataSource(); if (c instanceof Container.Sortable) { final int pageIndex = getCurrentPageFirstItemIndex(); boolean refreshingPreviouslyEnabled = disableContentRefreshing(); ((Container.Sortable) c).sort(propertyId, ascending); setCurrentPageFirstItemIndex(pageIndex); if (refreshingPreviouslyEnabled) { enableContentRefreshing(true); } if (propertyId.length > 0 && ascending.length > 0) { // The first propertyId is the primary sorting criterion, // therefore the sort indicator should be there sortAscending = ascending[0]; sortContainerPropertyId = propertyId[0]; } else { sortAscending = true; sortContainerPropertyId = null; } } else if (c != null) { throw new UnsupportedOperationException("Underlying Data does not allow sorting"); } } /** * Sorts the table by currently selected sorting column. * * @throws UnsupportedOperationException * if the container data source does not implement * Container.Sortable */ public void sort() { if (getSortContainerPropertyId() == null) { return; } sort(new Object[] { sortContainerPropertyId }, new boolean[] { sortAscending }); } /** * Gets the container property IDs, which can be used to sort the item. * <p> * Note that the {@link #isSortEnabled()} state affects what this method * returns. Disabling sorting causes this method to always return an empty * collection. * </p> * * @see Container.Sortable#getSortableContainerPropertyIds() */ @Override public Collection<?> getSortableContainerPropertyIds() { final Container c = getContainerDataSource(); if (c instanceof Container.Sortable && isSortEnabled()) { return ((Container.Sortable) c).getSortableContainerPropertyIds(); } else { return Collections.EMPTY_LIST; } } /** * Gets the currently sorted column property ID. * * @return the Container property id of the currently sorted column. */ public Object getSortContainerPropertyId() { return sortContainerPropertyId; } /** * Sets the currently sorted column property id. * * @param propertyId * the Container property id of the currently sorted column. */ public void setSortContainerPropertyId(Object propertyId) { setSortContainerPropertyId(propertyId, true); } /** * Internal method to set currently sorted column property id. With doSort * flag actual sorting may be bypassed. * * @param propertyId * @param doSort */ private void setSortContainerPropertyId(Object propertyId, boolean doSort) { if ((sortContainerPropertyId != null && !sortContainerPropertyId.equals(propertyId)) || (sortContainerPropertyId == null && propertyId != null)) { sortContainerPropertyId = propertyId; if (doSort) { sort(); // Assures the visual refresh. This should not be necessary as // sort() calls refreshRowCache refreshRenderedCells(); } } } /** * Is the table currently sorted in ascending order. * * @return <code>true</code> if ascending, <code>false</code> if descending. */ public boolean isSortAscending() { return sortAscending; } /** * Sets the table in ascending order. * * @param ascending * <code>true</code> if ascending, <code>false</code> if * descending. */ public void setSortAscending(boolean ascending) { setSortAscending(ascending, true); } /** * Internal method to set sort ascending. With doSort flag actual sort can * be bypassed. * * @param ascending * @param doSort */ private void setSortAscending(boolean ascending, boolean doSort) { if (sortAscending != ascending) { sortAscending = ascending; if (doSort) { sort(); // Assures the visual refresh. This should not be necessary as // sort() calls refreshRowCache refreshRenderedCells(); } } } /** * Is sorting disabled altogether. * * True if no sortable columns are given even in the case where data source * would support this. * * @return True if sorting is disabled. * @deprecated As of 7.0, use {@link #isSortEnabled()} instead */ @Deprecated public boolean isSortDisabled() { return !isSortEnabled(); } /** * Checks if sorting is enabled. * * @return true if sorting by the user is allowed, false otherwise */ public boolean isSortEnabled() { return sortEnabled; } /** * Disables the sorting by the user altogether. * * @param sortDisabled * True if sorting is disabled. * @deprecated As of 7.0, use {@link #setSortEnabled(boolean)} instead */ @Deprecated public void setSortDisabled(boolean sortDisabled) { setSortEnabled(!sortDisabled); } /** * Enables or disables sorting. * <p> * Setting this to false disallows sorting by the user. It is still possible * to call {@link #sort()}. * </p> * * @param sortEnabled * true to allow the user to sort the table, false to disallow it */ public void setSortEnabled(boolean sortEnabled) { if (this.sortEnabled != sortEnabled) { this.sortEnabled = sortEnabled; markAsDirty(); } } /** * Used to create "generated columns"; columns that exist only in the Table, * not in the underlying Container. Implement this interface and pass it to * Table.addGeneratedColumn along with an id for the column to be generated. * */ @Deprecated public interface ColumnGenerator extends Serializable { /** * Called by Table when a cell in a generated column needs to be * generated. * * @param source * the source Table * @param itemId * the itemId (aka rowId) for the of the cell to be generated * @param columnId * the id for the generated column (as specified in * addGeneratedColumn) * @return A {@link Component} that should be rendered in the cell or a * {@link String} that should be displayed in the cell. Other * return values are not supported. */ public abstract Object generateCell(Table source, Object itemId, Object columnId); } /** * Set cell style generator for Table. * * @param cellStyleGenerator * New cell style generator or null to remove generator. */ public void setCellStyleGenerator(CellStyleGenerator cellStyleGenerator) { this.cellStyleGenerator = cellStyleGenerator; // Assures the visual refresh. No need to reset the page buffer // before as the content has not changed, only the style generators refreshRenderedCells(); } /** * Get the current cell style generator. * */ public CellStyleGenerator getCellStyleGenerator() { return cellStyleGenerator; } /** * Allow to define specific style on cells (and rows) contents. Implements * this interface and pass it to Table.setCellStyleGenerator. Row styles are * generated when porpertyId is null. The CSS class name that will be added * to the cell content is <tt>v-table-cell-content-[style name]</tt>, and * the row style will be <tt>v-table-row-[style name]</tt>. */ @Deprecated public interface CellStyleGenerator extends Serializable { /** * Called by Table when a cell (and row) is painted. * * @param source * the source Table * @param itemId * The itemId of the painted cell * @param propertyId * The propertyId of the cell, null when getting row style * @return The style name to add to this cell or row. (the CSS class * name will be v-table-cell-content-[style name], or * v-table-row-[style name] for rows) */ public abstract String getStyle(Table source, Object itemId, Object propertyId); } @Override public void addItemClickListener(ItemClickListener listener) { addListener(TableConstants.ITEM_CLICK_EVENT_ID, ItemClickEvent.class, listener, ItemClickEvent.ITEM_CLICK_METHOD); } /** * @deprecated As of 7.0, replaced by * {@link #addItemClickListener(ItemClickListener)} */ @Override @Deprecated public void addListener(ItemClickListener listener) { addItemClickListener(listener); } @Override public void removeItemClickListener(ItemClickListener listener) { removeListener(TableConstants.ITEM_CLICK_EVENT_ID, ItemClickEvent.class, listener); } /** * @deprecated As of 7.0, replaced by * {@link #removeItemClickListener(ItemClickListener)} */ @Override @Deprecated public void removeListener(ItemClickListener listener) { removeItemClickListener(listener); } // Identical to AbstractCompoenentContainer.setEnabled(); @Override public void setEnabled(boolean enabled) { super.setEnabled(enabled); if (getParent() != null && !getParent().isEnabled()) { // some ancestor still disabled, don't update children return; } else { markAsDirtyRecursive(); } } /** * Sets the drag start mode of the Table. Drag start mode controls how Table * behaves as a drag source. * * @param newDragMode */ public void setDragMode(TableDragMode newDragMode) { dragMode = newDragMode; markAsDirty(); } /** * @return the current start mode of the Table. Drag start mode controls how * Table behaves as a drag source. */ public TableDragMode getDragMode() { return dragMode; } /** * Concrete implementation of {@link DataBoundTransferable} for data * transferred from a table. * * @see DataBoundTransferable * * @since 6.3 */ @Deprecated public class TableTransferable extends DataBoundTransferable { protected TableTransferable(Map<String, Object> rawVariables) { super(Table.this, rawVariables); Object object = rawVariables.get("itemId"); if (object != null) { setData("itemId", itemIdMapper.get((String) object)); } object = rawVariables.get("propertyId"); if (object != null) { setData("propertyId", columnIdMap.get((String) object)); } } @Override public Object getItemId() { return getData("itemId"); } @Override public Object getPropertyId() { return getData("propertyId"); } @Override public Table getSourceComponent() { return (Table) super.getSourceComponent(); } } @Override public TableTransferable getTransferable(Map<String, Object> rawVariables) { TableTransferable transferable = new TableTransferable(rawVariables); return transferable; } @Override public DropHandler getDropHandler() { return dropHandler; } public void setDropHandler(DropHandler dropHandler) { this.dropHandler = dropHandler; } @Override public AbstractSelectTargetDetails translateDropTargetDetails(Map<String, Object> clientVariables) { return new AbstractSelectTargetDetails(clientVariables); } /** * Sets the behavior of how the multi-select mode should behave when the * table is both selectable and in multi-select mode. * <p> * Note, that on some clients the mode may not be respected. E.g. on touch * based devices CTRL/SHIFT base selection method is invalid, so touch based * browsers always use the {@link MultiSelectMode#SIMPLE}. * * @param mode * The select mode of the table */ public void setMultiSelectMode(MultiSelectMode mode) { multiSelectMode = mode; markAsDirty(); } /** * Returns the select mode in which multi-select is used. * * @return The multi select mode */ public MultiSelectMode getMultiSelectMode() { return multiSelectMode; } /** * Lazy loading accept criterion for Table. Accepted target rows are loaded * from server once per drag and drop operation. Developer must override one * method that decides on which rows the currently dragged data can be * dropped. * * <p> * Initially pretty much no data is sent to client. On first required * criterion check (per drag request) the client side data structure is * initialized from server and no subsequent requests requests are needed * during that drag and drop operation. */ @Deprecated public abstract static class TableDropCriterion extends ServerSideCriterion { private Table table; private Set<Object> allowedItemIds; /* * (non-Javadoc) * * @see * com.vaadin.event.dd.acceptcriteria.ServerSideCriterion#getIdentifier * () */ @Override protected String getIdentifier() { return TableDropCriterion.class.getCanonicalName(); } /* * (non-Javadoc) * * @see * com.vaadin.event.dd.acceptcriteria.AcceptCriterion#accepts(com.vaadin * .event.dd.DragAndDropEvent) */ @Override @SuppressWarnings("unchecked") public boolean accept(DragAndDropEvent dragEvent) { AbstractSelectTargetDetails dropTargetData = (AbstractSelectTargetDetails) dragEvent.getTargetDetails(); table = (Table) dragEvent.getTargetDetails().getTarget(); Collection<?> visibleItemIds = table.getVisibleItemIds(); allowedItemIds = getAllowedItemIds(dragEvent, table, (Collection<Object>) visibleItemIds); return allowedItemIds.contains(dropTargetData.getItemIdOver()); } /* * (non-Javadoc) * * @see * com.vaadin.event.dd.acceptcriteria.AcceptCriterion#paintResponse( * com.vaadin.server.PaintTarget) */ @Override public void paintResponse(PaintTarget target) throws PaintException { /* * send allowed nodes to client so subsequent requests can be * avoided */ Object[] array = allowedItemIds.toArray(); for (int i = 0; i < array.length; i++) { String key = table.itemIdMapper.key(array[i]); array[i] = key; } target.addAttribute("allowedIds", array); } /** * @param dragEvent * @param table * the table for which the allowed item identifiers are * defined * @param visibleItemIds * the list of currently rendered item identifiers, accepted * item id's need to be detected only for these visible items * @return the set of identifiers for items on which the dragEvent will * be accepted */ protected abstract Set<Object> getAllowedItemIds(DragAndDropEvent dragEvent, Table table, Collection<Object> visibleItemIds); } /** * Click event fired when clicking on the Table headers. The event includes * a reference the the Table the event originated from, the property id of * the column which header was pressed and details about the mouse event * itself. */ @Deprecated public static class HeaderClickEvent extends ClickEvent { public static final Method HEADER_CLICK_METHOD; static { try { // Set the header click method HEADER_CLICK_METHOD = HeaderClickListener.class.getDeclaredMethod("headerClick", new Class[] { HeaderClickEvent.class }); } catch (final NoSuchMethodException e) { // This should never happen throw new RuntimeException(e); } } // The property id of the column which header was pressed private final Object columnPropertyId; public HeaderClickEvent(Component source, Object propertyId, MouseEventDetails details) { super(source, details); columnPropertyId = propertyId; } /** * Gets the property id of the column which header was pressed. * * @return The column property id */ public Object getPropertyId() { return columnPropertyId; } } /** * Click event fired when clicking on the Table footers. The event includes * a reference the the Table the event originated from, the property id of * the column which header was pressed and details about the mouse event * itself. */ @Deprecated public static class FooterClickEvent extends ClickEvent { public static final Method FOOTER_CLICK_METHOD; static { try { // Set the header click method FOOTER_CLICK_METHOD = FooterClickListener.class.getDeclaredMethod("footerClick", new Class[] { FooterClickEvent.class }); } catch (final NoSuchMethodException e) { // This should never happen throw new RuntimeException(e); } } // The property id of the column which header was pressed private final Object columnPropertyId; /** * Constructor. * * @param source * The source of the component * @param propertyId * The propertyId of the column * @param details * The mouse details of the click */ public FooterClickEvent(Component source, Object propertyId, MouseEventDetails details) { super(source, details); columnPropertyId = propertyId; } /** * Gets the property id of the column which header was pressed. * * @return The column property id */ public Object getPropertyId() { return columnPropertyId; } } /** * Interface for the listener for column header mouse click events. The * headerClick method is called when the user presses a header column cell. */ @Deprecated public interface HeaderClickListener extends Serializable { /** * Called when a user clicks a header column cell. * * @param event * The event which contains information about the column and * the mouse click event */ public void headerClick(HeaderClickEvent event); } /** * Interface for the listener for column footer mouse click events. The * footerClick method is called when the user presses a footer column cell. */ @Deprecated public interface FooterClickListener extends Serializable { /** * Called when a user clicks a footer column cell. * * @param event * The event which contains information about the column and * the mouse click event */ public void footerClick(FooterClickEvent event); } /** * Adds a header click listener which handles the click events when the user * clicks on a column header cell in the Table. * <p> * The listener will receive events which contain information about which * column was clicked and some details about the mouse event. * </p> * * @param listener * The handler which should handle the header click events. */ public void addHeaderClickListener(HeaderClickListener listener) { addListener(TableConstants.HEADER_CLICK_EVENT_ID, HeaderClickEvent.class, listener, HeaderClickEvent.HEADER_CLICK_METHOD); } /** * @deprecated As of 7.0, replaced by * {@link #addHeaderClickListener(HeaderClickListener)} */ @Deprecated public void addListener(HeaderClickListener listener) { addHeaderClickListener(listener); } /** * Removes a header click listener. * * @param listener * The listener to remove. */ public void removeHeaderClickListener(HeaderClickListener listener) { removeListener(TableConstants.HEADER_CLICK_EVENT_ID, HeaderClickEvent.class, listener); } /** * @deprecated As of 7.0, replaced by * {@link #removeHeaderClickListener(HeaderClickListener)} */ @Deprecated public void removeListener(HeaderClickListener listener) { removeHeaderClickListener(listener); } /** * Adds a footer click listener which handles the click events when the user * clicks on a column footer cell in the Table. * <p> * The listener will receive events which contain information about which * column was clicked and some details about the mouse event. * </p> * * @param listener * The handler which should handle the footer click events. */ public void addFooterClickListener(FooterClickListener listener) { addListener(TableConstants.FOOTER_CLICK_EVENT_ID, FooterClickEvent.class, listener, FooterClickEvent.FOOTER_CLICK_METHOD); } /** * @deprecated As of 7.0, replaced by * {@link #addFooterClickListener(FooterClickListener)} */ @Deprecated public void addListener(FooterClickListener listener) { addFooterClickListener(listener); } /** * Removes a footer click listener. * * @param listener * The listener to remove. */ public void removeFooterClickListener(FooterClickListener listener) { removeListener(TableConstants.FOOTER_CLICK_EVENT_ID, FooterClickEvent.class, listener); } /** * @deprecated As of 7.0, replaced by * {@link #removeFooterClickListener(FooterClickListener)} */ @Deprecated public void removeListener(FooterClickListener listener) { removeFooterClickListener(listener); } /** * Gets the footer caption beneath the rows. * * @param propertyId * The propertyId of the column * * @return The caption of the footer or NULL if not set */ public String getColumnFooter(Object propertyId) { return columnFooters.get(propertyId); } /** * Sets the column footer caption. The column footer caption is the text * displayed beneath the column if footers have been set visible. * * @param propertyId * The properyId of the column * * @param footer * The caption of the footer */ public void setColumnFooter(Object propertyId, String footer) { if (footer == null) { columnFooters.remove(propertyId); } else { columnFooters.put(propertyId, footer); } markAsDirty(); } /** * Sets the footer visible in the bottom of the table. * <p> * The footer can be used to add column related data like sums to the bottom * of the Table using setColumnFooter(Object propertyId, String footer). * </p> * * @param visible * Should the footer be visible */ public void setFooterVisible(boolean visible) { if (visible != columnFootersVisible) { columnFootersVisible = visible; markAsDirty(); } } /** * Is the footer currently visible? * * @return Returns true if visible else false */ public boolean isFooterVisible() { return columnFootersVisible; } /** * This event is fired when a column is resized. The event contains the * columns property id which was fired, the previous width of the column and * the width of the column after the resize. */ @Deprecated public static class ColumnResizeEvent extends Component.Event { public static final Method COLUMN_RESIZE_METHOD; static { try { COLUMN_RESIZE_METHOD = ColumnResizeListener.class.getDeclaredMethod("columnResize", new Class[] { ColumnResizeEvent.class }); } catch (final NoSuchMethodException e) { // This should never happen throw new RuntimeException(e); } } private final int previousWidth; private final int currentWidth; private final Object columnPropertyId; /** * Constructor. * * @param source * The source of the event * @param propertyId * The columns property id * @param previous * The width in pixels of the column before the resize event * @param current * The width in pixels of the column after the resize event */ public ColumnResizeEvent(Component source, Object propertyId, int previous, int current) { super(source); previousWidth = previous; currentWidth = current; columnPropertyId = propertyId; } /** * Get the column property id of the column that was resized. * * @return The column property id */ public Object getPropertyId() { return columnPropertyId; } /** * Get the width in pixels of the column before the resize event. * * @return Width in pixels */ public int getPreviousWidth() { return previousWidth; } /** * Get the width in pixels of the column after the resize event. * * @return Width in pixels */ public int getCurrentWidth() { return currentWidth; } } /** * Interface for listening to column resize events. */ @Deprecated public interface ColumnResizeListener extends Serializable { /** * This method is triggered when the column has been resized. * * @param event * The event which contains the column property id, the * previous width of the column and the current width of the * column */ public void columnResize(ColumnResizeEvent event); } /** * Adds a column resize listener to the Table. A column resize listener is * called when a user resizes a columns width. * * @param listener * The listener to attach to the Table */ public void addColumnResizeListener(ColumnResizeListener listener) { addListener(TableConstants.COLUMN_RESIZE_EVENT_ID, ColumnResizeEvent.class, listener, ColumnResizeEvent.COLUMN_RESIZE_METHOD); } /** * @deprecated As of 7.0, replaced by * {@link #addColumnResizeListener(ColumnResizeListener)} */ @Deprecated public void addListener(ColumnResizeListener listener) { addColumnResizeListener(listener); } /** * Removes a column resize listener from the Table. * * @param listener * The listener to remove */ public void removeColumnResizeListener(ColumnResizeListener listener) { removeListener(TableConstants.COLUMN_RESIZE_EVENT_ID, ColumnResizeEvent.class, listener); } /** * @deprecated As of 7.0, replaced by * {@link #removeColumnResizeListener(ColumnResizeListener)} */ @Deprecated public void removeListener(ColumnResizeListener listener) { removeColumnResizeListener(listener); } /** * This event is fired when a columns are reordered by the end user user. */ @Deprecated public static class ColumnReorderEvent extends Component.Event { public static final Method METHOD; static { try { METHOD = ColumnReorderListener.class.getDeclaredMethod("columnReorder", new Class[] { ColumnReorderEvent.class }); } catch (final NoSuchMethodException e) { // This should never happen throw new RuntimeException(e); } } /** * Constructor. * * @param source * The source of the event */ public ColumnReorderEvent(Component source) { super(source); } } /** * Interface for listening to column reorder events. */ @Deprecated public interface ColumnReorderListener extends Serializable { /** * This method is triggered when the column has been reordered. * * @param event */ public void columnReorder(ColumnReorderEvent event); } /** * This event is fired when the collapse state of a column changes. * * @since 7.6 */ @Deprecated public static class ColumnCollapseEvent extends Component.Event { public static final Method METHOD = ReflectTools.findMethod(ColumnCollapseListener.class, "columnCollapseStateChange", ColumnCollapseEvent.class); private Object propertyId; /** * Constructor. * * @param source * The source of the event * @param propertyId * The id of the column */ public ColumnCollapseEvent(Component source, Object propertyId) { super(source); this.propertyId = propertyId; } /** * Gets the id of the column whose collapse state changed. * * @return the property id of the column */ public Object getPropertyId() { return propertyId; } } /** * Interface for listening to column collapse events. * * @since 7.6 */ @Deprecated public interface ColumnCollapseListener extends Serializable { /** * This method is triggered when the collapse state for a column has * changed. * * @param event */ public void columnCollapseStateChange(ColumnCollapseEvent event); } /** * Adds a column reorder listener to the Table. A column reorder listener is * called when a user reorders columns. * * @param listener * The listener to attach to the Table */ public void addColumnReorderListener(ColumnReorderListener listener) { addListener(TableConstants.COLUMN_REORDER_EVENT_ID, ColumnReorderEvent.class, listener, ColumnReorderEvent.METHOD); } /** * @deprecated As of 7.0, replaced by * {@link #addColumnReorderListener(ColumnReorderListener)} */ @Deprecated public void addListener(ColumnReorderListener listener) { addColumnReorderListener(listener); } /** * Removes a column reorder listener from the Table. * * @param listener * The listener to remove */ public void removeColumnReorderListener(ColumnReorderListener listener) { removeListener(TableConstants.COLUMN_REORDER_EVENT_ID, ColumnReorderEvent.class, listener); } /** * @deprecated As of 7.0, replaced by * {@link #removeColumnReorderListener(ColumnReorderListener)} */ @Deprecated public void removeListener(ColumnReorderListener listener) { removeColumnReorderListener(listener); } /** * Adds a column collapse listener to the Table. A column collapse listener * is called when the collapsed state of a column changes. * * @since 7.6 * * @param listener * The listener to attach */ public void addColumnCollapseListener(ColumnCollapseListener listener) { addListener(TableConstants.COLUMN_COLLAPSE_EVENT_ID, ColumnCollapseEvent.class, listener, ColumnCollapseEvent.METHOD); } /** * Removes a column reorder listener from the Table. * * @since 7.6 * @param listener * The listener to remove */ public void removeColumnCollapseListener(ColumnCollapseListener listener) { removeListener(TableConstants.COLUMN_COLLAPSE_EVENT_ID, ColumnCollapseEvent.class, listener); } /** * Set the item description generator which generates tooltips for cells and * rows in the Table. * * @param generator * The generator to use or null to disable */ public void setItemDescriptionGenerator(ItemDescriptionGenerator generator) { if (generator != itemDescriptionGenerator) { itemDescriptionGenerator = generator; // Assures the visual refresh. No need to reset the page buffer // before as the content has not changed, only the descriptions refreshRenderedCells(); } } /** * Get the item description generator which generates tooltips for cells and * rows in the Table. */ public ItemDescriptionGenerator getItemDescriptionGenerator() { return itemDescriptionGenerator; } /** * Row generators can be used to replace certain items in a table with a * generated string. The generator is called each time the table is * rendered, which means that new strings can be generated each time. * * Row generators can be used for e.g. summary rows or grouping of items. */ @Deprecated public interface RowGenerator extends Serializable { /** * Called for every row that is painted in the Table. Returning a * GeneratedRow object will cause the row to be painted based on the * contents of the GeneratedRow. A generated row is by default styled * similarly to a header or footer row. * <p> * The GeneratedRow data object contains the text that should be * rendered in the row. The itemId in the container thus works only as a * placeholder. * <p> * If GeneratedRow.setSpanColumns(true) is used, there will be one * String spanning all columns (use setText("Spanning text")). Otherwise * you can define one String per visible column. * <p> * If GeneratedRow.setRenderAsHtml(true) is used, the strings can * contain HTML markup, otherwise all strings will be rendered as text * (the default). * <p> * A "v-table-generated-row" CSS class is added to all generated rows. * For custom styling of a generated row you can combine a RowGenerator * with a CellStyleGenerator. * <p> * * @param table * The Table that is being painted * @param itemId * The itemId for the row * @return A GeneratedRow describing how the row should be painted or * null to paint the row with the contents from the container */ public GeneratedRow generateRow(Table table, Object itemId); } @Deprecated public static class GeneratedRow implements Serializable { private boolean htmlContentAllowed = false; private boolean spanColumns = false; private String[] text = null; /** * Creates a new generated row. If only one string is passed in, columns * are automatically spanned. * * @param text */ public GeneratedRow(String... text) { setHtmlContentAllowed(false); setSpanColumns(text == null || text.length == 1); setText(text); } /** * Pass one String if spanColumns is used, one String for each visible * column otherwise. */ public void setText(String... text) { if (text == null || (text.length == 1 && text[0] == null)) { text = new String[] { "" }; } this.text = text; } protected String[] getText() { return text; } protected Object getValue() { return getText(); } protected boolean isHtmlContentAllowed() { return htmlContentAllowed; } /** * If set to true, all strings passed to {@link #setText(String...)} * will be rendered as HTML. * * @param htmlContentAllowed */ public void setHtmlContentAllowed(boolean htmlContentAllowed) { this.htmlContentAllowed = htmlContentAllowed; } protected boolean isSpanColumns() { return spanColumns; } /** * If set to true, only one string will be rendered, spanning the entire * row. * * @param spanColumns */ public void setSpanColumns(boolean spanColumns) { this.spanColumns = spanColumns; } } /** * Assigns a row generator to the table. The row generator will be able to * replace rows in the table when it is rendered. * * @param generator * the new row generator */ public void setRowGenerator(RowGenerator generator) { rowGenerator = generator; refreshRowCache(); } /** * @return the current row generator */ public RowGenerator getRowGenerator() { return rowGenerator; } /** * Sets a converter for a property id. * <p> * The converter is used to format the the data for the given property id * before displaying it in the table. * </p> * * @param propertyId * The propertyId to format using the converter * @param converter * The converter to use for the property id */ public void setConverter(Object propertyId, Converter<String, ?> converter) { if (!getContainerPropertyIds().contains(propertyId)) { throw new IllegalArgumentException("PropertyId " + propertyId + " must be in the container"); } if (!typeIsCompatible(converter.getModelType(), getType(propertyId))) { throw new IllegalArgumentException("Property type (" + getType(propertyId) + ") must match converter source type (" + converter.getModelType() + ")"); } propertyValueConverters.put(propertyId, (Converter<String, Object>) converter); refreshRowCache(); } /** * Checks if there is a converter set explicitly for the given property id. * * @param propertyId * The propertyId to check * @return true if a converter has been set for the property id, false * otherwise */ protected boolean hasConverter(Object propertyId) { return propertyValueConverters.containsKey(propertyId); } /** * Returns the converter used to format the given propertyId. * * @param propertyId * The propertyId to check * @return The converter used to format the propertyId or null if no * converter has been set */ public Converter<String, Object> getConverter(Object propertyId) { return propertyValueConverters.get(propertyId); } @Override public void setVisible(boolean visible) { if (visible) { // We need to ensure that the rows are sent to the client when the // Table is made visible if it has been rendered as invisible. setRowCacheInvalidated(true); } super.setVisible(visible); } @Override public Iterator<Component> iterator() { if (visibleComponents == null) { Collection<Component> empty = Collections.emptyList(); return empty.iterator(); } return visibleComponents.iterator(); } /** * @deprecated As of 7.0, use {@link #iterator()} instead. */ @Deprecated public Iterator<Component> getComponentIterator() { return iterator(); } @Override public void readDesign(Element design, DesignContext context) { super.readDesign(design, context); if (design.hasAttr("sortable")) { setSortEnabled(DesignAttributeHandler.readAttribute("sortable", design.attributes(), boolean.class)); } readColumns(design); readHeader(design); readBody(design, context); readFooter(design); } private void readColumns(Element design) { Element colgroup = design.select("> table > colgroup").first(); if (colgroup != null) { int i = 0; List<Object> pIds = new ArrayList<Object>(); for (Element col : colgroup.children()) { if (!col.tagName().equals("col")) { throw new DesignException("invalid column"); } String id = DesignAttributeHandler.readAttribute("property-id", col.attributes(), "property-" + i++, String.class); pIds.add(id); addContainerProperty(id, String.class, null); if (col.hasAttr("width")) { setColumnWidth(id, DesignAttributeHandler.readAttribute("width", col.attributes(), Integer.class)); } if (col.hasAttr("center")) { setColumnAlignment(id, Align.CENTER); } else if (col.hasAttr("right")) { setColumnAlignment(id, Align.RIGHT); } if (col.hasAttr("expand")) { if (col.attr("expand").isEmpty()) { setColumnExpandRatio(id, 1); } else { setColumnExpandRatio(id, DesignAttributeHandler.readAttribute("expand", col.attributes(), float.class)); } } if (col.hasAttr("collapsible")) { setColumnCollapsible(id, DesignAttributeHandler.readAttribute("collapsible", col.attributes(), boolean.class)); } if (col.hasAttr("collapsed")) { setColumnCollapsed(id, DesignAttributeHandler.readAttribute("collapsed", col.attributes(), boolean.class)); } } setVisibleColumns(pIds.toArray()); } } private void readFooter(Element design) { readHeaderOrFooter(design, false); } private void readHeader(Element design) { readHeaderOrFooter(design, true); } @Override protected void readItems(Element design, DesignContext context) { // Do nothing - header/footer and inline data must be handled after // colgroup. } private void readHeaderOrFooter(Element design, boolean header) { String selector = header ? "> table > thead" : "> table > tfoot"; Element elem = design.select(selector).first(); if (elem != null) { if (!header) { setFooterVisible(true); } if (elem.children().size() != 1) { throw new DesignException("Table header and footer should contain exactly one <tr> element"); } Element tr = elem.child(0); Elements elems = tr.children(); Collection<?> propertyIds = visibleColumns; if (elems.size() != propertyIds.size()) { throw new DesignException("Table header and footer should contain as many items as there" + " are columns in the Table."); } Iterator<?> propertyIt = propertyIds.iterator(); for (Element e : elems) { String columnValue = DesignFormatter.decodeFromTextNode(e.html()); Object propertyId = propertyIt.next(); if (header) { setColumnHeader(propertyId, columnValue); if (e.hasAttr("icon")) { setColumnIcon(propertyId, DesignAttributeHandler.readAttribute("icon", e.attributes(), Resource.class)); } } else { setColumnFooter(propertyId, columnValue); } } } } protected void readBody(Element design, DesignContext context) { Element tbody = design.select("> table > tbody").first(); if (tbody == null) { return; } Set<String> selected = new HashSet<String>(); for (Element tr : tbody.children()) { readItem(tr, selected, context); } } @Override protected Object readItem(Element tr, Set<String> selected, DesignContext context) { Elements cells = tr.children(); if (visibleColumns.size() != cells.size()) { throw new DesignException("Wrong number of columns in a Table row. Expected " + visibleColumns.size() + ", was " + cells.size() + "."); } Object[] data = new String[cells.size()]; for (int c = 0; c < cells.size(); ++c) { data[c] = DesignFormatter.decodeFromTextNode(cells.get(c).html()); } Object itemId = addItem(data, tr.hasAttr("item-id") ? tr.attr("item-id") : null); if (itemId == null) { throw new DesignException("Failed to add a Table row: " + data); } return itemId; } @Override public void writeDesign(Element design, DesignContext context) { Table def = context.getDefaultInstance(this); DesignAttributeHandler.writeAttribute("sortable", design.attributes(), isSortEnabled(), def.isSortEnabled(), boolean.class, context); Element table = null; boolean hasColumns = getVisibleColumns().length != 0; if (hasColumns) { table = design.appendElement("table"); writeColumns(table, def, context); writeHeader(table, def, context); } super.writeDesign(design, context); if (hasColumns) { writeFooter(table); } } private void writeColumns(Element table, Table def, DesignContext context) { Object[] columns = getVisibleColumns(); if (columns.length == 0) { return; } Element colgroup = table.appendElement("colgroup"); for (Object id : columns) { Element col = colgroup.appendElement("col"); col.attr("property-id", id.toString()); if (getColumnAlignment(id) == Align.CENTER) { col.attr("center", true); } else if (getColumnAlignment(id) == Align.RIGHT) { col.attr("right", true); } DesignAttributeHandler.writeAttribute("width", col.attributes(), getColumnWidth(id), def.getColumnWidth(null), int.class, context); DesignAttributeHandler.writeAttribute("expand", col.attributes(), getColumnExpandRatio(id), def.getColumnExpandRatio(null), float.class, context); DesignAttributeHandler.writeAttribute("collapsible", col.attributes(), isColumnCollapsible(id), def.isColumnCollapsible(null), boolean.class, context); DesignAttributeHandler.writeAttribute("collapsed", col.attributes(), isColumnCollapsed(id), def.isColumnCollapsed(null), boolean.class, context); } } private void writeHeader(Element table, Table def, DesignContext context) { Object[] columns = getVisibleColumns(); if (columns.length == 0 || (columnIcons.isEmpty() && columnHeaders.isEmpty())) { return; } Element header = table.appendElement("thead").appendElement("tr"); for (Object id : columns) { Element th = header.appendElement("th"); th.html(getColumnHeader(id)); DesignAttributeHandler.writeAttribute("icon", th.attributes(), getColumnIcon(id), def.getColumnIcon(null), Resource.class, context); } } private void writeFooter(Element table) { Object[] columns = getVisibleColumns(); if (columns.length == 0 || columnFooters.isEmpty()) { return; } Element footer = table.appendElement("tfoot").appendElement("tr"); for (Object id : columns) { footer.appendElement("td").text(getColumnFooter(id)); } } @Override protected void writeItems(Element design, DesignContext context) { if (getVisibleColumns().length == 0) { return; } Element tbody = design.child(0).appendElement("tbody"); super.writeItems(tbody, context); } @Override protected Element writeItem(Element tbody, Object itemId, DesignContext context) { Element tr = tbody.appendElement("tr"); tr.attr("item-id", String.valueOf(itemId)); Item item = getItem(itemId); for (Object id : getVisibleColumns()) { Element td = tr.appendElement("td"); Object value = item.getItemProperty(id).getValue(); td.html(value != null ? value.toString() : ""); } return tr; } @Override protected Collection<String> getCustomAttributes() { Collection<String> result = super.getCustomAttributes(); result.add("sortable"); result.add("sort-enabled"); result.add("sort-disabled"); result.add("footer-visible"); result.add("item-caption-mode"); result.add("current-page-first-item-id"); result.add("current-page-first-item-index"); return result; } /** * ContextClickEvent for the Table Component. * * @since 7.6 */ @Deprecated public static class TableContextClickEvent extends ContextClickEvent { private final Object itemId; private final Object propertyId; private final Section section; public TableContextClickEvent(Table source, MouseEventDetails mouseEventDetails, Object itemId, Object propertyId, Section section) { super(source, mouseEventDetails); this.itemId = itemId; this.propertyId = propertyId; this.section = section; } /** * Returns the item id of context clicked row. * * @return item id of clicked row; <code>null</code> if header, footer * or empty area of Table */ public Object getItemId() { return itemId; } /** * Returns the property id of context clicked column. * * @return property id; or <code>null</code> if we've clicked on the * empty area of the Table */ public Object getPropertyId() { return propertyId; } /** * Returns the clicked section of Table. * * @return section of Table */ public Section getSection() { return section; } @Override public Table getComponent() { return (Table) super.getComponent(); } } @Override protected TableState getState() { return getState(true); } @Override protected TableState getState(boolean markAsDirty) { return (TableState) super.getState(markAsDirty); } private final Logger getLogger() { if (logger == null) { logger = Logger.getLogger(Table.class.getName()); } return logger; } @Override public void setChildMeasurementHint(ChildMeasurementHint hint) { if (hint == null) { childMeasurementHint = ChildMeasurementHint.MEASURE_ALWAYS; } else { childMeasurementHint = hint; } } @Override public ChildMeasurementHint getChildMeasurementHint() { return childMeasurementHint; } /** * Sets whether only collapsible columns should be shown to the user in the * column collapse menu. The default is * {@link CollapseMenuContent#ALL_COLUMNS}. * * * @since 7.6 * @param content * the desired collapsible menu content setting */ public void setCollapseMenuContent(CollapseMenuContent content) { getState().collapseMenuContent = content; } /** * Checks whether only collapsible columns are shown to the user in the * column collapse menu. The default is * {@link CollapseMenuContent#ALL_COLUMNS} . * * @since 7.6 * @return the current collapsible menu content setting */ public CollapseMenuContent getCollapseMenuContent() { return getState(false).collapseMenuContent; } }