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.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.Stack; import java.util.logging.Level; import java.util.logging.Logger; import org.jsoup.nodes.Element; import com.vaadin.server.PaintException; import com.vaadin.server.PaintTarget; import com.vaadin.server.Resource; import com.vaadin.ui.declarative.DesignAttributeHandler; import com.vaadin.ui.declarative.DesignContext; import com.vaadin.ui.declarative.DesignException; import com.vaadin.v7.data.Collapsible; import com.vaadin.v7.data.Container; import com.vaadin.v7.data.Container.Hierarchical; import com.vaadin.v7.data.util.ContainerHierarchicalWrapper; import com.vaadin.v7.data.util.HierarchicalContainer; import com.vaadin.v7.data.util.HierarchicalContainerOrderedWrapper; import com.vaadin.v7.shared.ui.treetable.TreeTableConstants; import com.vaadin.v7.shared.ui.treetable.TreeTableState; import com.vaadin.v7.ui.Tree.CollapseEvent; import com.vaadin.v7.ui.Tree.CollapseListener; import com.vaadin.v7.ui.Tree.ExpandEvent; import com.vaadin.v7.ui.Tree.ExpandListener; /** * TreeTable extends the {@link Table} component so that it can also visualize a * hierarchy of its Items in a similar manner that {@link Tree} does. The tree * hierarchy is always displayed in the first actual column of the TreeTable. * <p> * The TreeTable supports the usual {@link Table} features like lazy loading, so * it should be no problem to display lots of items at once. Only required rows * and some cache rows are sent to the client. * <p> * TreeTable supports standard {@link Hierarchical} container interfaces, but * also a more fine tuned version - {@link Collapsible}. A container * implementing the {@link Collapsible} interface stores the collapsed/expanded * state internally and can this way scale better on the server side than with * standard Hierarchical implementations. Developer must however note that * {@link Collapsible} containers can not be shared among several users as they * share UI state in the container. * * @deprecated See {@code TreeGrid}. */ @SuppressWarnings({ "serial" }) @Deprecated public class TreeTable extends Table implements Hierarchical { private interface ContainerStrategy extends Serializable { public int size(); public boolean isNodeOpen(Object itemId); public int getDepth(Object itemId); public void toggleChildVisibility(Object itemId); public Object getIdByIndex(int index); public int indexOfId(Object id); public Object nextItemId(Object itemId); public Object lastItemId(); public Object prevItemId(Object itemId); public boolean isLastId(Object itemId); public Collection<?> getItemIds(); public void containerItemSetChange(ItemSetChangeEvent event); } private abstract class AbstractStrategy implements ContainerStrategy { /** * Consider adding getDepth to {@link Collapsible}, might help * scalability with some container implementations. */ @Override public int getDepth(Object itemId) { int depth = 0; Hierarchical hierarchicalContainer = getContainerDataSource(); while (!hierarchicalContainer.isRoot(itemId)) { depth++; itemId = hierarchicalContainer.getParent(itemId); } return depth; } @Override public void containerItemSetChange(ItemSetChangeEvent event) { } } /** * This strategy is used if current container implements {@link Collapsible} * . * * open-collapsed logic diverted to container, otherwise use default * implementations. */ private class CollapsibleStrategy extends AbstractStrategy { private Collapsible c() { return (Collapsible) getContainerDataSource(); } @Override public void toggleChildVisibility(Object itemId) { c().setCollapsed(itemId, !c().isCollapsed(itemId)); } @Override public boolean isNodeOpen(Object itemId) { return !c().isCollapsed(itemId); } @Override public int size() { return TreeTable.super.size(); } @Override public Object getIdByIndex(int index) { return TreeTable.super.getIdByIndex(index); } @Override public int indexOfId(Object id) { return TreeTable.super.indexOfId(id); } @Override public boolean isLastId(Object itemId) { // using the default impl return TreeTable.super.isLastId(itemId); } @Override public Object lastItemId() { // using the default impl return TreeTable.super.lastItemId(); } @Override public Object nextItemId(Object itemId) { return TreeTable.super.nextItemId(itemId); } @Override public Object prevItemId(Object itemId) { return TreeTable.super.prevItemId(itemId); } @Override public Collection<?> getItemIds() { return TreeTable.super.getItemIds(); } } /** * Strategy for Hierarchical but not Collapsible container like * {@link HierarchicalContainer}. * * Store collapsed/open states internally, fool Table to use preorder when * accessing items from container via Ordered/Indexed methods. */ private class HierarchicalStrategy extends AbstractStrategy { private final HashSet<Object> openItems = new HashSet<Object>(); @Override public boolean isNodeOpen(Object itemId) { return openItems.contains(itemId); } @Override public int size() { return getPreOrder().size(); } @Override public Collection<Object> getItemIds() { return Collections.unmodifiableCollection(getPreOrder()); } @Override public boolean isLastId(Object itemId) { if (itemId == null) { return false; } return itemId.equals(lastItemId()); } @Override public Object lastItemId() { if (!getPreOrder().isEmpty()) { return getPreOrder().get(getPreOrder().size() - 1); } else { return null; } } @Override public Object nextItemId(Object itemId) { int indexOf = getPreOrder().indexOf(itemId); if (indexOf == -1) { return null; } indexOf++; if (indexOf == getPreOrder().size()) { return null; } else { return getPreOrder().get(indexOf); } } @Override public Object prevItemId(Object itemId) { int indexOf = getPreOrder().indexOf(itemId); indexOf--; if (indexOf < 0) { return null; } else { return getPreOrder().get(indexOf); } } @Override public void toggleChildVisibility(Object itemId) { boolean removed = openItems.remove(itemId); if (!removed) { openItems.add(itemId); getLogger().log(Level.FINEST, "Item {0} is now expanded", itemId); } else { getLogger().log(Level.FINEST, "Item {0} is now collapsed", itemId); } clearPreorderCache(); } private void clearPreorderCache() { preOrder = null; // clear preorder cache } List<Object> preOrder; /** * Preorder of ids currently visible * * @return */ private List<Object> getPreOrder() { if (preOrder == null) { preOrder = new ArrayList<Object>(); Collection<?> rootItemIds = getContainerDataSource().rootItemIds(); for (Object id : rootItemIds) { preOrder.add(id); addVisibleChildTree(id); } } return preOrder; } private void addVisibleChildTree(Object id) { if (isNodeOpen(id)) { Collection<?> children = getContainerDataSource().getChildren(id); if (children != null) { for (Object childId : children) { preOrder.add(childId); addVisibleChildTree(childId); } } } } @Override public int indexOfId(Object id) { return getPreOrder().indexOf(id); } @Override public Object getIdByIndex(int index) { return getPreOrder().get(index); } @Override public void containerItemSetChange(ItemSetChangeEvent event) { // preorder becomes invalid on sort, item additions etc. clearPreorderCache(); super.containerItemSetChange(event); } } /** * Creates an empty TreeTable with a default container. */ public TreeTable() { super(null, new HierarchicalContainer()); } /** * Creates an empty TreeTable with a default container. * * @param caption * the caption for the TreeTable */ public TreeTable(String caption) { this(); setCaption(caption); } /** * Creates a TreeTable instance with given captions and data source. * * @param caption * the caption for the component * @param dataSource * the dataSource that is used to list items in the component */ public TreeTable(String caption, Container dataSource) { super(caption, dataSource); } private ContainerStrategy cStrategy; private Object focusedRowId = null; private Object hierarchyColumnId; /** * The item id that was expanded or collapsed during this request. Reset at * the end of paint and only used for determining if a partial or full paint * should be done. * * Can safely be reset to null whenever a change occurs that would prevent a * partial update from rendering the correct result, e.g. rows added or * removed during an expand operation. */ private Object toggledItemId; private boolean animationsEnabled; private boolean clearFocusedRowPending; /** * If the container does not send item set change events, always do a full * repaint instead of a partial update when expanding/collapsing nodes. */ private boolean containerSupportsPartialUpdates; private ContainerStrategy getContainerStrategy() { if (cStrategy == null) { if (getContainerDataSource() instanceof Collapsible) { cStrategy = new CollapsibleStrategy(); } else { cStrategy = new HierarchicalStrategy(); } } return cStrategy; } @Override protected void paintRowAttributes(PaintTarget target, Object itemId) throws PaintException { super.paintRowAttributes(target, itemId); target.addAttribute("depth", getContainerStrategy().getDepth(itemId)); if (getContainerDataSource().areChildrenAllowed(itemId)) { target.addAttribute("ca", true); target.addAttribute("open", getContainerStrategy().isNodeOpen(itemId)); } } @Override protected void paintRowIcon(PaintTarget target, Object[][] cells, int indexInRowbuffer) throws PaintException { // always paint if present (in parent only if row headers visible) if (getRowHeaderMode() == ROW_HEADER_MODE_HIDDEN) { Resource itemIcon = getItemIcon(cells[CELL_ITEMID][indexInRowbuffer]); if (itemIcon != null) { target.addAttribute("icon", itemIcon); } } else if (cells[CELL_ICON][indexInRowbuffer] != null) { target.addAttribute("icon", (Resource) cells[CELL_ICON][indexInRowbuffer]); } } @Override protected boolean rowHeadersAreEnabled() { if (getRowHeaderMode() == RowHeaderMode.ICON_ONLY) { return false; } return super.rowHeadersAreEnabled(); } @Override public void changeVariables(Object source, Map<String, Object> variables) { super.changeVariables(source, variables); if (variables.containsKey("toggleCollapsed")) { String object = (String) variables.get("toggleCollapsed"); Object itemId = itemIdMapper.get(object); toggledItemId = itemId; toggleChildVisibility(itemId, false); if (variables.containsKey("selectCollapsed")) { // ensure collapsed is selected unless opened with selection // head if (isSelectable()) { select(itemId); } } } else if (variables.containsKey("focusParent")) { String key = (String) variables.get("focusParent"); Object refId = itemIdMapper.get(key); Object itemId = getParent(refId); focusParent(itemId); } } private void focusParent(Object itemId) { boolean inView = false; Object inPageId = getCurrentPageFirstItemId(); for (int i = 0; inPageId != null && i < getPageLength(); i++) { if (inPageId.equals(itemId)) { inView = true; break; } inPageId = nextItemId(inPageId); i++; } if (!inView) { setCurrentPageFirstItemId(itemId); } // Select the row if it is selectable. if (isSelectable()) { if (isMultiSelect()) { setValue(Collections.singleton(itemId)); } else { setValue(itemId); } } setFocusedRow(itemId); } private void setFocusedRow(Object itemId) { focusedRowId = itemId; if (focusedRowId == null) { // Must still inform the client that the focusParent request has // been processed clearFocusedRowPending = true; } markAsDirty(); } @Override public void paintContent(PaintTarget target) throws PaintException { if (focusedRowId != null) { target.addAttribute("focusedRow", itemIdMapper.key(focusedRowId)); focusedRowId = null; } else if (clearFocusedRowPending) { // Must still inform the client that the focusParent request has // been processed target.addAttribute("clearFocusPending", true); clearFocusedRowPending = false; } target.addAttribute("animate", animationsEnabled); if (hierarchyColumnId != null) { Object[] visibleColumns2 = getVisibleColumns(); for (int i = 0; i < visibleColumns2.length; i++) { Object object = visibleColumns2[i]; if (hierarchyColumnId.equals(object)) { target.addAttribute(TreeTableConstants.ATTRIBUTE_HIERARCHY_COLUMN_INDEX, i); break; } } } super.paintContent(target); toggledItemId = null; } /* * Override methods for partial row updates and additions when expanding / * collapsing nodes. */ @Override protected boolean isPartialRowUpdate() { return toggledItemId != null && containerSupportsPartialUpdates && !isRowCacheInvalidated(); } @Override protected int getFirstAddedItemIndex() { return indexOfId(toggledItemId) + 1; } @Override protected int getAddedRowCount() { return countSubNodesRecursively(getContainerDataSource(), toggledItemId); } private int countSubNodesRecursively(Hierarchical hc, Object itemId) { int count = 0; // we need the number of children for toggledItemId no matter if its // collapsed or expanded. Other items' children are only counted if the // item is expanded. if (getContainerStrategy().isNodeOpen(itemId) || itemId == toggledItemId) { Collection<?> children = hc.getChildren(itemId); if (children != null) { count += children != null ? children.size() : 0; for (Object id : children) { count += countSubNodesRecursively(hc, id); } } } return count; } @Override protected int getFirstUpdatedItemIndex() { return indexOfId(toggledItemId); } @Override protected int getUpdatedRowCount() { return 1; } @Override protected boolean shouldHideAddedRows() { return !getContainerStrategy().isNodeOpen(toggledItemId); } private void toggleChildVisibility(Object itemId, boolean forceFullRefresh) { getContainerStrategy().toggleChildVisibility(itemId); // ensure that page still has first item in page, DON'T clear the // caches. setCurrentPageFirstItemIndex(getCurrentPageFirstItemIndex(), false); if (isCollapsed(itemId)) { fireCollapseEvent(itemId); } else { fireExpandEvent(itemId); } if (containerSupportsPartialUpdates && !forceFullRefresh) { markAsDirty(); } else { // For containers that do not send item set change events, always do // full repaint instead of partial row update. refreshRowCache(); } } @Override public int size() { return getContainerStrategy().size(); } @Override public Hierarchical getContainerDataSource() { return (Hierarchical) super.getContainerDataSource(); } @Override public void setContainerDataSource(Container newDataSource) { cStrategy = null; // FIXME: This disables partial updates until TreeTable is fixed so it // does not change component hierarchy during paint containerSupportsPartialUpdates = (newDataSource instanceof ItemSetChangeNotifier) && false; if (newDataSource != null && !(newDataSource instanceof Hierarchical)) { newDataSource = new ContainerHierarchicalWrapper(newDataSource); } if (newDataSource != null && !(newDataSource instanceof Ordered)) { newDataSource = new HierarchicalContainerOrderedWrapper((Hierarchical) newDataSource); } super.setContainerDataSource(newDataSource); } @Override public void containerItemSetChange(Container.ItemSetChangeEvent event) { // Can't do partial repaints if items are added or removed during the // expand/collapse request toggledItemId = null; getContainerStrategy().containerItemSetChange(event); super.containerItemSetChange(event); } @Override protected Object getIdByIndex(int index) { return getContainerStrategy().getIdByIndex(index); } @Override protected int indexOfId(Object itemId) { return getContainerStrategy().indexOfId(itemId); } @Override public Object nextItemId(Object itemId) { return getContainerStrategy().nextItemId(itemId); } @Override public Object lastItemId() { return getContainerStrategy().lastItemId(); } @Override public Object prevItemId(Object itemId) { return getContainerStrategy().prevItemId(itemId); } @Override public boolean isLastId(Object itemId) { return getContainerStrategy().isLastId(itemId); } @Override public Collection<?> getItemIds() { return getContainerStrategy().getItemIds(); } @Override public boolean areChildrenAllowed(Object itemId) { return getContainerDataSource().areChildrenAllowed(itemId); } @Override public Collection<?> getChildren(Object itemId) { return getContainerDataSource().getChildren(itemId); } @Override public Object getParent(Object itemId) { return getContainerDataSource().getParent(itemId); } @Override public boolean hasChildren(Object itemId) { return getContainerDataSource().hasChildren(itemId); } @Override public boolean isRoot(Object itemId) { return getContainerDataSource().isRoot(itemId); } @Override public Collection<?> rootItemIds() { return getContainerDataSource().rootItemIds(); } @Override public boolean setChildrenAllowed(Object itemId, boolean areChildrenAllowed) throws UnsupportedOperationException { return getContainerDataSource().setChildrenAllowed(itemId, areChildrenAllowed); } @Override public boolean setParent(Object itemId, Object newParentId) throws UnsupportedOperationException { return getContainerDataSource().setParent(itemId, newParentId); } /** * Sets the Item specified by given identifier as collapsed or expanded. If * the Item is collapsed, its children are not displayed to the user. * * @param itemId * the identifier of the Item * @param collapsed * true if the Item should be collapsed, false if expanded */ public void setCollapsed(Object itemId, boolean collapsed) { if (isCollapsed(itemId) != collapsed) { if (null == toggledItemId && !isRowCacheInvalidated() && getVisibleItemIds().contains(itemId)) { // optimization: partial refresh if only one item is // collapsed/expanded toggledItemId = itemId; toggleChildVisibility(itemId, false); } else { // make sure a full refresh takes place - otherwise neither // partial nor full repaint of table content is performed toggledItemId = null; toggleChildVisibility(itemId, true); } } } /** * Checks if Item with given identifier is collapsed in the UI. * * <p> * * @param itemId * the identifier of the checked Item * @return true if the Item with given id is collapsed * @see Collapsible#isCollapsed(Object) */ public boolean isCollapsed(Object itemId) { return !getContainerStrategy().isNodeOpen(itemId); } /** * Explicitly sets the column in which the TreeTable visualizes the * hierarchy. If hierarchyColumnId is not set, the hierarchy is visualized * in the first visible column. * * @param hierarchyColumnId */ public void setHierarchyColumn(Object hierarchyColumnId) { this.hierarchyColumnId = hierarchyColumnId; } /** * @return the identifier of column into which the hierarchy will be * visualized or null if the column is not explicitly defined. */ public Object getHierarchyColumnId() { return hierarchyColumnId; } /** * Adds an expand listener. * * @param listener * the Listener to be added. */ public void addExpandListener(ExpandListener listener) { addListener(ExpandEvent.class, listener, ExpandListener.EXPAND_METHOD); } /** * @deprecated As of 7.0, replaced by * {@link #addExpandListener(ExpandListener)} */ @Deprecated public void addListener(ExpandListener listener) { addExpandListener(listener); } /** * Removes an expand listener. * * @param listener * the Listener to be removed. */ public void removeExpandListener(ExpandListener listener) { removeListener(ExpandEvent.class, listener, ExpandListener.EXPAND_METHOD); } /** * @deprecated As of 7.0, replaced by * {@link #removeExpandListener(ExpandListener)} */ @Deprecated public void removeListener(ExpandListener listener) { removeExpandListener(listener); } /** * Emits an expand event. * * @param itemId * the item id. */ protected void fireExpandEvent(Object itemId) { fireEvent(new ExpandEvent(this, itemId)); } /** * Adds a collapse listener. * * @param listener * the Listener to be added. */ public void addCollapseListener(CollapseListener listener) { addListener(CollapseEvent.class, listener, CollapseListener.COLLAPSE_METHOD); } /** * @deprecated As of 7.0, replaced by * {@link #addCollapseListener(CollapseListener)} */ @Deprecated public void addListener(CollapseListener listener) { addCollapseListener(listener); } /** * Removes a collapse listener. * * @param listener * the Listener to be removed. */ public void removeCollapseListener(CollapseListener listener) { removeListener(CollapseEvent.class, listener, CollapseListener.COLLAPSE_METHOD); } /** * @deprecated As of 7.0, replaced by * {@link #removeCollapseListener(CollapseListener)} */ @Deprecated public void removeListener(CollapseListener listener) { removeCollapseListener(listener); } /** * Emits a collapse event. * * @param itemId * the item id. */ protected void fireCollapseEvent(Object itemId) { fireEvent(new CollapseEvent(this, itemId)); } /** * @return true if animations are enabled */ public boolean isAnimationsEnabled() { return animationsEnabled; } /** * Animations can be enabled by passing true to this method. Currently * expanding rows slide in from the top and collapsing rows slide out the * same way. NOTE! not supported in Internet Explorer 6 or 7. * * @param animationsEnabled * true or false whether to enable animations or not. */ public void setAnimationsEnabled(boolean animationsEnabled) { this.animationsEnabled = animationsEnabled; markAsDirty(); } private static final Logger getLogger() { return Logger.getLogger(TreeTable.class.getName()); } @Override protected List<Object> getItemIds(int firstIndex, int rows) { List<Object> itemIds = new ArrayList<Object>(); for (int i = firstIndex; i < firstIndex + rows; i++) { itemIds.add(getIdByIndex(i)); } return itemIds; } @Override protected void readBody(Element design, DesignContext context) { Element tbody = design.select("> table > tbody").first(); if (tbody == null) { return; } Set<String> selected = new HashSet<String>(); Stack<Object> parents = new Stack<Object>(); int lastDepth = -1; for (Element tr : tbody.children()) { int depth = DesignAttributeHandler.readAttribute("depth", tr.attributes(), 0, int.class); if (depth < 0 || depth > lastDepth + 1) { throw new DesignException( "Malformed TreeTable item hierarchy at " + tr + ": last depth was " + lastDepth); } else if (depth <= lastDepth) { for (int d = depth; d <= lastDepth; d++) { parents.pop(); } } Object itemId = readItem(tr, selected, context); setParent(itemId, !parents.isEmpty() ? parents.peek() : null); parents.push(itemId); lastDepth = depth; } } @Override protected Object readItem(Element tr, Set<String> selected, DesignContext context) { Object itemId = super.readItem(tr, selected, context); if (tr.hasAttr("collapsed")) { boolean collapsed = DesignAttributeHandler.readAttribute("collapsed", tr.attributes(), boolean.class); setCollapsed(itemId, collapsed); } return itemId; } @Override protected void writeItems(Element design, DesignContext context) { if (getVisibleColumns().length == 0) { return; } Element tbody = design.child(0).appendElement("tbody"); writeItems(tbody, rootItemIds(), 0, context); } protected void writeItems(Element tbody, Collection<?> itemIds, int depth, DesignContext context) { for (Object itemId : itemIds) { Element tr = writeItem(tbody, itemId, context); DesignAttributeHandler.writeAttribute("depth", tr.attributes(), depth, 0, int.class, context); if (getChildren(itemId) != null) { writeItems(tbody, getChildren(itemId), depth + 1, context); } } } @Override protected Element writeItem(Element tbody, Object itemId, DesignContext context) { Element tr = super.writeItem(tbody, itemId, context); DesignAttributeHandler.writeAttribute("collapsed", tr.attributes(), isCollapsed(itemId), true, boolean.class, context); return tr; } @Override protected TreeTableState getState() { return (TreeTableState) super.getState(); } }