| /* |
| * Copyright 2000-2014 JetBrains s.r.o. |
| * |
| * 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.intellij.openapi.options.newEditor; |
| |
| import com.intellij.icons.AllIcons; |
| import com.intellij.ide.util.treeView.NodeDescriptor; |
| import com.intellij.openapi.Disposable; |
| import com.intellij.openapi.options.*; |
| import com.intellij.openapi.options.ex.ConfigurableWrapper; |
| import com.intellij.openapi.options.ex.SortedConfigurableGroup; |
| import com.intellij.openapi.project.Project; |
| import com.intellij.openapi.util.ActionCallback; |
| import com.intellij.openapi.util.Disposer; |
| import com.intellij.ui.*; |
| import com.intellij.ui.treeStructure.CachingSimpleNode; |
| import com.intellij.ui.treeStructure.SimpleNode; |
| import com.intellij.ui.treeStructure.SimpleTree; |
| import com.intellij.ui.treeStructure.SimpleTreeStructure; |
| import com.intellij.ui.treeStructure.filtered.FilteringTreeBuilder; |
| import com.intellij.ui.treeStructure.filtered.FilteringTreeStructure; |
| import com.intellij.util.ArrayUtil; |
| import com.intellij.util.ui.ButtonlessScrollBarUI; |
| import com.intellij.util.ui.GraphicsUtil; |
| import com.intellij.util.ui.UIUtil; |
| import com.intellij.util.ui.tree.TreeUtil; |
| import com.intellij.util.ui.tree.WideSelectionTreeUI; |
| import com.intellij.util.ui.update.MergingUpdateQueue; |
| import com.intellij.util.ui.update.Update; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| |
| import javax.swing.*; |
| import javax.swing.event.TreeExpansionEvent; |
| import javax.swing.event.TreeExpansionListener; |
| import javax.swing.event.TreeSelectionEvent; |
| import javax.swing.event.TreeSelectionListener; |
| import javax.swing.plaf.TreeUI; |
| import javax.swing.tree.DefaultMutableTreeNode; |
| import javax.swing.tree.TreeCellRenderer; |
| import javax.swing.tree.TreePath; |
| import javax.swing.tree.TreeSelectionModel; |
| import java.awt.*; |
| import java.awt.event.ComponentAdapter; |
| import java.awt.event.ComponentEvent; |
| import java.awt.event.KeyEvent; |
| import java.awt.event.MouseEvent; |
| import java.util.*; |
| import java.util.List; |
| |
| /** |
| * @author Sergey.Malenkov |
| */ |
| final class SettingsTreeView extends JComponent implements Disposable, OptionsEditorColleague { |
| private static final String NODE_ICON = "settings.tree.view.icon"; |
| private static final Color NORMAL_NODE = new JBColor(Gray._60, Gray._140); |
| private static final Color WRONG_CONTENT = JBColor.RED; |
| private static final Color MODIFIED_CONTENT = JBColor.BLUE; |
| |
| final SimpleTree myTree; |
| final FilteringTreeBuilder myBuilder; |
| |
| private final SettingsFilter myFilter; |
| private final MyRoot myRoot; |
| private final JScrollPane myScroller; |
| private JLabel mySeparator; |
| private final IdentityHashMap<Configurable, MyNode> myConfigurableToNodeMap = new IdentityHashMap<Configurable, MyNode>(); |
| private final IdentityHashMap<UnnamedConfigurable, ConfigurableWrapper> myConfigurableToWrapperMap |
| = new IdentityHashMap<UnnamedConfigurable, ConfigurableWrapper>(); |
| private final MergingUpdateQueue myQueue = new MergingUpdateQueue("SettingsTreeView", 150, false, this, this, this) |
| .setRestartTimerOnAdd(true); |
| |
| private Configurable myQueuedConfigurable; |
| |
| SettingsTreeView(SettingsFilter filter, ConfigurableGroup... groups) { |
| myFilter = filter; |
| myRoot = new MyRoot(groups); |
| myTree = new MyTree(); |
| myTree.putClientProperty(WideSelectionTreeUI.TREE_TABLE_TREE_KEY, Boolean.TRUE); |
| myTree.setBackground(UIUtil.getSidePanelColor()); |
| myTree.getInputMap().clear(); |
| TreeUtil.installActions(myTree); |
| |
| myTree.setOpaque(true); |
| myTree.setBorder(BorderFactory.createEmptyBorder(0, 1, 0, 0)); |
| |
| myTree.setRowHeight(-1); |
| myTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION); |
| |
| myTree.setCellRenderer(new MyRenderer()); |
| myTree.setRootVisible(false); |
| myTree.setShowsRootHandles(false); |
| myTree.setExpandableItemsEnabled(false); |
| |
| myScroller = ScrollPaneFactory.createScrollPane(myTree, true); |
| myScroller.getVerticalScrollBar().setUI(ButtonlessScrollBarUI.createTransparent()); |
| myScroller.setBackground(UIUtil.getSidePanelColor()); |
| myScroller.getViewport().setBackground(UIUtil.getSidePanelColor()); |
| myScroller.getVerticalScrollBar().setBackground(UIUtil.getSidePanelColor()); |
| add(myScroller); |
| |
| myTree.addComponentListener(new ComponentAdapter() { |
| @Override |
| public void componentResized(ComponentEvent e) { |
| myBuilder.revalidateTree(); |
| } |
| |
| @Override |
| public void componentMoved(ComponentEvent e) { |
| myBuilder.revalidateTree(); |
| } |
| |
| @Override |
| public void componentShown(ComponentEvent e) { |
| myBuilder.revalidateTree(); |
| } |
| }); |
| |
| myTree.getSelectionModel().addTreeSelectionListener(new TreeSelectionListener() { |
| public void valueChanged(TreeSelectionEvent event) { |
| MyNode node = extractNode(event.getNewLeadSelectionPath()); |
| select(node == null ? null : node.myConfigurable); |
| } |
| }); |
| |
| myBuilder = new MyBuilder(new SimpleTreeStructure.Impl(myRoot)); |
| myBuilder.setFilteringMerge(300, null); |
| Disposer.register(this, myBuilder); |
| } |
| |
| @NotNull |
| String[] getPathNames(Configurable configurable) { |
| ArrayDeque<String> path = new ArrayDeque<String>(); |
| MyNode node = findNode(configurable); |
| while (node != null) { |
| path.push(node.myDisplayName); |
| SimpleNode parent = node.getParent(); |
| node = parent instanceof MyNode |
| ? (MyNode)parent |
| : null; |
| } |
| return ArrayUtil.toStringArray(path); |
| } |
| |
| static Configurable getConfigurable(SimpleNode node) { |
| return node instanceof MyNode |
| ? ((MyNode)node).myConfigurable |
| : null; |
| } |
| |
| @Nullable |
| MyNode findNode(Configurable configurable) { |
| ConfigurableWrapper wrapper = myConfigurableToWrapperMap.get(configurable); |
| return myConfigurableToNodeMap.get(wrapper != null ? wrapper : configurable); |
| } |
| |
| @Nullable |
| SearchableConfigurable findConfigurableById(@NotNull String id) { |
| for (Configurable configurable : myConfigurableToNodeMap.keySet()) { |
| if (configurable instanceof SearchableConfigurable) { |
| SearchableConfigurable searchable = (SearchableConfigurable)configurable; |
| if (id.equals(searchable.getId())) { |
| return searchable; |
| } |
| } |
| } |
| return null; |
| } |
| |
| @Nullable |
| <T extends UnnamedConfigurable> T findConfigurable(@NotNull Class<T> type) { |
| for (UnnamedConfigurable configurable : myConfigurableToNodeMap.keySet()) { |
| if (configurable instanceof ConfigurableWrapper) { |
| ConfigurableWrapper wrapper = (ConfigurableWrapper)configurable; |
| configurable = wrapper.getConfigurable(); |
| myConfigurableToWrapperMap.put(configurable, wrapper); |
| } |
| if (type.isInstance(configurable)) { |
| return type.cast(configurable); |
| } |
| } |
| return null; |
| } |
| |
| @Nullable |
| Project findConfigurableProject(@Nullable Configurable configurable) { |
| if (configurable instanceof ConfigurableWrapper) { |
| ConfigurableWrapper wrapper = (ConfigurableWrapper)configurable; |
| return wrapper.getExtensionPoint().getProject(); |
| } |
| return findConfigurableProject(findNode(configurable)); |
| } |
| |
| @Nullable |
| private static Project findConfigurableProject(@Nullable MyNode node) { |
| if (node != null) { |
| Configurable configurable = node.myConfigurable; |
| if (configurable instanceof ConfigurableWrapper) { |
| ConfigurableWrapper wrapper = (ConfigurableWrapper)configurable; |
| return wrapper.getExtensionPoint().getProject(); |
| } |
| SimpleNode parent = node.getParent(); |
| if (parent instanceof MyNode) { |
| return findConfigurableProject((MyNode)parent); |
| } |
| } |
| return null; |
| } |
| |
| @Nullable |
| private String findGroupNameAt(int x, int y) { |
| TreePath path = myTree.getClosestPathForLocation(x - myTree.getX(), y - myTree.getY()); |
| while (path != null) { |
| MyNode node = extractNode(path); |
| if (node == null) { |
| return null; |
| } |
| if (myRoot == node.getParent()) { |
| return node.myDisplayName; |
| } |
| path = path.getParentPath(); |
| } |
| return null; |
| } |
| |
| @Nullable |
| private static MyNode extractNode(@Nullable Object object) { |
| if (object instanceof TreePath) { |
| TreePath path = (TreePath)object; |
| object = path.getLastPathComponent(); |
| } |
| if (object instanceof DefaultMutableTreeNode) { |
| DefaultMutableTreeNode node = (DefaultMutableTreeNode)object; |
| object = node.getUserObject(); |
| } |
| if (object instanceof FilteringTreeStructure.FilteringNode) { |
| FilteringTreeStructure.FilteringNode node = (FilteringTreeStructure.FilteringNode)object; |
| object = node.getDelegate(); |
| } |
| return object instanceof MyNode |
| ? (MyNode)object |
| : null; |
| } |
| |
| @Override |
| public void doLayout() { |
| myScroller.setBounds(0, 0, getWidth(), getHeight()); |
| } |
| |
| @Override |
| public void paint(Graphics g) { |
| super.paint(g); |
| |
| if (0 == myTree.getY()) { |
| return; // separator is not needed without scrolling |
| } |
| if (mySeparator == null) { |
| mySeparator = new JLabel(); |
| mySeparator.setForeground(NORMAL_NODE); |
| mySeparator.setFont(UIUtil.getLabelFont()); |
| mySeparator.setFont(getFont().deriveFont(Font.BOLD)); |
| } |
| int height = mySeparator.getPreferredSize().height; |
| String group = findGroupNameAt(0, height); |
| if (group != null && group.equals(findGroupNameAt(0, 0))) { |
| mySeparator.setBorder(BorderFactory.createEmptyBorder(0, 18, 0, 0)); |
| mySeparator.setText(group); |
| |
| Rectangle bounds = myScroller.getViewport().getBounds(); |
| if (bounds.height > height) { |
| bounds.height = height; |
| } |
| g.setColor(myTree.getBackground()); |
| g.fillRect(bounds.x, bounds.y, bounds.width, bounds.height); |
| if (g instanceof Graphics2D) { |
| int h = 4; // gradient height |
| int y = bounds.y + bounds.height; |
| ((Graphics2D)g).setPaint(UIUtil.getGradientPaint( |
| 0, y, g.getColor(), |
| 0, y + h, ColorUtil.toAlpha(g.getColor(), 0))); |
| g.fillRect(bounds.x, y, bounds.width, h); |
| } |
| mySeparator.setSize(bounds.width - 1, bounds.height); |
| mySeparator.paint(g.create(bounds.x + 1, bounds.y, bounds.width - 1, bounds.height)); |
| } |
| } |
| |
| void selectFirst() { |
| for (ConfigurableGroup eachGroup : myRoot.myGroups) { |
| Configurable[] kids = eachGroup.getConfigurables(); |
| if (kids.length > 0) { |
| select(kids[0]); |
| return; |
| } |
| } |
| } |
| |
| ActionCallback select(@Nullable final Configurable configurable) { |
| if (myBuilder.isSelectionBeingAdjusted()) { |
| return new ActionCallback.Rejected(); |
| } |
| final ActionCallback callback = new ActionCallback(); |
| myQueuedConfigurable = configurable; |
| myQueue.queue(new Update(this) { |
| public void run() { |
| if (configurable == myQueuedConfigurable) { |
| if (configurable == null) { |
| fireSelected(null, callback); |
| } |
| else { |
| myBuilder.getReady(this).doWhenDone(new Runnable() { |
| @Override |
| public void run() { |
| if (configurable != myQueuedConfigurable) return; |
| |
| MyNode editorNode = findNode(configurable); |
| FilteringTreeStructure.FilteringNode editorUiNode = myBuilder.getVisibleNodeFor(editorNode); |
| if (editorUiNode == null) return; |
| |
| if (!myBuilder.getSelectedElements().contains(editorUiNode)) { |
| myBuilder.select(editorUiNode, new Runnable() { |
| public void run() { |
| fireSelected(configurable, callback); |
| } |
| }); |
| } |
| else { |
| myBuilder.scrollSelectionToVisible(new Runnable() { |
| public void run() { |
| fireSelected(configurable, callback); |
| } |
| }, false); |
| } |
| } |
| }); |
| } |
| } |
| } |
| |
| @Override |
| public void setRejected() { |
| super.setRejected(); |
| callback.setRejected(); |
| } |
| }); |
| return callback; |
| } |
| |
| private void fireSelected(Configurable configurable, ActionCallback callback) { |
| ConfigurableWrapper wrapper = myConfigurableToWrapperMap.get(configurable); |
| myFilter.myContext.fireSelected(wrapper != null ? wrapper : configurable, this).doWhenProcessed(callback.createSetDoneRunnable()); |
| } |
| |
| @Override |
| public void dispose() { |
| myQueuedConfigurable = null; |
| } |
| |
| @Override |
| public ActionCallback onSelected(@Nullable Configurable configurable, Configurable oldConfigurable) { |
| return select(configurable); |
| } |
| |
| @Override |
| public ActionCallback onModifiedAdded(Configurable configurable) { |
| myTree.repaint(); |
| return new ActionCallback.Done(); |
| } |
| |
| @Override |
| public ActionCallback onModifiedRemoved(Configurable configurable) { |
| myTree.repaint(); |
| return new ActionCallback.Done(); |
| } |
| |
| @Override |
| public ActionCallback onErrorsChanged() { |
| return new ActionCallback.Done(); |
| } |
| |
| private final class MyRoot extends CachingSimpleNode { |
| private final ConfigurableGroup[] myGroups; |
| |
| private MyRoot(ConfigurableGroup[] groups) { |
| super(null); |
| myGroups = groups; |
| } |
| |
| @Override |
| protected SimpleNode[] buildChildren() { |
| if (myGroups == null || myGroups.length == 0) { |
| return NO_CHILDREN; |
| } |
| ArrayList<MyNode> list = new ArrayList<MyNode>(); |
| for (ConfigurableGroup group : myGroups) { |
| for (Configurable configurable : group.getConfigurables()) { |
| list.add(new MyNode(this, configurable, 0)); |
| } |
| } |
| return list.toArray(new SimpleNode[list.size()]); |
| } |
| } |
| |
| private final class MyNode extends CachingSimpleNode { |
| private final Configurable.Composite myComposite; |
| private final Configurable myConfigurable; |
| private final String myDisplayName; |
| private final int myLevel; |
| |
| private MyNode(CachingSimpleNode parent, Configurable configurable, int level) { |
| super(parent); |
| myComposite = configurable instanceof Configurable.Composite ? (Configurable.Composite)configurable : null; |
| myConfigurable = configurable; |
| String name = configurable.getDisplayName(); |
| myDisplayName = name != null ? name.replace("\n", " ") : "{ " + configurable.getClass().getSimpleName() + " }"; |
| myLevel = level; |
| } |
| |
| @Override |
| protected SimpleNode[] buildChildren() { |
| if (myConfigurable != null) { |
| myConfigurableToNodeMap.put(myConfigurable, this); |
| } |
| if (myComposite == null) { |
| return NO_CHILDREN; |
| } |
| Configurable[] configurables = myComposite.getConfigurables(); |
| if (configurables == null || configurables.length == 0) { |
| return NO_CHILDREN; |
| } |
| SimpleNode[] result = new SimpleNode[configurables.length]; |
| for (int i = 0; i < configurables.length; i++) { |
| result[i] = new MyNode(this, configurables[i], myLevel + 1); |
| if (myConfigurable != null) { |
| myFilter.myContext.registerKid(myConfigurable, configurables[i]); |
| } |
| } |
| return result; |
| } |
| |
| @Override |
| public boolean isAlwaysLeaf() { |
| return myComposite == null; |
| } |
| } |
| |
| private final class MyRenderer extends JPanel implements TreeCellRenderer { |
| private final JLabel myTextLabel = new ErrorLabel(); |
| private final JLabel myNodeIcon = new JLabel(" ", SwingConstants.RIGHT); |
| private final JLabel myProjectIcon = new JLabel(" ", SwingConstants.LEFT); |
| |
| public MyRenderer() { |
| super(new BorderLayout()); |
| myNodeIcon.setName(NODE_ICON); |
| add(BorderLayout.CENTER, myTextLabel); |
| add(BorderLayout.WEST, myNodeIcon); |
| add(BorderLayout.EAST, myProjectIcon); |
| } |
| |
| public Component getTreeCellRendererComponent(JTree tree, |
| Object value, |
| boolean selected, |
| boolean expanded, |
| boolean leaf, |
| int row, |
| boolean focused) { |
| myTextLabel.setFont(UIUtil.getLabelFont()); |
| setPreferredSize(null); |
| |
| MyNode node = extractNode(value); |
| if (node == null) { |
| myTextLabel.setText(value.toString()); |
| } |
| else { |
| myTextLabel.setText(node.myDisplayName); |
| // show groups in bold |
| if (myRoot == node.getParent()) { |
| myTextLabel.setFont(myTextLabel.getFont().deriveFont(Font.BOLD)); |
| } |
| if (tree.isVisible()) { |
| int indent = node.myLevel * (UIUtil.getTreeLeftChildIndent() + UIUtil.getTreeRightChildIndent()); |
| Insets treeInsets = tree.getInsets(); |
| if (treeInsets != null) { |
| indent += treeInsets.left + treeInsets.right; |
| } |
| int visibleWidth = tree.getVisibleRect().width; |
| if (visibleWidth > indent) { |
| Dimension size = getPreferredSize(); |
| size.width = visibleWidth - indent; |
| //setPreferredSize(size); |
| } |
| } |
| } |
| // update font color for modified configurables |
| myTextLabel.setForeground(selected ? UIUtil.getTreeSelectionForeground() : NORMAL_NODE); |
| if (!selected && node != null) { |
| Configurable configurable = node.myConfigurable; |
| if (configurable != null) { |
| if (myFilter.myContext.getErrors().containsKey(configurable)) { |
| myTextLabel.setForeground(WRONG_CONTENT); |
| } |
| else if (myFilter.myContext.getModified().contains(configurable)) { |
| myTextLabel.setForeground(MODIFIED_CONTENT); |
| } |
| } |
| } |
| // configure project icon |
| Project project = null; |
| if (node != null) { |
| SimpleNode parent = node.getParent(); |
| if (parent instanceof MyNode) { |
| if (myRoot == parent.getParent()) { |
| project = findConfigurableProject(node); // show icon for top-level nodes |
| if (node.myConfigurable instanceof SortedConfigurableGroup) { // special case for custom subgroups (build.tools) |
| Configurable[] configurables = ((SortedConfigurableGroup)node.myConfigurable).getConfigurables(); |
| if (configurables != null) { // assume that all configurables have the same project |
| project = findConfigurableProject(configurables[0]); |
| } |
| } |
| } |
| else if (((MyNode)parent).myConfigurable instanceof SortedConfigurableGroup) { |
| if (((MyNode)node.getParent()).myConfigurable instanceof SortedConfigurableGroup) { |
| project = findConfigurableProject(node); // special case for custom subgroups |
| } |
| } |
| } |
| } |
| if (project != null) { |
| myProjectIcon.setIcon(selected |
| ? AllIcons.General.ProjectConfigurableSelected |
| : AllIcons.General.ProjectConfigurable); |
| myProjectIcon.setToolTipText(OptionsBundle.message(project.isDefault() |
| ? "configurable.default.project.tooltip" |
| : "configurable.current.project.tooltip")); |
| myProjectIcon.setVisible(true); |
| } |
| else { |
| myProjectIcon.setVisible(false); |
| } |
| // configure node icon |
| Icon nodeIcon = null; |
| if (node != null) { |
| if (0 == node.getChildCount()) { |
| nodeIcon = myTree.getEmptyHandle(); |
| } |
| else if (value instanceof DefaultMutableTreeNode) { |
| DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode)value; |
| nodeIcon = myTree.isExpanded(new TreePath(treeNode.getPath())) |
| ? myTree.getExpandedHandle() |
| : myTree.getCollapsedHandle(); |
| } |
| } |
| myNodeIcon.setIcon(nodeIcon); |
| return this; |
| } |
| } |
| |
| private final class MyTree extends SimpleTree { |
| @Override |
| public String getToolTipText(MouseEvent event) { |
| if (event != null) { |
| Component component = getDeepestRendererComponentAt(event.getX(), event.getY()); |
| if (component instanceof JLabel) { |
| JLabel label = (JLabel)component; |
| if (label.getIcon() != null) { |
| String text = label.getToolTipText(); |
| if (text != null) { |
| return text; |
| } |
| } |
| } |
| } |
| return super.getToolTipText(event); |
| } |
| |
| @Override |
| protected boolean paintNodes() { |
| return false; |
| } |
| |
| @Override |
| protected boolean highlightSingleNode() { |
| return false; |
| } |
| |
| @Override |
| public void setUI(TreeUI ui) { |
| super.setUI(ui instanceof MyTreeUi ? ui : new MyTreeUi()); |
| } |
| |
| @Override |
| protected boolean isCustomUI() { |
| return true; |
| } |
| |
| @Override |
| protected void configureUiHelper(TreeUIHelper helper) { |
| } |
| |
| @Override |
| public boolean getScrollableTracksViewportWidth() { |
| return true; |
| } |
| |
| |
| @Override |
| public void processKeyEvent(KeyEvent e) { |
| TreePath path = myTree.getSelectionPath(); |
| if (path != null) { |
| if (e.getKeyCode() == KeyEvent.VK_LEFT) { |
| if (isExpanded(path)) { |
| collapsePath(path); |
| return; |
| } |
| } |
| else if (e.getKeyCode() == KeyEvent.VK_RIGHT) { |
| if (isCollapsed(path)) { |
| expandPath(path); |
| return; |
| } |
| } |
| } |
| super.processKeyEvent(e); |
| } |
| |
| @Override |
| protected void processMouseEvent(MouseEvent event) { |
| MyTreeUi ui = (MyTreeUi)myTree.getUI(); |
| if (!ui.processMouseEvent(event)) { |
| super.processMouseEvent(event); |
| } |
| } |
| } |
| |
| private static final class MyTreeUi extends WideSelectionTreeUI { |
| boolean processMouseEvent(MouseEvent event) { |
| if (super.tree instanceof SimpleTree) { |
| SimpleTree tree = (SimpleTree)super.tree; |
| |
| boolean toggleNow = MouseEvent.MOUSE_RELEASED == event.getID() |
| && UIUtil.isActionClick(event, MouseEvent.MOUSE_RELEASED) |
| && !isToggleEvent(event); |
| |
| if (toggleNow || MouseEvent.MOUSE_PRESSED == event.getID()) { |
| Component component = tree.getDeepestRendererComponentAt(event.getX(), event.getY()); |
| if (component != null && NODE_ICON.equals(component.getName())) { |
| if (toggleNow) { |
| toggleExpandState(tree.getPathForLocation(event.getX(), event.getY())); |
| } |
| event.consume(); |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| @Override |
| protected boolean shouldPaintExpandControl(TreePath path, |
| int row, |
| boolean isExpanded, |
| boolean hasBeenExpanded, |
| boolean isLeaf) { |
| return false; |
| } |
| |
| @Override |
| protected void paintHorizontalPartOfLeg(Graphics g, |
| Rectangle clipBounds, |
| Insets insets, |
| Rectangle bounds, |
| TreePath path, |
| int row, |
| boolean isExpanded, |
| boolean hasBeenExpanded, |
| boolean isLeaf) { |
| |
| } |
| |
| @Override |
| protected void paintVerticalPartOfLeg(Graphics g, Rectangle clipBounds, Insets insets, TreePath path) { |
| } |
| |
| @Override |
| public void paint(Graphics g, JComponent c) { |
| GraphicsUtil.setupAntialiasing(g); |
| super.paint(g, c); |
| } |
| |
| @Override |
| protected void paintRow(Graphics g, |
| Rectangle clipBounds, |
| Insets insets, |
| Rectangle bounds, |
| TreePath path, |
| int row, |
| boolean isExpanded, |
| boolean hasBeenExpanded, |
| boolean isLeaf) { |
| if (tree != null) { |
| int width = tree.getWidth(); |
| Container parent = tree.getParent(); |
| if (parent instanceof JViewport) { |
| JViewport viewport = (JViewport)parent; |
| width = viewport.getWidth() - viewport.getViewPosition().x; |
| } |
| width -= bounds.x; |
| if (bounds.width < width) { |
| bounds.width = width; |
| } |
| } |
| super.paintRow(g, clipBounds, insets, bounds, path, row, isExpanded, hasBeenExpanded, isLeaf); |
| } |
| } |
| |
| private final class MyBuilder extends FilteringTreeBuilder { |
| |
| List<Object> myToExpandOnResetFilter; |
| boolean myRefilteringNow; |
| boolean myWasHoldingFilter; |
| |
| public MyBuilder(SimpleTreeStructure structure) { |
| super(myTree, myFilter, structure, null); |
| myTree.addTreeExpansionListener(new TreeExpansionListener() { |
| public void treeExpanded(TreeExpansionEvent event) { |
| invalidateExpansions(); |
| } |
| |
| public void treeCollapsed(TreeExpansionEvent event) { |
| invalidateExpansions(); |
| } |
| }); |
| } |
| |
| private void invalidateExpansions() { |
| if (!myRefilteringNow) { |
| myToExpandOnResetFilter = null; |
| } |
| } |
| |
| @Override |
| protected boolean isSelectable(Object object) { |
| return object instanceof MyNode; |
| } |
| |
| @Override |
| public boolean isAutoExpandNode(NodeDescriptor nodeDescriptor) { |
| return myFilter.myContext.isHoldingFilter(); |
| } |
| |
| @Override |
| public boolean isToEnsureSelectionOnFocusGained() { |
| return false; |
| } |
| |
| @Override |
| protected ActionCallback refilterNow(Object preferredSelection, boolean adjustSelection) { |
| final List<Object> toRestore = new ArrayList<Object>(); |
| if (myFilter.myContext.isHoldingFilter() && !myWasHoldingFilter && myToExpandOnResetFilter == null) { |
| myToExpandOnResetFilter = myBuilder.getUi().getExpandedElements(); |
| } |
| else if (!myFilter.myContext.isHoldingFilter() && myWasHoldingFilter && myToExpandOnResetFilter != null) { |
| toRestore.addAll(myToExpandOnResetFilter); |
| myToExpandOnResetFilter = null; |
| } |
| |
| myWasHoldingFilter = myFilter.myContext.isHoldingFilter(); |
| |
| ActionCallback result = super.refilterNow(preferredSelection, adjustSelection); |
| myRefilteringNow = true; |
| return result.doWhenDone(new Runnable() { |
| public void run() { |
| myRefilteringNow = false; |
| if (!myFilter.myContext.isHoldingFilter() && getSelectedElements().isEmpty()) { |
| restoreExpandedState(toRestore); |
| } |
| } |
| }); |
| } |
| |
| private void restoreExpandedState(List<Object> toRestore) { |
| TreePath[] selected = myTree.getSelectionPaths(); |
| if (selected == null) { |
| selected = new TreePath[0]; |
| } |
| |
| List<TreePath> toCollapse = new ArrayList<TreePath>(); |
| |
| for (int eachRow = 0; eachRow < myTree.getRowCount(); eachRow++) { |
| if (!myTree.isExpanded(eachRow)) continue; |
| |
| TreePath eachVisiblePath = myTree.getPathForRow(eachRow); |
| if (eachVisiblePath == null) continue; |
| |
| Object eachElement = myBuilder.getElementFor(eachVisiblePath.getLastPathComponent()); |
| if (toRestore.contains(eachElement)) continue; |
| |
| |
| for (TreePath eachSelected : selected) { |
| if (!eachVisiblePath.isDescendant(eachSelected)) { |
| toCollapse.add(eachVisiblePath); |
| } |
| } |
| } |
| |
| for (TreePath each : toCollapse) { |
| myTree.collapsePath(each); |
| } |
| } |
| } |
| } |
