inspection toolwindow: insert problem nodes with permission of duplication according...
[idea/community.git] / platform / lang-impl / src / com / intellij / codeInspection / ui / InspectionTreeNode.java
1 /*
2  * Copyright 2000-2016 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.codeInspection.ui;
18
19 import com.intellij.codeHighlighting.HighlightDisplayLevel;
20 import com.intellij.codeInspection.reference.RefEntity;
21 import com.intellij.openapi.vcs.FileStatus;
22 import com.intellij.util.containers.FactoryMap;
23 import com.intellij.util.ui.tree.TreeUtil;
24 import org.jetbrains.annotations.Nullable;
25
26 import javax.swing.*;
27 import javax.swing.tree.DefaultMutableTreeNode;
28 import javax.swing.tree.MutableTreeNode;
29 import javax.swing.tree.TreeNode;
30 import java.util.Enumeration;
31
32 /**
33  * @author max
34  */
35 public abstract class InspectionTreeNode extends DefaultMutableTreeNode {
36   protected volatile InspectionTreeUpdater myUpdater;
37   protected InspectionTreeNode  (Object userObject) {
38     super(userObject);
39   }
40
41   @Nullable
42   public Icon getIcon(boolean expanded) {
43     return null;
44   }
45
46   public void visitProblemSeverities(FactoryMap<HighlightDisplayLevel, Integer> counter) {
47     Enumeration enumeration = children();
48     while (enumeration.hasMoreElements()) {
49       InspectionTreeNode child = (InspectionTreeNode)enumeration.nextElement();
50       child.visitProblemSeverities(counter);
51     }
52   }
53
54   public int getProblemCount() {
55     int sum = 0;
56     Enumeration enumeration = children();
57     while (enumeration.hasMoreElements()) {
58       InspectionTreeNode child = (InspectionTreeNode)enumeration.nextElement();
59       sum += child.getProblemCount();
60     }
61     return sum;
62   }
63
64   public boolean isValid() {
65     return true;
66   }
67
68   public boolean isExcluded(ExcludedInspectionTreeNodesManager excludedManager) {
69     return excludedManager.isExcluded(this);
70   }
71
72   public boolean appearsBold() {
73     return false;
74   }
75
76   @Nullable
77   public String getCustomizedTailText() {
78     return null;
79   }
80
81   public FileStatus getNodeStatus() {
82     return FileStatus.NOT_CHANGED;
83   }
84
85   public void excludeElement(ExcludedInspectionTreeNodesManager excludedManager) {
86     excludedManager.exclude(this);
87     Enumeration enumeration = children();
88     while (enumeration.hasMoreElements()) {
89       InspectionTreeNode child = (InspectionTreeNode)enumeration.nextElement();
90       child.excludeElement(excludedManager);
91     }
92   }
93
94   public void amnestyElement(ExcludedInspectionTreeNodesManager excludedManager) {
95     excludedManager.amnesty(this);
96     Enumeration enumeration = children();
97     while (enumeration.hasMoreElements()) {
98       InspectionTreeNode child = (InspectionTreeNode)enumeration.nextElement();
99       child.amnestyElement(excludedManager);
100     }
101   }
102
103   public void insertByOrder(InspectionTreeNode child, boolean allowDuplication) {
104     if (!allowDuplication && getIndex(child) != -1) {
105       return;
106     }
107     final int i = TreeUtil.indexedBinarySearch(this, child, InspectionResultsViewComparator.getInstance());
108     if (!allowDuplication && i >= 0){
109       return;
110     }
111     insert(child, Math.abs(i + 1));
112   }
113
114   @Override
115   public void add(MutableTreeNode newChild) {
116     super.add(newChild);
117     if (myUpdater != null) {
118       ((InspectionTreeNode)newChild).propagateUpdater(myUpdater);
119       myUpdater.updateWithPreviewPanel(this);
120     }
121   }
122
123   @Override
124   public void insert(MutableTreeNode newChild, int childIndex) {
125     super.insert(newChild, childIndex);
126     if (myUpdater != null) {
127       ((InspectionTreeNode)newChild).propagateUpdater(myUpdater);
128       myUpdater.updateWithPreviewPanel(this);
129     }
130   }
131
132   private void propagateUpdater(InspectionTreeUpdater updater) {
133     if (myUpdater != null) return;
134     myUpdater = updater;
135     Enumeration enumeration = children();
136     while (enumeration.hasMoreElements()) {
137       InspectionTreeNode child = (InspectionTreeNode)enumeration.nextElement();
138       child.propagateUpdater(updater);
139     }
140   }
141
142   public RefEntity getContainingFileLocalEntity() {
143     final Enumeration children = children();
144     RefEntity current = null;
145     while (children.hasMoreElements()) {
146       InspectionTreeNode child = (InspectionTreeNode)children.nextElement();
147       final RefEntity entity = child.getContainingFileLocalEntity();
148       if (entity == null || current != null) {
149         return null;
150       }
151       current = entity;
152     }
153     return current;
154   }
155
156   @Override
157   public synchronized TreeNode getParent() {
158     return super.getParent();
159   }
160
161   @Override
162   public synchronized void setParent(MutableTreeNode newParent) {
163     super.setParent(newParent);
164   }
165 }