blob: b182bc31bceb6deaedbc6008d32a61604db15f72 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
/*
* 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.usages.impl.rules;
import com.intellij.openapi.extensions.Extensions;
import com.intellij.openapi.vcs.FileStatus;
import com.intellij.psi.PsiComment;
import com.intellij.psi.PsiElement;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.usages.*;
import com.intellij.usages.rules.PsiElementUsage;
import com.intellij.usages.rules.UsageGroupingRuleEx;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import javax.swing.*;
/**
* @author max
*/
public class UsageTypeGroupingRule implements UsageGroupingRuleEx {
@Override
public UsageGroup groupUsage(@NotNull Usage usage) {
return groupUsage(usage, UsageTarget.EMPTY_ARRAY);
}
@Override
public UsageGroup groupUsage(@NotNull Usage usage, @NotNull UsageTarget[] targets) {
if (usage instanceof PsiElementUsage) {
PsiElementUsage elementUsage = (PsiElementUsage)usage;
UsageType usageType = getUsageType(elementUsage.getElement(), targets);
if (usageType != null) return new UsageTypeGroup(usageType);
if (usage instanceof ReadWriteAccessUsage) {
ReadWriteAccessUsage u = (ReadWriteAccessUsage)usage;
if (u.isAccessedForWriting()) return new UsageTypeGroup(UsageType.WRITE);
if (u.isAccessedForReading()) return new UsageTypeGroup(UsageType.READ);
}
return new UsageTypeGroup(UsageType.UNCLASSIFIED);
}
return null;
}
@Nullable
private static UsageType getUsageType(PsiElement element, @NotNull UsageTarget[] targets) {
if (element == null) return null;
if (PsiTreeUtil.getParentOfType(element, PsiComment.class, false) != null) { return UsageType.COMMENT_USAGE; }
UsageTypeProvider[] providers = Extensions.getExtensions(UsageTypeProvider.EP_NAME);
for(UsageTypeProvider provider: providers) {
UsageType usageType;
if (provider instanceof UsageTypeProviderEx) {
usageType = ((UsageTypeProviderEx) provider).getUsageType(element, targets);
}
else {
usageType = provider.getUsageType(element);
}
if (usageType != null) {
return usageType;
}
}
return null;
}
private static class UsageTypeGroup implements UsageGroup {
private final UsageType myUsageType;
private UsageTypeGroup(@NotNull UsageType usageType) {
myUsageType = usageType;
}
@Override
public void update() {
}
@Override
public Icon getIcon(boolean isOpen) {
return null;
}
@Override
@NotNull
public String getText(@Nullable UsageView view) {
return view == null ? myUsageType.toString() : myUsageType.toString(view.getPresentation());
}
@Override
public FileStatus getFileStatus() {
return null;
}
@Override
public boolean isValid() { return true; }
@Override
public void navigate(boolean focus) { }
@Override
public boolean canNavigate() { return false; }
@Override
public boolean canNavigateToSource() {
return false;
}
@Override
public int compareTo(@NotNull UsageGroup usageGroup) {
return getText(null).compareTo(usageGroup.getText(null));
}
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof UsageTypeGroup)) return false;
final UsageTypeGroup usageTypeGroup = (UsageTypeGroup)o;
return myUsageType.equals(usageTypeGroup.myUsageType);
}
public int hashCode() {
return myUsageType.hashCode();
}
}
}
|
