| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to you 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 org.apache.pivot.wtk.skin.terra; |
| |
| import java.awt.AlphaComposite; |
| import java.awt.Color; |
| import java.awt.Font; |
| import java.awt.Graphics2D; |
| import java.awt.Rectangle; |
| import java.awt.Transparency; |
| import java.awt.geom.GeneralPath; |
| import java.util.Iterator; |
| import java.util.NoSuchElementException; |
| |
| import org.apache.pivot.collections.ArrayList; |
| import org.apache.pivot.collections.Dictionary; |
| import org.apache.pivot.collections.List; |
| import org.apache.pivot.collections.Sequence; |
| import org.apache.pivot.collections.Sequence.Tree.Path; |
| import org.apache.pivot.util.ClassUtils; |
| import org.apache.pivot.util.Filter; |
| import org.apache.pivot.util.Utils; |
| import org.apache.pivot.util.Vote; |
| import org.apache.pivot.wtk.Bounds; |
| import org.apache.pivot.wtk.Button; |
| import org.apache.pivot.wtk.Checkbox; |
| import org.apache.pivot.wtk.Component; |
| import org.apache.pivot.wtk.GraphicsUtilities; |
| import org.apache.pivot.wtk.Keyboard; |
| import org.apache.pivot.wtk.Keyboard.KeyCode; |
| import org.apache.pivot.wtk.Keyboard.KeyLocation; |
| import org.apache.pivot.wtk.Keyboard.Modifier; |
| import org.apache.pivot.wtk.Mouse; |
| import org.apache.pivot.wtk.Orientation; |
| import org.apache.pivot.wtk.Platform; |
| import org.apache.pivot.wtk.Theme; |
| import org.apache.pivot.wtk.TreeView; |
| import org.apache.pivot.wtk.TreeView.SelectMode; |
| import org.apache.pivot.wtk.TreeViewBranchListener; |
| import org.apache.pivot.wtk.TreeViewListener; |
| import org.apache.pivot.wtk.TreeViewNodeListener; |
| import org.apache.pivot.wtk.TreeViewNodeStateListener; |
| import org.apache.pivot.wtk.TreeViewSelectionListener; |
| import org.apache.pivot.wtk.skin.ComponentSkin; |
| |
| /** |
| * Tree view skin. |
| */ |
| public class TerraTreeViewSkin extends ComponentSkin implements TreeView.Skin, TreeViewListener, |
| TreeViewBranchListener, TreeViewNodeListener, TreeViewNodeStateListener, |
| TreeViewSelectionListener { |
| |
| /** |
| * Node info visitor interface. |
| */ |
| protected interface NodeInfoVisitor { |
| /** |
| * Visits the specified node info. |
| * |
| * @param nodeInfo The object to visit |
| */ |
| public void visit(NodeInfo nodeInfo); |
| } |
| |
| /** |
| * Iterates through the visible nodes. For callers who wish to know the path |
| * of each visible node, using this iterator will be much more efficient |
| * than manually iterating over the visible nodes and calling |
| * <tt>getPath()</tt> on each node. |
| */ |
| protected final class VisibleNodeIterator implements Iterator<NodeInfo> { |
| private int index; |
| private int end; |
| |
| private Path path = null; |
| private NodeInfo previous = null; |
| |
| public VisibleNodeIterator() { |
| this(0, visibleNodes.getLength() - 1); |
| } |
| |
| /** |
| * Creates a new visible node iterator that will iterate over a portion |
| * of the visible nodes list (useful during painting). |
| * |
| * @param start The start index, inclusive |
| * @param end The end index, inclusive |
| */ |
| public VisibleNodeIterator(int start, int end) { |
| if (start < 0 || end >= visibleNodes.getLength()) { |
| throw new IndexOutOfBoundsException(); |
| } |
| |
| this.index = start; |
| this.end = end; |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public boolean hasNext() { |
| return (index <= end); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public NodeInfo next() { |
| if (!hasNext()) { |
| throw new NoSuchElementException(); |
| } |
| |
| NodeInfo next = visibleNodes.get(index++); |
| |
| if (path == null) { |
| // First iteration |
| path = next.getPath(); |
| } else if (next.parent == previous) { |
| // Child of previous visible node |
| path.add(0); |
| } else { |
| int n = path.getLength(); |
| while (next.parent != previous.parent) { |
| path.remove(--n, 1); |
| previous = previous.parent; |
| } |
| |
| int tail = path.get(n - 1); |
| path.update(n - 1, tail + 1); |
| } |
| |
| previous = next; |
| |
| return next; |
| } |
| |
| /** |
| * This operation is not supported by this iterator. |
| * |
| * @throws UnsupportedOperationException always since this is unsupported. |
| */ |
| @Override |
| public void remove() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * Gets the index of the node last returned by a call to {@link #next()} |
| * , as seen in the current visible nodes list. Note that as branches |
| * are expanded and collapsed, the row index of any given node in the |
| * tree will change. |
| * |
| * @return The row index of the current node, or <tt>-1</tt> if |
| * <tt>next()</tt> has not yet been called. |
| */ |
| public int getRowIndex() { |
| return (path == null ? -1 : index - 1); |
| } |
| |
| /** |
| * Gets the path of the node last returned by a call to {@link #next()}. |
| * |
| * @return The path to the node, or <tt>null</tt> if <tt>next()</tt> has |
| * not yet been called. |
| */ |
| public Path getPath() { |
| return path; |
| } |
| } |
| |
| /** |
| * An internal data structure that keeps track of skin-related metadata for |
| * a tree node. The justification for the existence of this class lies in |
| * the <tt>visibleNodes</tt> data structure, which is a flat list of nodes |
| * that are visible at any given time. In this context, visible means that |
| * their parent hierarchy is expanded, <b>not</b> that they are being |
| * painted. This list, combined with <tt>getNodeHeight()</tt>, enables us to |
| * quickly determine which nodes to paint given a graphics clip rect. It |
| * also enables us to quickly traverse the tree view when handling key |
| * events. <p> NOTE: some of this data is managed by <tt>TreeView</tt> and |
| * cached here to provide further optimizations during painting and user |
| * input. |
| */ |
| protected static class NodeInfo { |
| // Core metadata |
| final TreeView treeView; |
| final BranchInfo parent; |
| final Object data; |
| final int depth; |
| |
| // Cached fields. Note that this is maintained as a bitmask in favor of |
| // separate properties because it allows us to easily clear any cached |
| // field for all nodes in one common method. See #clearField(byte) |
| byte fields = 0; |
| |
| public static final byte HIGHLIGHTED_MASK = 1 << 0; |
| public static final byte SELECTED_MASK = 1 << 1; |
| public static final byte DISABLED_MASK = 1 << 2; |
| public static final byte CHECKMARK_DISABLED_MASK = 1 << 3; |
| public static final byte CHECK_STATE_CHECKED_MASK = 1 << 4; |
| public static final byte CHECK_STATE_MIXED_MASK = 1 << 5; |
| |
| public static final byte CHECK_STATE_MASK = CHECK_STATE_CHECKED_MASK |
| | CHECK_STATE_MIXED_MASK; |
| |
| private NodeInfo(TreeView treeView, BranchInfo parent, Object data) { |
| this.treeView = treeView; |
| this.parent = parent; |
| this.data = data; |
| |
| depth = (parent == null) ? 0 : parent.depth + 1; |
| |
| // Newly created nodes are guaranteed to not be selected or checked, |
| // but they may be disabled or have their checkmarks disabled, so |
| // we set those flags appropriately here. |
| |
| @SuppressWarnings("unchecked") |
| Filter<Object> disabledNodeFilter = (Filter<Object>) treeView.getDisabledNodeFilter(); |
| if (disabledNodeFilter != null) { |
| setDisabled(disabledNodeFilter.include(data)); |
| } |
| |
| @SuppressWarnings("unchecked") |
| Filter<Object> disabledCheckmarkFilter = (Filter<Object>) treeView.getDisabledCheckmarkFilter(); |
| if (disabledCheckmarkFilter != null) { |
| setCheckmarkDisabled(disabledCheckmarkFilter.include(data)); |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static NodeInfo newInstance(TreeView treeView, BranchInfo parent, Object data) { |
| NodeInfo nodeInfo = null; |
| |
| if (data instanceof List<?>) { |
| nodeInfo = new BranchInfo(treeView, parent, (List<Object>) data); |
| } else { |
| nodeInfo = new NodeInfo(treeView, parent, data); |
| } |
| |
| return nodeInfo; |
| } |
| |
| @SuppressWarnings("unchecked") |
| public Path getPath() { |
| Path path = Path.forDepth(depth); |
| |
| NodeInfo nodeInfo = this; |
| |
| while (nodeInfo.parent != null) { |
| List<Object> parentData = (List<Object>) nodeInfo.parent.data; |
| int index = parentData.indexOf(nodeInfo.data); |
| path.insert(index, 0); |
| |
| nodeInfo = nodeInfo.parent; |
| } |
| |
| return path; |
| } |
| |
| public boolean isHighlighted() { |
| return ((fields & HIGHLIGHTED_MASK) != 0); |
| } |
| |
| public void setHighlighted(boolean highlighted) { |
| if (highlighted) { |
| fields |= HIGHLIGHTED_MASK; |
| } else { |
| fields &= ~HIGHLIGHTED_MASK; |
| } |
| } |
| |
| public boolean isSelected() { |
| return ((fields & SELECTED_MASK) != 0); |
| } |
| |
| public void setSelected(boolean selected) { |
| if (selected) { |
| fields |= SELECTED_MASK; |
| } else { |
| fields &= ~SELECTED_MASK; |
| } |
| } |
| |
| public boolean isDisabled() { |
| return ((fields & DISABLED_MASK) != 0); |
| } |
| |
| public void setDisabled(boolean disabled) { |
| if (disabled) { |
| fields |= DISABLED_MASK; |
| } else { |
| fields &= ~DISABLED_MASK; |
| } |
| } |
| |
| public boolean isCheckmarkDisabled() { |
| return ((fields & CHECKMARK_DISABLED_MASK) != 0); |
| } |
| |
| public void setCheckmarkDisabled(boolean checkmarkDisabled) { |
| if (checkmarkDisabled) { |
| fields |= CHECKMARK_DISABLED_MASK; |
| } else { |
| fields &= ~CHECKMARK_DISABLED_MASK; |
| } |
| } |
| |
| public TreeView.NodeCheckState getCheckState() { |
| TreeView.NodeCheckState checkState; |
| |
| switch (fields & CHECK_STATE_MASK) { |
| case CHECK_STATE_CHECKED_MASK: |
| checkState = TreeView.NodeCheckState.CHECKED; |
| break; |
| case CHECK_STATE_MIXED_MASK: |
| checkState = TreeView.NodeCheckState.MIXED; |
| break; |
| default: |
| checkState = TreeView.NodeCheckState.UNCHECKED; |
| break; |
| } |
| |
| return checkState; |
| } |
| |
| public boolean isChecked() { |
| return ((fields & CHECK_STATE_CHECKED_MASK) != 0); |
| } |
| |
| public void setCheckState(TreeView.NodeCheckState checkState) { |
| fields &= ~CHECK_STATE_MASK; |
| |
| switch (checkState) { |
| case CHECKED: |
| fields |= CHECK_STATE_CHECKED_MASK; |
| break; |
| case MIXED: |
| fields |= CHECK_STATE_MIXED_MASK; |
| break; |
| case UNCHECKED: |
| break; |
| default: |
| break; |
| } |
| } |
| |
| public void clearField(byte mask) { |
| fields &= ~mask; |
| } |
| |
| @Override |
| public String toString() { |
| return ClassUtils.simpleToString(this); |
| } |
| } |
| |
| /** |
| * An internal data structure that keeps track of skin-related metadata for |
| * a tree branch. |
| */ |
| protected static final class BranchInfo extends NodeInfo { |
| // Core skin metadata |
| private List<NodeInfo> children = null; |
| |
| public static final byte EXPANDED_MASK = 1 << 6; |
| |
| private BranchInfo(TreeView treeView, BranchInfo parent, List<Object> data) { |
| super(treeView, parent, data); |
| } |
| |
| /** |
| * Loads this branch info's children. The children list is initialized |
| * to <tt>null</tt> and loaded lazily to allow the skin to only create |
| * <tt>NodeInfo</tt> objects for the nodes that it actually needs in |
| * order to paint. Thus, it is the responsibility of the skin to check |
| * if <tt>children</tt> is null and call <tt>loadChildren()</tt> if |
| * necessary. |
| */ |
| @SuppressWarnings("unchecked") |
| public void loadChildren() { |
| if (children == null || children.isEmpty()) { |
| List<Object> dataLocal = (List<Object>) this.data; |
| int count = dataLocal.getLength(); |
| |
| children = new ArrayList<>(count); |
| |
| for (int i = 0; i < count; i++) { |
| Object nodeData = dataLocal.get(i); |
| NodeInfo childNodeInfo = NodeInfo.newInstance(treeView, this, nodeData); |
| children.add(childNodeInfo); |
| } |
| } |
| } |
| |
| public boolean isExpanded() { |
| return ((fields & EXPANDED_MASK) != 0); |
| } |
| |
| public void setExpanded(boolean expanded) { |
| if (expanded) { |
| fields |= EXPANDED_MASK; |
| } else { |
| fields &= ~EXPANDED_MASK; |
| } |
| } |
| } |
| |
| private BranchInfo rootBranchInfo = null; |
| private List<NodeInfo> visibleNodes = new ArrayList<>(); |
| |
| private NodeInfo highlightedNode = null; |
| private Path selectPath = null; |
| |
| // Styles |
| private Font font; |
| private Color color; |
| private Color disabledColor; |
| private Color backgroundColor; |
| private Color selectionColor; |
| private Color selectionBackgroundColor; |
| private Color inactiveSelectionColor; |
| private Color inactiveSelectionBackgroundColor; |
| private Color highlightColor; |
| private Color highlightBackgroundColor; |
| private int spacing; |
| private int indent; |
| private boolean showHighlight; |
| private boolean showBranchControls; |
| private boolean showEmptyBranchControls; |
| private Color branchControlColor; |
| private Color branchControlSelectionColor; |
| private Color branchControlInactiveSelectionColor; |
| private Color gridColor; |
| private boolean showGridLines; |
| |
| private boolean validateSelection = false; |
| |
| private static final int BRANCH_CONTROL_IMAGE_WIDTH = 8; |
| private static final int BRANCH_CONTROL_IMAGE_HEIGHT = 8; |
| private static final int VERTICAL_SPACING = 1; |
| |
| private static final Checkbox CHECKBOX = new Checkbox(); |
| private static final int CHECKBOX_VERTICAL_PADDING = 2; |
| |
| static { |
| CHECKBOX.setSize(CHECKBOX.getPreferredSize()); |
| CHECKBOX.setTriState(true); |
| } |
| |
| public TerraTreeViewSkin() { |
| Theme theme = currentTheme(); |
| |
| font = theme.getFont(); |
| color = theme.getColor(1); |
| disabledColor = theme.getColor(7); |
| backgroundColor = theme.getColor(4); |
| selectionColor = theme.getColor(4); |
| selectionBackgroundColor = theme.getColor(14); |
| inactiveSelectionColor = theme.getColor(1); |
| inactiveSelectionBackgroundColor = theme.getColor(10); |
| highlightColor = theme.getColor(1); |
| highlightBackgroundColor = theme.getColor(10); |
| spacing = 6; |
| indent = 16; |
| showHighlight = true; |
| showBranchControls = true; |
| showEmptyBranchControls = true; |
| branchControlColor = theme.getColor(12); |
| branchControlSelectionColor = theme.getColor(4); |
| branchControlInactiveSelectionColor = theme.getColor(14); |
| gridColor = theme.getColor(11); |
| showGridLines = false; |
| } |
| |
| @Override |
| public void install(Component component) { |
| super.install(component); |
| |
| TreeView treeView = (TreeView) component; |
| treeView.getTreeViewListeners().add(this); |
| treeView.getTreeViewBranchListeners().add(this); |
| treeView.getTreeViewNodeListeners().add(this); |
| treeView.getTreeViewNodeStateListeners().add(this); |
| treeView.getTreeViewSelectionListeners().add(this); |
| |
| treeDataChanged(treeView, null); |
| } |
| |
| @Override |
| public int getPreferredWidth(int height) { |
| TreeView treeView = (TreeView) getComponent(); |
| TreeView.NodeRenderer nodeRenderer = treeView.getNodeRenderer(); |
| |
| int preferredWidth = 0; |
| |
| VisibleNodeIterator visibleNodeIterator = new VisibleNodeIterator(); |
| while (visibleNodeIterator.hasNext()) { |
| NodeInfo nodeInfo = visibleNodeIterator.next(); |
| |
| int nodeWidth = (nodeInfo.depth - 1) * (indent + spacing); |
| |
| nodeRenderer.render(nodeInfo.data, visibleNodeIterator.getPath(), |
| visibleNodeIterator.getRowIndex(), treeView, false, false, |
| TreeView.NodeCheckState.UNCHECKED, false, false); |
| nodeWidth += nodeRenderer.getPreferredWidth(-1); |
| |
| preferredWidth = Math.max(preferredWidth, nodeWidth); |
| } |
| |
| if (showBranchControls) { |
| preferredWidth += indent + spacing; |
| } |
| |
| if (treeView.getCheckmarksEnabled()) { |
| preferredWidth += Math.max(CHECKBOX.getWidth(), indent) + spacing; |
| } |
| |
| return preferredWidth; |
| } |
| |
| @Override |
| public int getPreferredHeight(int width) { |
| int nodeHeight = getNodeHeight(); |
| int visibleNodeCount = visibleNodes.getLength(); |
| |
| int preferredHeight = nodeHeight * visibleNodeCount; |
| |
| if (visibleNodeCount > 1) { |
| preferredHeight += VERTICAL_SPACING * (visibleNodeCount - 1); |
| } |
| |
| return preferredHeight; |
| } |
| |
| @Override |
| public int getBaseline(int width, int height) { |
| int baseline = -1; |
| |
| if (visibleNodes.getLength() > 0) { |
| TreeView treeView = (TreeView) getComponent(); |
| TreeView.NodeRenderer nodeRenderer = treeView.getNodeRenderer(); |
| |
| NodeInfo nodeInfo = visibleNodes.get(0); |
| |
| int nodeWidth = width - (nodeInfo.depth - 1) * (indent + spacing); |
| int nodeHeight = getNodeHeight(); |
| |
| boolean expanded = false; |
| boolean selected = nodeInfo.isSelected(); |
| boolean highlighted = nodeInfo.isHighlighted(); |
| boolean disabled = nodeInfo.isDisabled(); |
| |
| if (showBranchControls) { |
| if (nodeInfo instanceof BranchInfo) { |
| BranchInfo branchInfo = (BranchInfo) nodeInfo; |
| expanded = branchInfo.isExpanded(); |
| } |
| |
| nodeWidth -= (indent + spacing); |
| } |
| |
| TreeView.NodeCheckState checkState = TreeView.NodeCheckState.UNCHECKED; |
| if (treeView.getCheckmarksEnabled()) { |
| checkState = nodeInfo.getCheckState(); |
| nodeWidth -= (Math.max(indent, CHECKBOX.getWidth()) + spacing); |
| } |
| |
| nodeRenderer.render(nodeInfo.data, nodeInfo.getPath(), 0, treeView, expanded, selected, |
| checkState, highlighted, disabled); |
| baseline = nodeRenderer.getBaseline(nodeWidth, nodeHeight); |
| } |
| |
| return baseline; |
| } |
| |
| @Override |
| public void layout() { |
| if (validateSelection) { |
| // Ensure that the selection is visible |
| scrollSelectionToVisible(); |
| } |
| |
| validateSelection = false; |
| } |
| |
| @Override |
| public void paint(Graphics2D graphics) { |
| TreeView treeView = (TreeView) getComponent(); |
| TreeView.NodeRenderer nodeRenderer = treeView.getNodeRenderer(); |
| |
| int width = getWidth(); |
| int height = getHeight(); |
| |
| int nodeHeight = getNodeHeight(); |
| |
| // Paint the background |
| if (backgroundColor != null) { |
| graphics.setPaint(backgroundColor); |
| graphics.fillRect(0, 0, width, height); |
| } |
| |
| // nodeStart and nodeEnd are both inclusive |
| int nodeStart = 0; |
| int nodeEnd = visibleNodes.getLength() - 1; |
| |
| // Ensure that we only paint items that are visible |
| Rectangle clipBounds = graphics.getClipBounds(); |
| if (clipBounds != null) { |
| nodeStart = Math.max(nodeStart, |
| (int) (clipBounds.y / (double) (nodeHeight + VERTICAL_SPACING))); |
| nodeEnd = Math.min( |
| nodeEnd, |
| (int) ((clipBounds.y + clipBounds.height) / (double) (nodeHeight + VERTICAL_SPACING))); |
| } |
| |
| int nodeY = nodeStart * (nodeHeight + VERTICAL_SPACING); |
| |
| VisibleNodeIterator visibleNodeIterator = new VisibleNodeIterator(nodeStart, nodeEnd); |
| while (visibleNodeIterator.hasNext()) { |
| NodeInfo nodeInfo = visibleNodeIterator.next(); |
| |
| boolean expanded = false; |
| boolean highlighted = nodeInfo.isHighlighted(); |
| boolean selected = nodeInfo.isSelected(); |
| boolean disabled = nodeInfo.isDisabled(); |
| |
| int nodeX = (nodeInfo.depth - 1) * (indent + spacing); |
| |
| if (treeView.isEnabled()) { |
| if (selected) { |
| // Paint the selection state |
| Color selectionBackgroundColorLocal = treeView.isFocused() ? this.selectionBackgroundColor |
| : inactiveSelectionBackgroundColor; |
| graphics.setPaint(selectionBackgroundColorLocal); |
| graphics.fillRect(0, nodeY, width, nodeHeight); |
| } else if (highlighted && !disabled) { |
| // Paint the highlight state |
| graphics.setPaint(highlightBackgroundColor); |
| graphics.fillRect(0, nodeY, width, nodeHeight); |
| } |
| } |
| |
| // Paint the expand/collapse control |
| if (showBranchControls) { |
| if (nodeInfo instanceof BranchInfo) { |
| BranchInfo branchInfo = (BranchInfo) nodeInfo; |
| |
| boolean showBranchControl = true; |
| if (!showEmptyBranchControls) { |
| branchInfo.loadChildren(); |
| showBranchControl = !(branchInfo.children == null || branchInfo.children.isEmpty()); |
| } |
| |
| if (showBranchControl) { |
| expanded = branchInfo.isExpanded(); |
| |
| Color branchControlColorLocal; |
| |
| if (selected) { |
| if (treeView.isFocused()) { |
| branchControlColorLocal = branchControlSelectionColor; |
| } else { |
| branchControlColorLocal = branchControlInactiveSelectionColor; |
| } |
| } else { |
| branchControlColorLocal = this.branchControlColor; |
| } |
| |
| GeneralPath shape = new GeneralPath(); |
| |
| int imageX = nodeX + (indent - BRANCH_CONTROL_IMAGE_WIDTH) / 2; |
| int imageY = nodeY + (nodeHeight - BRANCH_CONTROL_IMAGE_HEIGHT) / 2; |
| |
| if (expanded) { |
| shape.moveTo(imageX, imageY + 1); |
| shape.lineTo(imageX + 8, imageY + 1); |
| shape.lineTo(imageX + 4, imageY + 7); |
| } else { |
| shape.moveTo(imageX + 1, imageY); |
| shape.lineTo(imageX + 7, imageY + 4); |
| shape.lineTo(imageX + 1, imageY + 8); |
| } |
| |
| shape.closePath(); |
| |
| Graphics2D branchControlGraphics = (Graphics2D) graphics.create(); |
| GraphicsUtilities.setAntialiasingOn(branchControlGraphics); |
| if (!treeView.isEnabled() || disabled) { |
| branchControlGraphics.setComposite(AlphaComposite.getInstance( |
| AlphaComposite.SRC_OVER, 0.5f)); |
| } |
| branchControlGraphics.setPaint(branchControlColorLocal); |
| branchControlGraphics.fill(shape); |
| branchControlGraphics.dispose(); |
| } |
| } |
| |
| nodeX += indent + spacing; |
| } |
| |
| // Paint the checkbox |
| TreeView.NodeCheckState checkState = TreeView.NodeCheckState.UNCHECKED; |
| if (treeView.getCheckmarksEnabled()) { |
| checkState = nodeInfo.getCheckState(); |
| |
| int checkboxWidth = CHECKBOX.getWidth(); |
| int checkboxHeight = CHECKBOX.getHeight(); |
| |
| int checkboxX = Math.max(indent - checkboxWidth, 0) / 2; |
| int checkboxY = (nodeHeight - checkboxHeight) / 2; |
| Graphics2D checkboxGraphics = (Graphics2D) graphics.create(nodeX + checkboxX, nodeY |
| + checkboxY, checkboxWidth, checkboxHeight); |
| |
| Button.State state; |
| switch (checkState) { |
| case CHECKED: |
| state = Button.State.SELECTED; |
| break; |
| case MIXED: |
| state = Button.State.MIXED; |
| break; |
| default: |
| state = Button.State.UNSELECTED; |
| break; |
| } |
| |
| CHECKBOX.setState(state); |
| CHECKBOX.setEnabled(treeView.isEnabled() && !disabled |
| && !nodeInfo.isCheckmarkDisabled()); |
| CHECKBOX.paint(checkboxGraphics); |
| checkboxGraphics.dispose(); |
| |
| nodeX += Math.max(indent, checkboxWidth) + spacing; |
| } |
| |
| int nodeWidth = Math.max(width - nodeX, 0); |
| |
| // Paint the node data |
| Graphics2D rendererGraphics = (Graphics2D) graphics.create(nodeX, nodeY, nodeWidth, |
| nodeHeight); |
| nodeRenderer.render(nodeInfo.data, visibleNodeIterator.getPath(), |
| visibleNodeIterator.getRowIndex(), treeView, expanded, selected, checkState, |
| highlighted, disabled); |
| nodeRenderer.setSize(nodeWidth, nodeHeight); |
| nodeRenderer.paint(rendererGraphics); |
| rendererGraphics.dispose(); |
| |
| // Paint the grid line |
| if (showGridLines) { |
| graphics.setPaint(gridColor); |
| |
| GraphicsUtilities.drawLine(graphics, 0, nodeY + nodeHeight, width, |
| Orientation.HORIZONTAL); |
| } |
| |
| nodeY += nodeHeight + VERTICAL_SPACING; |
| } |
| } |
| |
| public Font getFont() { |
| return font; |
| } |
| |
| public void setFont(Font font) { |
| Utils.checkNull(font, "font"); |
| |
| this.font = font; |
| invalidateComponent(); |
| } |
| |
| public final void setFont(String font) { |
| setFont(decodeFont(font)); |
| } |
| |
| public final void setFont(Dictionary<String, ?> font) { |
| setFont(Theme.deriveFont(font)); |
| } |
| |
| public Color getColor() { |
| return color; |
| } |
| |
| public void setColor(Color color) { |
| Utils.checkNull(color, "color"); |
| |
| this.color = color; |
| repaintComponent(); |
| } |
| |
| public void setColor(String color) { |
| setColor(GraphicsUtilities.decodeColor(color, "color")); |
| } |
| |
| public final void setColor(int color) { |
| Theme theme = currentTheme(); |
| setColor(theme.getColor(color)); |
| } |
| |
| public Color getDisabledColor() { |
| return disabledColor; |
| } |
| |
| public void setDisabledColor(Color disabledColor) { |
| Utils.checkNull(disabledColor, "disabledColor"); |
| |
| this.disabledColor = disabledColor; |
| repaintComponent(); |
| } |
| |
| public void setDisabledColor(String disabledColor) { |
| setDisabledColor(GraphicsUtilities.decodeColor(disabledColor, "disabledColor")); |
| } |
| |
| public final void setDisabledColor(int disabledColor) { |
| Theme theme = currentTheme(); |
| setDisabledColor(theme.getColor(disabledColor)); |
| } |
| |
| public Color getBackgroundColor() { |
| return backgroundColor; |
| } |
| |
| public void setBackgroundColor(Color backgroundColor) { |
| // We allow a null background color here |
| this.backgroundColor = backgroundColor; |
| repaintComponent(); |
| } |
| |
| public void setBackgroundColor(String backgroundColor) { |
| setBackgroundColor(GraphicsUtilities.decodeColor(backgroundColor, "backgroundColor")); |
| } |
| |
| public final void setBackgroundColor(int backgroundColor) { |
| Theme theme = currentTheme(); |
| setBackgroundColor(theme.getColor(backgroundColor)); |
| } |
| |
| public Color getSelectionColor() { |
| return selectionColor; |
| } |
| |
| public void setSelectionColor(Color selectionColor) { |
| Utils.checkNull(selectionColor, "selectionColor"); |
| |
| this.selectionColor = selectionColor; |
| repaintComponent(); |
| } |
| |
| public void setSelectionColor(String selectionColor) { |
| setSelectionColor(GraphicsUtilities.decodeColor(selectionColor, "selectionColor")); |
| } |
| |
| public final void setSelectionColor(int selectionColor) { |
| Theme theme = currentTheme(); |
| setSelectionColor(theme.getColor(selectionColor)); |
| } |
| |
| public Color getSelectionBackgroundColor() { |
| return selectionBackgroundColor; |
| } |
| |
| public void setSelectionBackgroundColor(Color selectionBackgroundColor) { |
| Utils.checkNull(selectionBackgroundColor, "selectionBackgroundColor"); |
| |
| this.selectionBackgroundColor = selectionBackgroundColor; |
| repaintComponent(); |
| } |
| |
| public void setSelectionBackgroundColor(String selectionBackgroundColor) { |
| setSelectionBackgroundColor( |
| GraphicsUtilities.decodeColor(selectionBackgroundColor, "selectionBackgroundColor")); |
| } |
| |
| public final void setSelectionBackgroundColor(int selectionBackgroundColor) { |
| Theme theme = currentTheme(); |
| setSelectionBackgroundColor(theme.getColor(selectionBackgroundColor)); |
| } |
| |
| public Color getInactiveSelectionColor() { |
| return inactiveSelectionColor; |
| } |
| |
| public void setInactiveSelectionColor(Color inactiveSelectionColor) { |
| Utils.checkNull(inactiveSelectionColor, "inactiveSelectionColor"); |
| |
| this.inactiveSelectionColor = inactiveSelectionColor; |
| repaintComponent(); |
| } |
| |
| public void setInactiveSelectionColor(String inactiveSelectionColor) { |
| setInactiveSelectionColor( |
| GraphicsUtilities.decodeColor(inactiveSelectionColor, "inactiveSelectionColor")); |
| } |
| |
| public final void setInactiveSelectionColor(int inactiveSelectionColor) { |
| Theme theme = currentTheme(); |
| setInactiveSelectionColor(theme.getColor(inactiveSelectionColor)); |
| } |
| |
| public Color getInactiveSelectionBackgroundColor() { |
| return inactiveSelectionBackgroundColor; |
| } |
| |
| public void setInactiveSelectionBackgroundColor(Color inactiveSelectionBackgroundColor) { |
| Utils.checkNull(inactiveSelectionBackgroundColor, "inactiveSelectionBackgroundColor"); |
| |
| this.inactiveSelectionBackgroundColor = inactiveSelectionBackgroundColor; |
| repaintComponent(); |
| } |
| |
| public void setInactiveSelectionBackgroundColor(String inactiveSelectionBackgroundColor) { |
| setInactiveSelectionBackgroundColor( |
| GraphicsUtilities.decodeColor(inactiveSelectionBackgroundColor, "inactiveSelectionBackgroundColor")); |
| } |
| |
| public final void setInactiveSelectionBackgroundColor(int inactiveSelectionBackgroundColor) { |
| Theme theme = currentTheme(); |
| setInactiveSelectionBackgroundColor(theme.getColor(inactiveSelectionBackgroundColor)); |
| } |
| |
| public Color getHighlightColor() { |
| return highlightColor; |
| } |
| |
| public void setHighlightColor(Color highlightColor) { |
| Utils.checkNull(highlightColor, "highlightColor"); |
| |
| this.highlightColor = highlightColor; |
| repaintComponent(); |
| } |
| |
| public void setHighlightColor(String highlightColor) { |
| setHighlightColor(GraphicsUtilities.decodeColor(highlightColor, "highlightColor")); |
| } |
| |
| public final void setHighlightColor(int highlightColor) { |
| Theme theme = currentTheme(); |
| setHighlightColor(theme.getColor(highlightColor)); |
| } |
| |
| public Color getHighlightBackgroundColor() { |
| return highlightBackgroundColor; |
| } |
| |
| public void setHighlightBackgroundColor(Color highlightBackgroundColor) { |
| Utils.checkNull(highlightBackgroundColor, "highlightBackgroundColor"); |
| |
| this.highlightBackgroundColor = highlightBackgroundColor; |
| repaintComponent(); |
| } |
| |
| public void setHighlightBackgroundColor(String highlightBackgroundColor) { |
| setHighlightBackgroundColor( |
| GraphicsUtilities.decodeColor(highlightBackgroundColor, "highlightBackgroundColor")); |
| } |
| |
| public final void setHighlightBackgroundColor(int highlightBackgroundColor) { |
| Theme theme = currentTheme(); |
| setHighlightBackgroundColor(theme.getColor(highlightBackgroundColor)); |
| } |
| |
| public int getSpacing() { |
| return spacing; |
| } |
| |
| public void setSpacing(int spacing) { |
| Utils.checkNonNegative(spacing, "spacing"); |
| |
| this.spacing = spacing; |
| invalidateComponent(); |
| } |
| |
| public void setSpacing(Number spacing) { |
| Utils.checkNull(spacing, "spacing"); |
| |
| setSpacing(spacing.intValue()); |
| } |
| |
| public int getIndent() { |
| return indent; |
| } |
| |
| public void setIndent(int indent) { |
| Utils.checkNonNegative(indent, "indent"); |
| |
| this.indent = indent; |
| invalidateComponent(); |
| } |
| |
| public void setIndent(Number indent) { |
| Utils.checkNull(indent, "indent"); |
| |
| setIndent(indent.intValue()); |
| } |
| |
| public boolean getShowHighlight() { |
| return showHighlight; |
| } |
| |
| public void setShowHighlight(boolean showHighlight) { |
| this.showHighlight = showHighlight; |
| repaintComponent(); |
| } |
| |
| public boolean getShowBranchControls() { |
| return showBranchControls; |
| } |
| |
| public void setShowBranchControls(boolean showBranchControls) { |
| this.showBranchControls = showBranchControls; |
| invalidateComponent(); |
| } |
| |
| public boolean getShowEmptyBranchControls() { |
| return showEmptyBranchControls; |
| } |
| |
| public void setShowEmptyBranchControls(boolean showEmptyBranchControls) { |
| this.showEmptyBranchControls = showEmptyBranchControls; |
| repaintComponent(); |
| } |
| |
| public Color getBranchControlColor() { |
| return branchControlColor; |
| } |
| |
| public void setBranchControlColor(Color branchControlColor) { |
| Utils.checkNull(branchControlColor, "branchControlColor"); |
| |
| this.branchControlColor = branchControlColor; |
| repaintComponent(); |
| } |
| |
| public void setBranchControlColor(String branchControlColor) { |
| setBranchControlColor(GraphicsUtilities.decodeColor(branchControlColor, "branchControlColor")); |
| } |
| |
| public final void setBranchControlColor(int branchControlColor) { |
| Theme theme = currentTheme(); |
| setBranchControlColor(theme.getColor(branchControlColor)); |
| } |
| |
| public Color getBranchControlSelectionColor() { |
| return branchControlSelectionColor; |
| } |
| |
| public void setBranchControlSelectionColor(Color branchControlSelectionColor) { |
| Utils.checkNull(branchControlSelectionColor, "branchControlSelectionColor"); |
| |
| this.branchControlSelectionColor = branchControlSelectionColor; |
| repaintComponent(); |
| } |
| |
| public void setBranchControlSelectionColor(String branchControlSelectionColor) { |
| setBranchControlSelectionColor( |
| GraphicsUtilities.decodeColor(branchControlSelectionColor, "branchControlSelectionColor")); |
| } |
| |
| public final void setBranchControlSelectionColor(int branchControlSelectionColor) { |
| Theme theme = currentTheme(); |
| setBranchControlSelectionColor(theme.getColor(branchControlSelectionColor)); |
| } |
| |
| public Color getBranchControlInactiveSelectionColor() { |
| return branchControlInactiveSelectionColor; |
| } |
| |
| public void setBranchControlInactiveSelectionColor(Color branchControlInactiveSelectionColor) { |
| Utils.checkNull(branchControlInactiveSelectionColor, "branchControlInactiveSelectionColor"); |
| |
| this.branchControlInactiveSelectionColor = branchControlInactiveSelectionColor; |
| repaintComponent(); |
| } |
| |
| public void setBranchControlInactiveSelectionColor(String branchControlInactiveSelectionColor) { |
| setBranchControlInactiveSelectionColor( |
| GraphicsUtilities.decodeColor(branchControlInactiveSelectionColor, "branchControlInactiveSelectionColor")); |
| } |
| |
| public final void setBranchControlInactiveSelectionColor(int branchControlInactiveSelectionColor) { |
| Theme theme = currentTheme(); |
| setBranchControlInactiveSelectionColor(theme.getColor(branchControlInactiveSelectionColor)); |
| } |
| |
| public Color getGridColor() { |
| return gridColor; |
| } |
| |
| public void setGridColor(Color gridColor) { |
| Utils.checkNull(gridColor, "gridColor"); |
| |
| this.gridColor = gridColor; |
| repaintComponent(); |
| } |
| |
| public void setGridColor(String gridColor) { |
| setGridColor(GraphicsUtilities.decodeColor(gridColor, "gridColor")); |
| } |
| |
| public final void setGridColor(int gridColor) { |
| Theme theme = currentTheme(); |
| setGridColor(theme.getColor(gridColor)); |
| } |
| |
| public boolean getShowGridLines() { |
| return showGridLines; |
| } |
| |
| public void setShowGridLines(boolean showGridLines) { |
| this.showGridLines = showGridLines; |
| repaintComponent(); |
| } |
| |
| /** |
| * @return The fixed node height of this skin. |
| */ |
| protected int getNodeHeight() { |
| TreeView treeView = (TreeView) getComponent(); |
| TreeView.NodeRenderer nodeRenderer = treeView.getNodeRenderer(); |
| nodeRenderer.render(null, null, -1, treeView, false, false, |
| TreeView.NodeCheckState.UNCHECKED, false, false); |
| |
| int nodeHeight = nodeRenderer.getPreferredHeight(-1); |
| if (treeView.getCheckmarksEnabled()) { |
| nodeHeight = Math.max(CHECKBOX.getHeight() + (2 * CHECKBOX_VERTICAL_PADDING), |
| nodeHeight); |
| } |
| |
| return nodeHeight; |
| } |
| |
| /** |
| * @return The metadata associated with the node found at the specified |
| * y-coordinate, or <tt>null</tt> if there is no node at that location. |
| * @param y The current Y location. |
| */ |
| protected final NodeInfo getNodeInfoAt(int y) { |
| NodeInfo nodeInfo = null; |
| |
| int nodeHeight = getNodeHeight(); |
| int index = y / (nodeHeight + VERTICAL_SPACING); |
| |
| if (index >= 0 && index < visibleNodes.getLength()) { |
| nodeInfo = visibleNodes.get(index); |
| } |
| |
| return nodeInfo; |
| } |
| |
| /** |
| * @return The metadata associated with the node at the specified path. The |
| * path must be valid. The empty path is supported and represents the root |
| * node info. |
| * @param path The path to query. |
| */ |
| protected final NodeInfo getNodeInfoAt(Path path) { |
| assert (path != null) : "Path is null"; |
| |
| NodeInfo result = null; |
| int n = path.getLength(); |
| |
| if (n == 0) { |
| result = rootBranchInfo; |
| } else { |
| BranchInfo branchInfo = rootBranchInfo; |
| |
| for (int i = 0; i < n - 1; i++) { |
| branchInfo.loadChildren(); |
| NodeInfo nodeInfo = branchInfo.children.get(path.get(i)); |
| |
| assert (nodeInfo instanceof BranchInfo) : "Invalid path"; |
| |
| branchInfo = (BranchInfo) nodeInfo; |
| } |
| |
| branchInfo.loadChildren(); |
| result = branchInfo.children.get(path.get(n - 1)); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * @return The bounding box defined by the specified node, or <tt>null</tt> if |
| * the node is not currently visible. |
| * @param nodeInfo The node information to search for. |
| */ |
| protected final Bounds getNodeBounds(NodeInfo nodeInfo) { |
| Bounds bounds = null; |
| |
| int index = visibleNodes.indexOf(nodeInfo); |
| |
| if (index >= 0) { |
| int nodeHeight = getNodeHeight(); |
| int nodeY = index * (nodeHeight + VERTICAL_SPACING); |
| |
| bounds = new Bounds(0, nodeY, getWidth(), nodeHeight); |
| } |
| |
| return bounds; |
| } |
| |
| /** |
| * Accepts the specified visitor on all node info objects that exist in this |
| * skin's node info hierarchy. |
| * |
| * @param visitor The callback to execute on each node info object |
| */ |
| protected final void accept(NodeInfoVisitor visitor) { |
| Sequence<NodeInfo> nodes = new ArrayList<>(); |
| nodes.add(rootBranchInfo); |
| |
| while (nodes.getLength() > 0) { |
| NodeInfo nodeInfo = nodes.get(0); |
| nodes.remove(0, 1); |
| |
| visitor.visit(nodeInfo); |
| |
| if (nodeInfo instanceof BranchInfo) { |
| BranchInfo branchInfo = (BranchInfo) nodeInfo; |
| |
| if (branchInfo.children != null) { |
| for (int i = 0, n = branchInfo.children.getLength(); i < n; i++) { |
| nodes.insert(branchInfo.children.get(i), i); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Adds all children of the specified branch to the visible node list. Any |
| * children nodes that are expanded [branches] will also have their children |
| * made visible, and so on. Invalidates the component only if necessary. |
| */ |
| private void addVisibleNodes(BranchInfo parentBranchInfo) { |
| int insertIndex = -1; |
| |
| if (parentBranchInfo == rootBranchInfo) { |
| // Bootstrap case since the root branch is implicitly expanded |
| insertIndex = 0; |
| } else { |
| int branchIndex = visibleNodes.indexOf(parentBranchInfo); |
| if (branchIndex >= 0) { |
| insertIndex = branchIndex + 1; |
| } |
| } |
| |
| if (insertIndex >= 0) { |
| Sequence<NodeInfo> nodes = new ArrayList<>(); |
| |
| // The parent branch's children are the baseline nodes to make visible |
| parentBranchInfo.loadChildren(); |
| for (int i = 0, n = parentBranchInfo.children.getLength(); i < n; i++) { |
| nodes.add(parentBranchInfo.children.get(i)); |
| } |
| |
| while (nodes.getLength() > 0) { |
| NodeInfo nodeInfo = nodes.get(0); |
| nodes.remove(0, 1); |
| visibleNodes.insert(nodeInfo, insertIndex++); |
| |
| // If we encounter an expanded branch, we add that branch's |
| // children to our list of nodes that are to become visible |
| if (nodeInfo instanceof BranchInfo) { |
| BranchInfo branchInfo = (BranchInfo) nodeInfo; |
| if (branchInfo.isExpanded()) { |
| branchInfo.loadChildren(); |
| for (int i = 0, n = branchInfo.children.getLength(); i < n; i++) { |
| nodes.insert(branchInfo.children.get(i), i); |
| } |
| } |
| } |
| } |
| |
| invalidateComponent(); |
| } |
| } |
| |
| /** |
| * Adds the specified child of the specified branch to the visible node |
| * list. It is assumed that the child in question is not an expanded branch. |
| * Invalidates the component only if necessary. |
| * |
| * @param parentBranchInfo The branch info of the parent node. |
| * @param index The index of the child within its parent. |
| */ |
| private void addVisibleNode(BranchInfo parentBranchInfo, int index) { |
| parentBranchInfo.loadChildren(); |
| |
| assert (index >= 0) : "Index is too small"; |
| assert (index < parentBranchInfo.children.getLength()) : "Index is too large"; |
| |
| int branchIndex = visibleNodes.indexOf(parentBranchInfo); |
| |
| if (parentBranchInfo == rootBranchInfo |
| || (branchIndex >= 0 && parentBranchInfo.isExpanded())) { |
| |
| NodeInfo nodeInfo = parentBranchInfo.children.get(index); |
| int insertIndex = branchIndex + index + 1; |
| |
| if (index > 0) { |
| // Siblings of the node that lie before it may be expanded |
| // branches, thus adding their own children to the |
| // visible nodes list and pushing down our insert index |
| NodeInfo youngerSibling = parentBranchInfo.children.get(index - 1); |
| |
| // Try to insert after our younger sibling |
| insertIndex = visibleNodes.indexOf(youngerSibling) + 1; |
| |
| // Continue looking as long as the node at our insert index |
| // has a greater depth than we do, which means that it's a |
| // descendant of our younger sibling |
| for (int n = visibleNodes.getLength(), nodeDepth = youngerSibling.depth; insertIndex < n |
| && visibleNodes.get(insertIndex).depth > nodeDepth; insertIndex++) { |
| continue; |
| } |
| } |
| |
| visibleNodes.insert(nodeInfo, insertIndex); |
| |
| invalidateComponent(); |
| } |
| } |
| |
| /** |
| * Removes the specified children of the specified branch from the visible |
| * node list if necessary. If they are not already in the visible node list, |
| * nothing happens. Invalidates the component only if necessary. |
| * |
| * @param parentBranchInfo The branch info of the parent node. |
| * @param index The index of the first child node to remove from the visible |
| * nodes sequence. |
| * @param count The number of child nodes to remove, or <tt>-1</tt> to remove |
| * all child nodes from the visible nodes sequence. |
| */ |
| private void removeVisibleNodes(BranchInfo parentBranchInfo, int index, int count) { |
| parentBranchInfo.loadChildren(); |
| int childrenLength = parentBranchInfo.children.getLength(); |
| |
| int countUpdated = count; |
| |
| if (countUpdated == -1) { |
| assert (index == 0) : "Non-zero index with 'remove all' count"; |
| countUpdated = childrenLength; |
| } |
| |
| // If the index is greater-equal the child length, then there could |
| // not possibly be any visible nodes, so just quit |
| if (index >= childrenLength) { |
| return; |
| } |
| assert (index + countUpdated <= childrenLength) : "Value too big"; |
| if (countUpdated > 0) { |
| NodeInfo first = parentBranchInfo.children.get(index); |
| NodeInfo last = parentBranchInfo.children.get(index + countUpdated - 1); |
| |
| int rangeStart = visibleNodes.indexOf(first); |
| |
| if (rangeStart >= 0) { |
| int rangeEnd = visibleNodes.indexOf(last) + 1; |
| |
| assert (rangeEnd > rangeStart) : "Invalid visible node structure"; |
| |
| // Continue looking as long as the node at our endpoint has a |
| // greater depth than the last child node, which means that |
| // it's a descendant of the last child node |
| for (int n = visibleNodes.getLength(), nodeDepth = last.depth; rangeEnd < n |
| && visibleNodes.get(rangeEnd).depth > nodeDepth; rangeEnd++) { |
| continue; |
| } |
| |
| visibleNodes.remove(rangeStart, rangeEnd - rangeStart); |
| |
| invalidateComponent(); |
| } |
| } |
| } |
| |
| /** |
| * Repaints the region occupied by the specified node. |
| * |
| * @param nodeInfo The node to search for. |
| */ |
| protected void repaintNode(NodeInfo nodeInfo) { |
| Bounds bounds = getNodeBounds(nodeInfo); |
| if (bounds != null) { |
| repaintComponent(bounds); |
| } |
| } |
| |
| /** |
| * Clears the highlighted node if one exists. |
| */ |
| protected void clearHighlightedNode() { |
| if (highlightedNode != null) { |
| highlightedNode.setHighlighted(false); |
| repaintNode(highlightedNode); |
| |
| highlightedNode = null; |
| } |
| } |
| |
| /** |
| * Clears our <tt>NodeInfo</tt> hierarchy of the specified cached field. |
| * |
| * @param mask The bitmask specifying which field to clear. |
| */ |
| private void clearFields(final byte mask) { |
| accept(new NodeInfoVisitor() { |
| @Override |
| public void visit(NodeInfo nodeInfo) { |
| nodeInfo.clearField(mask); |
| } |
| }); |
| } |
| |
| /** |
| * Scrolls the last visible (expanded) selected node into viewport |
| * visibility. If no such node exists, nothing happens. <p> This should only |
| * be called when the tree view is valid. |
| */ |
| private void scrollSelectionToVisible() { |
| TreeView treeView = (TreeView) getComponent(); |
| |
| Sequence<Path> selectedPaths = treeView.getSelectedPaths(); |
| int n = selectedPaths.getLength(); |
| |
| if (n > 0) { |
| Bounds nodeBounds = null; |
| |
| for (int i = n - 1; i >= 0 && nodeBounds == null; i--) { |
| NodeInfo nodeInfo = getNodeInfoAt(selectedPaths.get(i)); |
| nodeBounds = getNodeBounds(nodeInfo); |
| } |
| |
| if (nodeBounds != null) { |
| Bounds visibleSelectionBounds = treeView.getVisibleArea(nodeBounds); |
| if (visibleSelectionBounds != null |
| && visibleSelectionBounds.height < nodeBounds.height) { |
| treeView.scrollAreaToVisible(nodeBounds); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public boolean mouseMove(Component component, int x, int y) { |
| boolean consumed = super.mouseMove(component, x, y); |
| |
| TreeView treeView = (TreeView) getComponent(); |
| |
| if (showHighlight && treeView.getSelectMode() != SelectMode.NONE) { |
| NodeInfo previousHighlightedNode = highlightedNode; |
| highlightedNode = getNodeInfoAt(y); |
| |
| if (highlightedNode != previousHighlightedNode) { |
| if (previousHighlightedNode != null) { |
| previousHighlightedNode.setHighlighted(false); |
| repaintNode(previousHighlightedNode); |
| } |
| |
| if (highlightedNode != null) { |
| highlightedNode.setHighlighted(true); |
| repaintNode(highlightedNode); |
| } |
| } |
| } |
| |
| return consumed; |
| } |
| |
| @Override |
| public void mouseOut(Component component) { |
| super.mouseOut(component); |
| |
| clearHighlightedNode(); |
| selectPath = null; |
| } |
| |
| @Override |
| public boolean mouseDown(Component component, Mouse.Button button, int x, int y) { |
| boolean consumed = super.mouseDown(component, button, x, y); |
| |
| if (!consumed) { |
| TreeView treeView = (TreeView) getComponent(); |
| NodeInfo nodeInfo = getNodeInfoAt(y); |
| |
| if (nodeInfo != null && !nodeInfo.isDisabled()) { |
| int nodeHeight = getNodeHeight(); |
| int baseNodeX = (nodeInfo.depth - 1) * (indent + spacing); |
| |
| int nodeX = baseNodeX + (showBranchControls ? indent + spacing : 0); |
| int nodeY = (y / (nodeHeight + VERTICAL_SPACING)) * (nodeHeight + VERTICAL_SPACING); |
| |
| int checkboxWidth = CHECKBOX.getWidth(); |
| int checkboxHeight = CHECKBOX.getHeight(); |
| |
| int checkboxX = Math.max(indent - checkboxWidth, 0) / 2; |
| int checkboxY = (nodeHeight - checkboxHeight) / 2; |
| |
| // Only proceed if the user DIDN'T click on a checkbox |
| if (!treeView.getCheckmarksEnabled() || nodeInfo.isCheckmarkDisabled() |
| || x < nodeX + checkboxX || x >= nodeX + checkboxX + checkboxWidth |
| || y < nodeY + checkboxY || y >= nodeY + checkboxY + checkboxHeight) { |
| Path path = nodeInfo.getPath(); |
| |
| // See if the user clicked on an expand/collapse control of |
| // a branch. If so, expand/collapse the branch |
| if (showBranchControls && nodeInfo instanceof BranchInfo && x >= baseNodeX |
| && x < baseNodeX + indent) { |
| BranchInfo branchInfo = (BranchInfo) nodeInfo; |
| treeView.setBranchExpanded(path, !branchInfo.isExpanded()); |
| consumed = true; |
| } |
| |
| // If we haven't consumed the event, then proceed to manage |
| // the selection state of the node |
| if (!consumed) { |
| SelectMode selectMode = treeView.getSelectMode(); |
| |
| if (button == Mouse.Button.LEFT) { |
| Modifier commandModifier = Platform.getCommandModifier(); |
| |
| if (Keyboard.isPressed(commandModifier) |
| && selectMode == SelectMode.MULTI) { |
| // Toggle the item's selection state |
| if (nodeInfo.isSelected()) { |
| treeView.removeSelectedPath(path); |
| } else { |
| treeView.addSelectedPath(path); |
| } |
| } else if (Keyboard.isPressed(commandModifier) |
| && selectMode == SelectMode.SINGLE) { |
| // Toggle the item's selection state |
| if (nodeInfo.isSelected()) { |
| treeView.clearSelection(); |
| } else { |
| treeView.setSelectedPath(path); |
| } |
| } else { |
| if (selectMode != SelectMode.NONE) { |
| if (nodeInfo.isSelected()) { |
| selectPath = path; |
| } else { |
| treeView.setSelectedPath(path); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| treeView.requestFocus(); |
| } |
| |
| return consumed; |
| } |
| |
| @Override |
| public boolean mouseUp(Component component, Mouse.Button button, int x, int y) { |
| boolean consumed = super.mouseUp(component, button, x, y); |
| |
| TreeView treeView = (TreeView) getComponent(); |
| if (selectPath != null |
| && !treeView.getFirstSelectedPath().equals(treeView.getLastSelectedPath())) { |
| treeView.setSelectedPath(selectPath); |
| selectPath = null; |
| } |
| |
| return consumed; |
| } |
| |
| @Override |
| public boolean mouseClick(Component component, Mouse.Button button, int x, int y, int count) { |
| boolean consumed = super.mouseClick(component, button, x, y, count); |
| |
| if (!consumed) { |
| TreeView treeView = (TreeView) getComponent(); |
| NodeInfo nodeInfo = getNodeInfoAt(y); |
| |
| if (nodeInfo != null && !nodeInfo.isDisabled()) { |
| int nodeHeight = getNodeHeight(); |
| int baseNodeX = (nodeInfo.depth - 1) * (indent + spacing); |
| |
| int nodeX = baseNodeX + (showBranchControls ? indent + spacing : 0); |
| int nodeY = (y / (nodeHeight + VERTICAL_SPACING)) * (nodeHeight + VERTICAL_SPACING); |
| |
| int checkboxWidth = CHECKBOX.getWidth(); |
| int checkboxHeight = CHECKBOX.getHeight(); |
| |
| int checkboxX = Math.max(indent - checkboxWidth, 0) / 2; |
| int checkboxY = (nodeHeight - checkboxHeight) / 2; |
| |
| if (treeView.getCheckmarksEnabled() && !nodeInfo.isCheckmarkDisabled() |
| && x >= nodeX + checkboxX && x < nodeX + checkboxX + checkboxWidth |
| && y >= nodeY + checkboxY && y < nodeY + checkboxY + checkboxHeight) { |
| Path path = nodeInfo.getPath(); |
| treeView.setNodeChecked(path, !nodeInfo.isChecked()); |
| } else { |
| if (selectPath != null && count == 1 && button == Mouse.Button.LEFT) { |
| TreeView.NodeEditor nodeEditor = treeView.getNodeEditor(); |
| if (nodeEditor != null) { |
| if (nodeEditor.isEditing()) { |
| nodeEditor.endEdit(true); |
| } |
| nodeEditor.beginEdit(treeView, selectPath); |
| } |
| } |
| selectPath = null; |
| } |
| } |
| } |
| |
| return consumed; |
| } |
| |
| @Override |
| public boolean mouseWheel(Component component, Mouse.ScrollType scrollType, int scrollAmount, |
| int wheelRotation, int x, int y) { |
| if (highlightedNode != null) { |
| Bounds nodeBounds = getNodeBounds(highlightedNode); |
| |
| highlightedNode.setHighlighted(false); |
| highlightedNode = null; |
| |
| if (nodeBounds != null) { |
| repaintComponent(nodeBounds.x, nodeBounds.y, nodeBounds.width, nodeBounds.height, |
| true); |
| } |
| } |
| |
| return super.mouseWheel(component, scrollType, scrollAmount, wheelRotation, x, y); |
| } |
| |
| /** |
| * Keyboard handling (arrow keys with modifiers). |
| * <ul> |
| * <li>{@link KeyCode#UP UP} Selects the previous enabled node when select mode |
| * is not {@link SelectMode#NONE}</li> |
| * <li>{@link KeyCode#DOWN DOWN} Selects the next enabled node when select mode |
| * is not {@link SelectMode#NONE}</li> |
| * <li>{@link Modifier#SHIFT SHIFT} + {@link KeyCode#UP UP} Increases the |
| * selection size by including the previous enabled node when select mode is |
| * {@link SelectMode#MULTI}</li> |
| * <li>{@link Modifier#SHIFT SHIFT} + {@link KeyCode#DOWN DOWN} Increases the |
| * selection size by including the next enabled node when select mode is |
| * {@link SelectMode#MULTI}</li> |
| * </ul> |
| */ |
| @Override |
| public boolean keyPressed(Component component, int keyCode, KeyLocation keyLocation) { |
| boolean consumed = false; |
| |
| TreeView treeView = (TreeView) getComponent(); |
| SelectMode selectMode = treeView.getSelectMode(); |
| |
| switch (keyCode) { |
| case KeyCode.UP: |
| if (selectMode != SelectMode.NONE) { |
| Path firstSelectedPath = treeView.getFirstSelectedPath(); |
| |
| int index; |
| if (firstSelectedPath != null) { |
| NodeInfo previousSelectedNode = getNodeInfoAt(firstSelectedPath); |
| index = visibleNodes.indexOf(previousSelectedNode); |
| } else { |
| // Select the last visible node |
| index = visibleNodes.getLength(); |
| } |
| |
| NodeInfo newSelectedNode = null; |
| do { |
| newSelectedNode = (--index >= 0) ? visibleNodes.get(index) : null; |
| } while (newSelectedNode != null && newSelectedNode.isDisabled()); |
| |
| if (newSelectedNode != null) { |
| if (Keyboard.isPressed(Modifier.SHIFT) |
| && treeView.getSelectMode() == SelectMode.MULTI) { |
| treeView.addSelectedPath(newSelectedNode.getPath()); |
| } else { |
| treeView.setSelectedPath(newSelectedNode.getPath()); |
| } |
| treeView.scrollAreaToVisible(getNodeBounds(newSelectedNode)); |
| } |
| consumed = true; |
| } |
| break; |
| |
| case KeyCode.DOWN: |
| if (selectMode != SelectMode.NONE) { |
| Path lastSelectedPath = treeView.getLastSelectedPath(); |
| |
| int index; |
| if (lastSelectedPath != null) { |
| NodeInfo previousSelectedNode = getNodeInfoAt(lastSelectedPath); |
| index = visibleNodes.indexOf(previousSelectedNode); |
| } else { |
| // Select the first visible node |
| index = -1; |
| } |
| |
| NodeInfo newSelectedNode = null; |
| int n = visibleNodes.getLength(); |
| do { |
| newSelectedNode = (++index <= n - 1) ? visibleNodes.get(index) : null; |
| } while (newSelectedNode != null && newSelectedNode.isDisabled()); |
| |
| if (newSelectedNode != null) { |
| if (Keyboard.isPressed(Modifier.SHIFT) |
| && treeView.getSelectMode() == SelectMode.MULTI) { |
| treeView.addSelectedPath(newSelectedNode.getPath()); |
| } else { |
| treeView.setSelectedPath(newSelectedNode.getPath()); |
| } |
| treeView.scrollAreaToVisible(getNodeBounds(newSelectedNode)); |
| } |
| consumed = true; |
| } |
| break; |
| |
| case KeyCode.LEFT: |
| if (showBranchControls) { |
| Sequence<Path> paths = treeView.getSelectedPaths(); |
| |
| if (paths != null && paths.getLength() > 0) { |
| Path path = paths.get(paths.getLength() - 1); |
| NodeInfo nodeInfo = getNodeInfoAt(path); |
| if (nodeInfo instanceof BranchInfo) { |
| BranchInfo branchInfo = (BranchInfo) nodeInfo; |
| if (branchInfo.isExpanded()) { |
| treeView.collapseBranch(branchInfo.getPath()); |
| } |
| } |
| consumed = true; |
| } |
| } |
| break; |
| |
| case KeyCode.RIGHT: |
| if (showBranchControls) { |
| Sequence<Path> paths = treeView.getSelectedPaths(); |
| |
| if (paths != null && paths.getLength() > 0) { |
| Path path = paths.get(paths.getLength() - 1); |
| NodeInfo nodeInfo = getNodeInfoAt(path); |
| if (nodeInfo instanceof BranchInfo) { |
| BranchInfo branchInfo = (BranchInfo) nodeInfo; |
| if (!branchInfo.isExpanded()) { |
| treeView.expandBranch(branchInfo.getPath()); |
| } |
| } |
| consumed = true; |
| } |
| } |
| break; |
| |
| default: |
| consumed = super.keyPressed(component, keyCode, keyLocation); |
| break; |
| } |
| |
| if (consumed) { |
| clearHighlightedNode(); |
| } |
| |
| return consumed; |
| } |
| |
| /** |
| * {@link KeyCode#SPACE SPACE} toggles check mark selection when select mode |
| * is {@link SelectMode#SINGLE}. |
| */ |
| @Override |
| public boolean keyReleased(Component component, int keyCode, KeyLocation keyLocation) { |
| boolean consumed = false; |
| |
| TreeView treeView = (TreeView) getComponent(); |
| |
| if (keyCode == KeyCode.SPACE) { |
| if (treeView.getCheckmarksEnabled() |
| && treeView.getSelectMode() == SelectMode.SINGLE) { |
| Path selectedPath = treeView.getSelectedPath(); |
| |
| if (selectedPath != null) { |
| NodeInfo nodeInfo = getNodeInfoAt(selectedPath); |
| |
| if (!nodeInfo.isCheckmarkDisabled()) { |
| treeView.setNodeChecked(selectedPath, !treeView.isNodeChecked(selectedPath)); |
| } |
| } |
| } |
| } else { |
| consumed = super.keyReleased(component, keyCode, keyLocation); |
| } |
| |
| return consumed; |
| } |
| |
| @Override |
| public boolean isFocusable() { |
| TreeView treeView = (TreeView) getComponent(); |
| return (treeView.getSelectMode() != SelectMode.NONE); |
| } |
| |
| @Override |
| public boolean isOpaque() { |
| return (backgroundColor != null && backgroundColor.getTransparency() == Transparency.OPAQUE); |
| } |
| |
| // ComponentStateListener methods |
| |
| @Override |
| public void enabledChanged(Component component) { |
| super.enabledChanged(component); |
| repaintComponent(); |
| } |
| |
| @Override |
| public void focusedChanged(Component component, Component obverseComponent) { |
| super.focusedChanged(component, obverseComponent); |
| repaintComponent(); |
| } |
| |
| // TreeView.Skin methods |
| |
| @Override |
| public Path getNodeAt(int y) { |
| Path path = null; |
| |
| NodeInfo nodeInfo = getNodeInfoAt(y); |
| |
| if (nodeInfo != null) { |
| path = nodeInfo.getPath(); |
| } |
| |
| return path; |
| } |
| |
| @Override |
| public Bounds getNodeBounds(Path path) { |
| Bounds nodeBounds = null; |
| |
| NodeInfo nodeInfo = getNodeInfoAt(path); |
| |
| if (nodeInfo != null) { |
| nodeBounds = getNodeBounds(nodeInfo); |
| } |
| |
| return nodeBounds; |
| } |
| |
| @Override |
| public int getNodeIndent(int depth) { |
| TreeView treeView = (TreeView) getComponent(); |
| |
| int nodeIndent = (depth - 1) * (indent + spacing); |
| |
| if (showBranchControls) { |
| nodeIndent += indent + spacing; |
| } |
| |
| if (treeView.getCheckmarksEnabled()) { |
| nodeIndent += Math.max(CHECKBOX.getWidth(), indent) + spacing; |
| } |
| |
| return nodeIndent; |
| } |
| |
| @Override |
| public int getRowIndex(Path path) { |
| int rowIndex = -1; |
| |
| NodeInfo nodeInfo = getNodeInfoAt(path); |
| |
| if (nodeInfo != null) { |
| rowIndex = visibleNodes.indexOf(nodeInfo); |
| } |
| |
| return rowIndex; |
| } |
| |
| // TreeViewListener methods |
| |
| @Override |
| public void treeDataChanged(TreeView treeView, List<?> previousTreeData) { |
| @SuppressWarnings("unchecked") |
| List<Object> treeData = (List<Object>) treeView.getTreeData(); |
| |
| visibleNodes.clear(); |
| |
| if (treeData == null) { |
| rootBranchInfo = null; |
| } else { |
| rootBranchInfo = new BranchInfo(treeView, null, treeData); |
| addVisibleNodes(rootBranchInfo); |
| } |
| |
| invalidateComponent(); |
| } |
| |
| @Override |
| public void nodeRendererChanged(TreeView treeView, TreeView.NodeRenderer previousNodeRenderer) { |
| invalidateComponent(); |
| } |
| |
| @Override |
| public void selectModeChanged(TreeView treeView, SelectMode previousSelectMode) { |
| // The selection has implicitly been cleared |
| clearFields(NodeInfo.SELECTED_MASK); |
| repaintComponent(); |
| } |
| |
| @Override |
| public void checkmarksEnabledChanged(TreeView treeView) { |
| // The check state of all nodes has implicitly been cleared |
| clearFields(NodeInfo.CHECK_STATE_MASK); |
| invalidateComponent(); |
| } |
| |
| @Override |
| public void showMixedCheckmarkStateChanged(TreeView treeView) { |
| if (treeView.getCheckmarksEnabled()) { |
| // The check state of all *branch* nodes may have changed, so we |
| // need to update the cached check state of all BranchNode |
| // instances in our hierarchy |
| Sequence<NodeInfo> nodes = new ArrayList<>(); |
| nodes.add(rootBranchInfo); |
| |
| while (nodes.getLength() > 0) { |
| NodeInfo nodeInfo = nodes.get(0); |
| nodes.remove(0, 1); |
| |
| // Only branch nodes can be affected by this event |
| if (nodeInfo instanceof BranchInfo) { |
| BranchInfo branchInfo = (BranchInfo) nodeInfo; |
| |
| // Update the cached entry for this branch |
| Path path = branchInfo.getPath(); |
| branchInfo.setCheckState(treeView.getNodeCheckState(path)); |
| |
| // Add the branch's children to the queue |
| if (branchInfo.children != null) { |
| for (int i = 0, n = branchInfo.children.getLength(); i < n; i++) { |
| nodes.insert(branchInfo.children.get(i), i); |
| } |
| } |
| } |
| } |
| |
| repaintComponent(); |
| } |
| } |
| |
| @Override |
| public void disabledNodeFilterChanged(TreeView treeView, Filter<?> previousDisabledNodeFilter) { |
| @SuppressWarnings("unchecked") |
| final Filter<Object> disabledNodeFilter = (Filter<Object>) treeView.getDisabledNodeFilter(); |
| |
| accept(new NodeInfoVisitor() { |
| @Override |
| public void visit(NodeInfo nodeInfo) { |
| if (nodeInfo != rootBranchInfo) { |
| nodeInfo.setDisabled(disabledNodeFilter != null |
| && disabledNodeFilter.include(nodeInfo.data)); |
| } |
| } |
| }); |
| |
| repaintComponent(); |
| } |
| |
| @Override |
| public void disabledCheckmarkFilterChanged(TreeView treeView, |
| Filter<?> previousDisabledCheckmarkFilter) { |
| @SuppressWarnings("unchecked") |
| final Filter<Object> disabledCheckmarkFilter = (Filter<Object>) treeView.getDisabledCheckmarkFilter(); |
| |
| accept(new NodeInfoVisitor() { |
| @Override |
| public void visit(NodeInfo nodeInfo) { |
| if (nodeInfo != rootBranchInfo) { |
| nodeInfo.setCheckmarkDisabled(disabledCheckmarkFilter != null |
| && disabledCheckmarkFilter.include(nodeInfo.data)); |
| } |
| } |
| }); |
| |
| repaintComponent(); |
| } |
| |
| // TreeViewBranchListener methods |
| |
| @Override |
| public void branchExpanded(TreeView treeView, Path path) { |
| BranchInfo branchInfo = (BranchInfo) getNodeInfoAt(path); |
| |
| branchInfo.setExpanded(true); |
| addVisibleNodes(branchInfo); |
| |
| repaintNode(branchInfo); |
| } |
| |
| @Override |
| public void branchCollapsed(TreeView treeView, Path path) { |
| BranchInfo branchInfo = (BranchInfo) getNodeInfoAt(path); |
| |
| branchInfo.setExpanded(false); |
| removeVisibleNodes(branchInfo, 0, -1); |
| |
| repaintNode(branchInfo); |
| } |
| |
| @Override |
| public Vote previewBranchExpandedChange(TreeView treeView, Path path) { |
| // We currently have no reason to refuse to open / close the branch |
| // although other listeners might have a reason |
| return Vote.APPROVE; |
| } |
| |
| @Override |
| public void branchExpandedChangeVetoed(TreeView treeView, Path path, Vote reason) { |
| // Nothing really to do -- our visual state doesn't change until/unless the |
| // expand/collapse really happens |
| } |
| |
| // TreeViewNodeListener methods |
| |
| @Override |
| @SuppressWarnings("unchecked") |
| public void nodeInserted(TreeView treeView, Path path, int index) { |
| BranchInfo branchInfo = (BranchInfo) getNodeInfoAt(path); |
| List<Object> branchData = (List<Object>) branchInfo.data; |
| |
| // Update our internal branch info |
| if (branchInfo.children != null) { |
| NodeInfo nodeInfo = NodeInfo.newInstance(treeView, branchInfo, branchData.get(index)); |
| branchInfo.children.insert(nodeInfo, index); |
| } |
| |
| // Add the node to the visible nodes list |
| addVisibleNode(branchInfo, index); |
| |
| // If the empty branch controls are not shown, then this event might |
| // need a repaint of the parent |
| if (!showEmptyBranchControls) { |
| repaintNode(branchInfo); |
| } |
| } |
| |
| @Override |
| public void nodesRemoved(TreeView treeView, Path path, int index, int count) { |
| BranchInfo branchInfo = (BranchInfo) getNodeInfoAt(path); |
| |
| // Remove the nodes from the visible nodes list |
| removeVisibleNodes(branchInfo, index, count); |
| |
| // Update our internal branch info |
| if (branchInfo.children != null) { |
| // Problem: if "loadChildren" was called on this branch the first time |
| // by "removeVisibleNodes" above, then the "children" will actually be |
| // correct here (i.e., already removed), so this is unnecessary. |
| int len = branchInfo.children.getLength(); |
| if (index < len && index + count <= len) { |
| branchInfo.children.remove(index, count); |
| } |
| } |
| |
| // If the empty branch controls are not shown, then this event might |
| // need a repaint of the parent |
| if (!showEmptyBranchControls) { |
| repaintNode(branchInfo); |
| } |
| } |
| |
| @Override |
| @SuppressWarnings("unchecked") |
| public void nodeUpdated(TreeView treeView, Path path, int index) { |
| BranchInfo branchInfo = (BranchInfo) getNodeInfoAt(path); |
| List<Object> branchData = (List<Object>) branchInfo.data; |
| |
| branchInfo.loadChildren(); |
| NodeInfo nodeInfo = branchInfo.children.get(index); |
| |
| Object previousNodeData = nodeInfo.data; |
| Object nodeData = branchData.get(index); |
| |
| if (previousNodeData != nodeData) { |
| // Remove the old node from the visible nodes list |
| removeVisibleNodes(branchInfo, index, 1); |
| |
| // Update our internal branch info |
| nodeInfo = NodeInfo.newInstance(treeView, branchInfo, nodeData); |
| branchInfo.children.update(index, nodeInfo); |
| |
| // Add the new node to the visible nodes list |
| addVisibleNode(branchInfo, index); |
| } else { |
| // This update might affect the node's disabled state |
| Filter<Object> disabledNodeFilter = (Filter<Object>) treeView.getDisabledNodeFilter(); |
| nodeInfo.setDisabled(disabledNodeFilter != null && disabledNodeFilter.include(nodeData)); |
| |
| if (visibleNodes.indexOf(nodeInfo) >= 0) { |
| // The updated node data might affect our preferred width |
| invalidateComponent(); |
| } |
| } |
| } |
| |
| @Override |
| public void nodesCleared(TreeView treeView, Path path) { |
| BranchInfo branchInfo = (BranchInfo) getNodeInfoAt(path); |
| |
| // Remove the node from the visible nodes list |
| removeVisibleNodes(branchInfo, 0, -1); |
| |
| // Update our internal branch info |
| if (branchInfo.children != null) { |
| branchInfo.children.clear(); |
| } |
| } |
| |
| @Override |
| public void nodesSorted(TreeView treeView, Path path) { |
| BranchInfo branchInfo = (BranchInfo) getNodeInfoAt(path); |
| |
| // Remove the child nodes from the visible nodes list |
| removeVisibleNodes(branchInfo, 0, -1); |
| |
| // Re-load the branch's children to get the correct sort order |
| branchInfo.children = null; |
| branchInfo.loadChildren(); |
| |
| // Add the child nodes back to the visible nodes list |
| addVisibleNodes(branchInfo); |
| } |
| |
| // TreeViewNodeStateListener methods |
| |
| @Override |
| public void nodeCheckStateChanged(TreeView treeView, Path path, |
| TreeView.NodeCheckState previousCheckState) { |
| NodeInfo nodeInfo = getNodeInfoAt(path); |
| |
| nodeInfo.setCheckState(treeView.getNodeCheckState(path)); |
| |
| repaintNode(nodeInfo); |
| } |
| |
| // TreeViewSelectionListener methods |
| |
| @Override |
| public void selectedPathAdded(TreeView treeView, Path path) { |
| // Update the node info |
| NodeInfo nodeInfo = getNodeInfoAt(path); |
| nodeInfo.setSelected(true); |
| |
| if (treeView.isValid()) { |
| Bounds nodeBounds = getNodeBounds(nodeInfo); |
| |
| if (nodeBounds != null) { |
| // Ensure that the selection is visible |
| Bounds visibleSelectionBounds = treeView.getVisibleArea(nodeBounds); |
| if (visibleSelectionBounds.height < nodeBounds.height) { |
| treeView.scrollAreaToVisible(nodeBounds); |
| } |
| } |
| } else { |
| validateSelection = true; |
| } |
| |
| repaintNode(nodeInfo); |
| } |
| |
| @Override |
| public void selectedPathRemoved(TreeView treeView, Path path) { |
| NodeInfo nodeInfo = getNodeInfoAt(path); |
| nodeInfo.setSelected(false); |
| repaintNode(nodeInfo); |
| } |
| |
| @Override |
| public void selectedPathsChanged(TreeView treeView, Sequence<Path> previousSelectedPaths) { |
| if (previousSelectedPaths != null && previousSelectedPaths != treeView.getSelectedPaths()) { |
| // Ensure that the selection is visible |
| if (treeView.isValid()) { |
| scrollSelectionToVisible(); |
| } else { |
| validateSelection = true; |
| } |
| |
| // Un-select the previous selected paths |
| for (int i = 0, n = previousSelectedPaths.getLength(); i < n; i++) { |
| NodeInfo previousSelectedNode = getNodeInfoAt(previousSelectedPaths.get(i)); |
| previousSelectedNode.setSelected(false); |
| repaintNode(previousSelectedNode); |
| } |
| |
| Sequence<Path> selectedPaths = treeView.getSelectedPaths(); |
| |
| // Select the current selected paths |
| for (int i = 0, n = selectedPaths.getLength(); i < n; i++) { |
| NodeInfo selectedNode = getNodeInfoAt(selectedPaths.get(i)); |
| selectedNode.setSelected(true); |
| repaintNode(selectedNode); |
| } |
| } |
| } |
| |
| } |
