platform/platform-api/src/com/intellij/ui/CheckboxTreeHelper.java

   1 /*
   2  * Copyright 2000-2014 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.ui;
  17
  18 import com.intellij.ui.speedSearch.SpeedSearchSupply;
  19 import com.intellij.ui.treeStructure.Tree;
  20 import com.intellij.util.EventDispatcher;
  21 import com.intellij.util.ui.tree.TreeUtil;
  22 import org.jetbrains.annotations.NotNull;
  23 import org.jetbrains.annotations.Nullable;
  24
  25 import javax.swing.*;
  26 import javax.swing.tree.TreeModel;
  27 import javax.swing.tree.TreeNode;
  28 import javax.swing.tree.TreePath;
  29 import java.awt.*;
  30 import java.awt.event.KeyAdapter;
  31 import java.awt.event.KeyEvent;
  32 import java.awt.event.MouseEvent;
  33 import java.lang.reflect.Array;
  34 import java.util.ArrayList;
  35 import java.util.Enumeration;
  36
  37 /**
  38  * @author nik
  39  */
  40 class CheckboxTreeHelper {
  41   static final CheckboxTreeBase.CheckPolicy DEFAULT_POLICY = new CheckboxTreeBase.CheckPolicy(true, true, false, true);
  42   private final CheckboxTreeBase.CheckPolicy myCheckPolicy;
  43   private final EventDispatcher<CheckboxTreeListener> myEventDispatcher;
  44
  45   CheckboxTreeHelper(CheckboxTreeBase.CheckPolicy checkPolicy, EventDispatcher<CheckboxTreeListener> dispatcher) {
  46     myCheckPolicy = checkPolicy;
  47     myEventDispatcher = dispatcher;
  48   }
  49
  50   public void initTree(@NotNull final Tree tree, JComponent mainComponent, CheckboxTreeBase.CheckboxTreeCellRendererBase cellRenderer) {
  51     tree.setCellRenderer(cellRenderer);
  52     tree.setRootVisible(false);
  53     tree.setShowsRootHandles(true);
  54     tree.setLineStyleAngled();
  55     TreeUtil.installActions(tree);
  56
  57     setupKeyListener(tree, mainComponent);
  58     setupMouseListener(tree, mainComponent, cellRenderer);
  59   }
  60
  61   public void setNodeState(Tree tree, CheckedTreeNode node, boolean checked) {
  62     changeNodeState(node, checked);
  63     adjustParentsAndChildren(node, checked);
  64     tree.repaint();
  65
  66     // notify model listeners about model change
  67     final TreeModel model = tree.getModel();
  68     model.valueForPathChanged(new TreePath(node.getPath()), node.getUserObject());
  69   }
  70
  71   private void toggleNode(Tree tree, CheckedTreeNode node) {
  72     setNodeState(tree, node, !node.isChecked());
  73   }
  74
  75   private void adjustParentsAndChildren(final CheckedTreeNode node, final boolean checked) {
  76     if (!checked) {
  77       if (myCheckPolicy.uncheckParentWithUncheckedChild) {
  78         TreeNode parent = node.getParent();
  79         while (parent != null) {
  80           if (parent instanceof CheckedTreeNode) {
  81             changeNodeState((CheckedTreeNode)parent, false);
  82           }
  83           parent = parent.getParent();
  84         }
  85       }
  86       if (myCheckPolicy.uncheckChildrenWithUncheckedParent) {
  87         uncheckChildren(node);
  88       }
  89     }
  90     else {
  91       if (myCheckPolicy.checkChildrenWithCheckedParent) {
  92         checkChildren(node);
  93       }
  94
  95       if (myCheckPolicy.checkParentWithCheckedChild) {
  96         TreeNode parent = node.getParent();
  97         while (parent != null) {
  98           if (parent instanceof CheckedTreeNode) {
  99             changeNodeState((CheckedTreeNode)parent, true);
 100           }
 101           parent = parent.getParent();
 102         }
 103       }
 104     }
 105   }
 106
 107   private void changeNodeState(final CheckedTreeNode node, final boolean checked) {
 108     if (node.isChecked() != checked) {
 109       myEventDispatcher.getMulticaster().beforeNodeStateChanged(node);
 110       node.setChecked(checked);
 111       myEventDispatcher.getMulticaster().nodeStateChanged(node);
 112     }
 113   }
 114
 115   private void uncheckChildren(final CheckedTreeNode node) {
 116     final Enumeration children = node.children();
 117     while (children.hasMoreElements()) {
 118       final Object o = children.nextElement();
 119       if (!(o instanceof CheckedTreeNode)) continue;
 120       CheckedTreeNode child = (CheckedTreeNode)o;
 121       changeNodeState(child, false);
 122       uncheckChildren(child);
 123     }
 124   }
 125
 126   private void checkChildren(final CheckedTreeNode node) {
 127     final Enumeration children = node.children();
 128     while (children.hasMoreElements()) {
 129       final Object o = children.nextElement();
 130       if (!(o instanceof CheckedTreeNode)) continue;
 131       CheckedTreeNode child = (CheckedTreeNode)o;
 132       changeNodeState(child, true);
 133       checkChildren(child);
 134     }
 135   }
 136
 137   private void setupKeyListener(final Tree tree, final JComponent mainComponent) {
 138     mainComponent.addKeyListener(new KeyAdapter() {
 139       public void keyPressed(@NotNull KeyEvent e) {
 140         if (isToggleEvent(e, mainComponent)) {
 141           TreePath treePath = tree.getLeadSelectionPath();
 142           if (treePath == null) return;
 143           final Object o = treePath.getLastPathComponent();
 144           if (!(o instanceof CheckedTreeNode)) return;
 145           CheckedTreeNode firstNode = (CheckedTreeNode)o;
 146           if (!firstNode.isEnabled()) return;
 147           toggleNode(tree, firstNode);
 148           boolean checked = firstNode.isChecked();
 149
 150           TreePath[] selectionPaths = tree.getSelectionPaths();
 151           for (int i = 0; selectionPaths != null && i < selectionPaths.length; i++) {
 152             final TreePath selectionPath = selectionPaths[i];
 153             final Object o1 = selectionPath.getLastPathComponent();
 154             if (!(o1 instanceof CheckedTreeNode)) continue;
 155             CheckedTreeNode node = (CheckedTreeNode)o1;
 156             setNodeState(tree, node, checked);
 157           }
 158
 159           e.consume();
 160         }
 161       }
 162     });
 163   }
 164
 165   private static boolean isToggleEvent(KeyEvent e, JComponent mainComponent) {
 166     return e.getKeyCode() == KeyEvent.VK_SPACE && SpeedSearchSupply.getSupply(mainComponent) == null;
 167   }
 168
 169   private void setupMouseListener(final Tree tree, JComponent mainComponent, final CheckboxTreeBase.CheckboxTreeCellRendererBase cellRenderer) {
 170     new ClickListener() {
 171       @Override
 172       public boolean onClick(@NotNull MouseEvent e, int clickCount) {
 173         int row = tree.getRowForLocation(e.getX(), e.getY());
 174         if (row < 0) return false;
 175         final Object o = tree.getPathForRow(row).getLastPathComponent();
 176         if (!(o instanceof CheckedTreeNode)) return false;
 177         Rectangle rowBounds = tree.getRowBounds(row);
 178         cellRenderer.setBounds(rowBounds);
 179         Rectangle checkBounds = cellRenderer.myCheckbox.getBounds();
 180         checkBounds.setLocation(rowBounds.getLocation());
 181
 182         if (checkBounds.height == 0) checkBounds.height = checkBounds.width = rowBounds.height;
 183
 184         final CheckedTreeNode node = (CheckedTreeNode)o;
 185         if (checkBounds.contains(e.getPoint())) {
 186           if (node.isEnabled()) {
 187             toggleNode(tree, node);
 188             tree.setSelectionRow(row);
 189             return true;
 190           }
 191         }
 192         else if (clickCount > 1) {
 193           myEventDispatcher.getMulticaster().mouseDoubleClicked(node);
 194           return true;
 195         }
 196
 197         return false;
 198       }
 199     }.installOn(mainComponent);
 200   }
 201
 202   @SuppressWarnings("unchecked")
 203   public static <T> T[] getCheckedNodes(final Class<T> nodeType, @Nullable final Tree.NodeFilter<T> filter, final TreeModel model) {
 204     final ArrayList<T> nodes = new ArrayList<T>();
 205     final Object root = model.getRoot();
 206     if (!(root instanceof CheckedTreeNode)) {
 207       throw new IllegalStateException(
 208         "The root must be instance of the " + CheckedTreeNode.class.getName() + ": " + root.getClass().getName());
 209     }
 210     new Object() {
 211       @SuppressWarnings("unchecked")
 212       public void collect(CheckedTreeNode node) {
 213         if (node.isLeaf()) {
 214           Object userObject = node.getUserObject();
 215           if (node.isChecked() && userObject != null && nodeType.isAssignableFrom(userObject.getClass())) {
 216             final T value = (T)userObject;
 217             if (filter != null && !filter.accept(value)) return;
 218             nodes.add(value);
 219           }
 220         }
 221         else {
 222           for (int i = 0; i < node.getChildCount(); i++) {
 223             final TreeNode child = node.getChildAt(i);
 224             if (child instanceof CheckedTreeNode) {
 225               collect((CheckedTreeNode)child);
 226             }
 227           }
 228         }
 229       }
 230     }.collect((CheckedTreeNode)root);
 231     T[] result = (T[])Array.newInstance(nodeType, nodes.size());
 232     nodes.toArray(result);
 233     return result;
 234   }
 235 }