221236c7af3723303659209bc376ecb4e7905ea5
[idea/community.git] / platform / lang-impl / src / com / intellij / util / ui / tree / AbstractFileTreeTable.java
1 /*
2  * Copyright 2000-2015 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
17 package com.intellij.util.ui.tree;
18
19 import com.intellij.icons.AllIcons;
20 import com.intellij.ide.CommonActionsManager;
21 import com.intellij.ide.DefaultTreeExpander;
22 import com.intellij.openapi.project.Project;
23 import com.intellij.openapi.roots.ProjectFileIndex;
24 import com.intellij.openapi.roots.ProjectRootManager;
25 import com.intellij.openapi.ui.Messages;
26 import com.intellij.openapi.util.Comparing;
27 import com.intellij.openapi.vfs.VfsUtilCore;
28 import com.intellij.openapi.vfs.VirtualFile;
29 import com.intellij.openapi.vfs.VirtualFileFilter;
30 import com.intellij.ui.TableUtil;
31 import com.intellij.ui.TreeTableSpeedSearch;
32 import com.intellij.ui.treeStructure.treetable.TreeTable;
33 import com.intellij.ui.treeStructure.treetable.TreeTableCellRenderer;
34 import com.intellij.ui.treeStructure.treetable.TreeTableModel;
35 import com.intellij.util.IconUtil;
36 import com.intellij.util.PlatformIcons;
37 import com.intellij.util.containers.Convertor;
38 import com.intellij.util.containers.HashMap;
39 import com.intellij.util.ui.UIUtil;
40 import gnu.trove.THashMap;
41 import org.jetbrains.annotations.NotNull;
42 import org.jetbrains.annotations.Nullable;
43
44 import javax.swing.*;
45 import javax.swing.table.TableColumn;
46 import javax.swing.tree.*;
47 import java.awt.*;
48 import java.util.*;
49 import java.util.List;
50
51 public class AbstractFileTreeTable<T> extends TreeTable {
52   private final MyModel<T> myModel;
53   private final Project myProject;
54
55   public AbstractFileTreeTable(@NotNull Project project,
56                                @NotNull Class<T> valueClass,
57                                @NotNull String valueTitle,
58                                @NotNull VirtualFileFilter filter,
59                                boolean showProjectNode) {
60     this(project, valueClass, valueTitle, filter, showProjectNode, true);
61   }
62
63   /**
64    * Due to historical reasons, passed filter does not perform all jobs - fileIndex.isInContent is checked in addition.
65    * Flag showContentFilesOnly allows you to disable such behavior.
66    */
67   public AbstractFileTreeTable(@NotNull Project project,
68                                @NotNull Class<T> valueClass,
69                                @NotNull String valueTitle,
70                                @NotNull VirtualFileFilter filter,
71                                boolean showProjectNode,
72                                boolean showContentFilesOnly) {
73     super(new MyModel<T>(project, valueClass, valueTitle, showContentFilesOnly ? new ProjectContentFileFilter(project, filter) : filter));
74     myProject = project;
75
76     //noinspection unchecked
77     myModel = (MyModel)getTableModel();
78     myModel.setTreeTable(this);
79
80     new TreeTableSpeedSearch(this, new Convertor<TreePath, String>() {
81       @Override
82       public String convert(final TreePath o) {
83         final DefaultMutableTreeNode node = (DefaultMutableTreeNode)o.getLastPathComponent();
84         final Object userObject = node.getUserObject();
85         if (userObject == null) {
86           return getProjectNodeText();
87         }
88         if (userObject instanceof VirtualFile) {
89           return ((VirtualFile)userObject).getName();
90         }
91         return node.toString();
92       }
93     });
94     final DefaultTreeExpander treeExpander = new DefaultTreeExpander(getTree());
95     CommonActionsManager.getInstance().createExpandAllAction(treeExpander, this);
96     CommonActionsManager.getInstance().createCollapseAllAction(treeExpander, this);
97
98     getTree().setShowsRootHandles(true);
99     getTree().setLineStyleAngled();
100     getTree().setRootVisible(showProjectNode);
101     final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex();
102     getTree().setCellRenderer(new DefaultTreeCellRenderer() {
103       @Override
104       public Component getTreeCellRendererComponent(final JTree tree, final Object value, final boolean sel, final boolean expanded,
105                                                     final boolean leaf, final int row, final boolean hasFocus) {
106         super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus);
107         if (value instanceof ProjectRootNode) {
108           setText(getProjectNodeText());
109           setIcon(AllIcons.Nodes.Project);
110           return this;
111         }
112         FileNode fileNode = (FileNode)value;
113         VirtualFile file = fileNode.getObject();
114         setText(fileNode.getParent() instanceof FileNode ? file.getName() : file.getPresentableUrl());
115         if (file.isDirectory()) {
116           setIcon(fileIndex.isExcluded(file) ? AllIcons.Modules.ExcludeRoot : PlatformIcons.DIRECTORY_CLOSED_ICON);
117         }
118         else {
119           setIcon(IconUtil.getIcon(file, 0, null));
120         }
121         return this;
122       }
123     });
124     getTableHeader().setReorderingAllowed(false);
125
126     setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
127     setPreferredScrollableViewportSize(new Dimension(300, getRowHeight() * 10));
128
129     getColumnModel().getColumn(0).setPreferredWidth(280);
130     getColumnModel().getColumn(1).setPreferredWidth(60);
131   }
132
133   protected boolean isNullObject(final T value) {
134     return false;
135   }
136
137   private static String getProjectNodeText() {
138     return "Project";
139   }
140
141   public Project getProject() {
142     return myProject;
143   }
144
145   public TableColumn getValueColumn() {
146     return getColumnModel().getColumn(1);
147   }
148
149   protected boolean isValueEditableForFile(final VirtualFile virtualFile) {
150     return true;
151   }
152
153   public static void press(final Container comboComponent) {
154     if (comboComponent instanceof JButton) {
155       ((JButton)comboComponent).doClick();
156     }
157     else {
158       for (int i = 0; i < comboComponent.getComponentCount(); i++) {
159         Component child = comboComponent.getComponent(i);
160         if (child instanceof Container) {
161           press((Container)child);
162         }
163       }
164     }
165   }
166
167   public boolean clearSubdirectoriesOnDemandOrCancel(final VirtualFile parent, final String message, final String title) {
168     Map<VirtualFile, T> mappings = myModel.myCurrentMapping;
169     Map<VirtualFile, T> subdirectoryMappings = new THashMap<VirtualFile, T>();
170     for (VirtualFile file : mappings.keySet()) {
171       if (file != null && (parent == null || VfsUtilCore.isAncestor(parent, file, true))) {
172         subdirectoryMappings.put(file, mappings.get(file));
173       }
174     }
175     if (subdirectoryMappings.isEmpty()) {
176       return true;
177     }
178     int ret = Messages.showYesNoCancelDialog(myProject, message, title, "Override", "Do Not Override", "Cancel",
179                                              Messages.getWarningIcon());
180     if (ret == Messages.YES) {
181       for (VirtualFile file : subdirectoryMappings.keySet()) {
182         myModel.setValueAt(null, new DefaultMutableTreeNode(file), 1);
183       }
184     }
185     return ret != Messages.CANCEL;
186   }
187
188   @NotNull
189   public Map<VirtualFile, T> getValues() {
190     return myModel.getValues();
191   }
192
193   @Override
194   public TreeTableCellRenderer createTableRenderer(TreeTableModel treeTableModel) {
195     TreeTableCellRenderer tableRenderer = super.createTableRenderer(treeTableModel);
196     UIUtil.setLineStyleAngled(tableRenderer);
197     tableRenderer.setRootVisible(false);
198     tableRenderer.setShowsRootHandles(true);
199
200     return tableRenderer;
201   }
202
203   public void reset(@NotNull Map<VirtualFile, T> mappings) {
204     myModel.reset(mappings);
205     myModel.nodeChanged((TreeNode)myModel.getRoot());
206     getTree().setModel(null);
207     getTree().setModel(myModel);
208     TreeUtil.expandRootChildIfOnlyOne(getTree());
209   }
210
211   public void select(@Nullable final VirtualFile toSelect) {
212     if (toSelect != null) {
213       select(toSelect, (TreeNode)myModel.getRoot());
214     }
215   }
216
217   private void select(@NotNull VirtualFile toSelect, final TreeNode root) {
218     for (int i = 0; i < root.getChildCount(); i++) {
219       TreeNode child = root.getChildAt(i);
220       VirtualFile file = ((FileNode)child).getObject();
221       if (VfsUtilCore.isAncestor(file, toSelect, false)) {
222         if (Comparing.equal(file, toSelect)) {
223           TreeUtil.selectNode(getTree(), child);
224           getSelectionModel().clearSelection();
225           addSelectedPath(TreeUtil.getPathFromRoot(child));
226           TableUtil.scrollSelectionToVisible(this);
227         }
228         else {
229           select(toSelect, child);
230         }
231         return;
232       }
233     }
234   }
235
236   private static class MyModel<T> extends DefaultTreeModel implements TreeTableModel {
237     private final Map<VirtualFile, T> myCurrentMapping = new HashMap<VirtualFile, T>();
238     private final Class<T> myValueClass;
239     private final String myValueTitle;
240     private AbstractFileTreeTable<T> myTreeTable;
241
242     private MyModel(@NotNull Project project, @NotNull Class<T> valueClass, @NotNull String valueTitle, @NotNull VirtualFileFilter filter) {
243       super(new ProjectRootNode(project, filter));
244       myValueClass = valueClass;
245       myValueTitle = valueTitle;
246     }
247
248     private Map<VirtualFile, T> getValues() {
249       return new HashMap<VirtualFile, T>(myCurrentMapping);
250     }
251
252     @Override
253     public void setTree(JTree tree) {
254     }
255
256     @Override
257     public int getColumnCount() {
258       return 2;
259     }
260
261     @Override
262     public String getColumnName(final int column) {
263       switch (column) {
264         case 0:
265           return "File/Directory";
266         case 1:
267           return myValueTitle;
268         default:
269           throw new RuntimeException("invalid column " + column);
270       }
271     }
272
273     @Override
274     public Class getColumnClass(final int column) {
275       switch (column) {
276         case 0:
277           return TreeTableModel.class;
278         case 1:
279           return myValueClass;
280         default:
281           throw new RuntimeException("invalid column " + column);
282       }
283     }
284
285     @Override
286     public Object getValueAt(final Object node, final int column) {
287       Object userObject = ((DefaultMutableTreeNode)node).getUserObject();
288       if (userObject instanceof Project) {
289         switch (column) {
290           case 0:
291             return userObject;
292           case 1:
293             return myCurrentMapping.get(null);
294         }
295       }
296       VirtualFile file = (VirtualFile)userObject;
297       switch (column) {
298         case 0:
299           return file;
300         case 1:
301           return myCurrentMapping.get(file);
302         default:
303           throw new RuntimeException("invalid column " + column);
304       }
305     }
306
307     @Override
308     public boolean isCellEditable(final Object node, final int column) {
309       switch (column) {
310         case 0:
311           return false;
312         case 1:
313           final Object userObject = ((DefaultMutableTreeNode)node).getUserObject();
314           return !(userObject instanceof VirtualFile || userObject == null) || myTreeTable.isValueEditableForFile((VirtualFile)userObject);
315         default:
316           throw new RuntimeException("invalid column " + column);
317       }
318     }
319
320     @Override
321     public void setValueAt(final Object aValue, final Object node, final int column) {
322       final Object userObject = ((DefaultMutableTreeNode)node).getUserObject();
323       if (userObject instanceof Project) {
324         return;
325       }
326
327       final VirtualFile file = (VirtualFile)userObject;
328       @SuppressWarnings("unchecked")
329       T t = (T)aValue;
330       if (t == null || myTreeTable.isNullObject(t)) {
331         myCurrentMapping.remove(file);
332       }
333       else {
334         myCurrentMapping.put(file, t);
335       }
336       fireTreeNodesChanged(this, new Object[]{getRoot()}, null, null);
337     }
338
339     public void reset(@NotNull Map<VirtualFile, T> mappings) {
340       myCurrentMapping.clear();
341       myCurrentMapping.putAll(mappings);
342       ((ProjectRootNode)getRoot()).clearCachedChildren();
343     }
344
345     void setTreeTable(final AbstractFileTreeTable<T> treeTable) {
346       myTreeTable = treeTable;
347     }
348   }
349
350   public static class ProjectRootNode extends ConvenientNode<Project> {
351     private final VirtualFileFilter myFilter;
352
353     public ProjectRootNode(@NotNull Project project) {
354       this(project, VirtualFileFilter.ALL);
355     }
356
357     public ProjectRootNode(@NotNull Project project, @NotNull VirtualFileFilter filter) {
358       super(project);
359       myFilter = filter;
360     }
361
362     @Override
363     protected void appendChildrenTo(@NotNull final Collection<ConvenientNode> children) {
364       Project project = getObject();
365       VirtualFile[] roots = ProjectRootManager.getInstance(project).getContentRoots();
366
367       NextRoot:
368       for (VirtualFile root : roots) {
369         for (VirtualFile candidate : roots) {
370           if (VfsUtilCore.isAncestor(candidate, root, true)) continue NextRoot;
371         }
372         if (myFilter.accept(root)) {
373           children.add(new FileNode(root, project, myFilter));
374         }
375       }
376     }
377   }
378
379   public abstract static class ConvenientNode<T> extends DefaultMutableTreeNode {
380     private final T myObject;
381
382     private ConvenientNode(T object) {
383       myObject = object;
384     }
385
386     public T getObject() {
387       return myObject;
388     }
389
390     protected abstract void appendChildrenTo(@NotNull Collection<ConvenientNode> children);
391
392     @Override
393     public int getChildCount() {
394       init();
395       return super.getChildCount();
396     }
397
398     @Override
399     public TreeNode getChildAt(final int childIndex) {
400       init();
401       return super.getChildAt(childIndex);
402     }
403
404     @Override
405     public Enumeration children() {
406       init();
407       return super.children();
408     }
409
410     private void init() {
411       if (getUserObject() == null) {
412         setUserObject(myObject);
413         final List<ConvenientNode> children = new ArrayList<ConvenientNode>();
414         appendChildrenTo(children);
415         Collections.sort(children, new Comparator<ConvenientNode>() {
416           @Override
417           public int compare(final ConvenientNode node1, final ConvenientNode node2) {
418             Object o1 = node1.getObject();
419             Object o2 = node2.getObject();
420             if (o1 == o2) return 0;
421             if (o1 instanceof Project) return -1;
422             if (o2 instanceof Project) return 1;
423             VirtualFile file1 = (VirtualFile)o1;
424             VirtualFile file2 = (VirtualFile)o2;
425             if (file1.isDirectory() != file2.isDirectory()) {
426               return file1.isDirectory() ? -1 : 1;
427             }
428             return file1.getName().compareTo(file2.getName());
429           }
430         });
431         int i = 0;
432         for (ConvenientNode child : children) {
433           insert(child, i++);
434         }
435       }
436     }
437
438     public void clearCachedChildren() {
439       if (children != null) {
440         for (Object child : children) {
441           //noinspection unchecked
442           ((ConvenientNode<T>)child).clearCachedChildren();
443         }
444       }
445       removeAllChildren();
446       setUserObject(null);
447     }
448   }
449
450   public static class FileNode extends ConvenientNode<VirtualFile> {
451     private final Project myProject;
452     private final VirtualFileFilter myFilter;
453
454     public FileNode(@NotNull VirtualFile file, @NotNull final Project project) {
455       this(file, project, VirtualFileFilter.ALL);
456     }
457
458     public FileNode(@NotNull VirtualFile file, @NotNull final Project project, @NotNull VirtualFileFilter filter) {
459       super(file);
460       myProject = project;
461       myFilter = filter;
462     }
463
464     @Override
465     protected void appendChildrenTo(@NotNull final Collection<ConvenientNode> children) {
466       for (VirtualFile child : getObject().getChildren()) {
467         if (myFilter.accept(child)) {
468           children.add(new FileNode(child, myProject, myFilter));
469         }
470       }
471     }
472   }
473 }