@NotNull
public EditorWindow[] getOrderedWindows() {
final ArrayList<EditorWindow> res = new ArrayList<EditorWindow>();
// Collector for windows in tree ordering:
class Inner {
final void collect(final JPanel panel) {
final Component comp = panel.getComponent(0);
if (comp instanceof Splitter) {
final Splitter splitter = (Splitter) comp;
collect((JPanel) splitter.getFirstComponent());
collect((JPanel) splitter.getSecondComponent());
} else if (comp instanceof JPanel || comp instanceof JBTabs) {
final EditorWindow window = findWindowWith(comp);
if (window != null) {
res.add(window);
}
}
}
}
// get root component and traverse splitters tree:
if (getComponentCount() != 0) {
final Component comp = getComponent(0);
LOG.assertTrue(comp instanceof JPanel);
final JPanel panel = (JPanel) comp;
if (panel.getComponentCount() != 0) {
new Inner().collect(panel);
}
}
LOG.assertTrue(res.size() == myWindows.size());
return res.toArray(new EditorWindow[res.size()]);
}
public EditorWithProviderComposite[] getEditorsComposites() {
final ArrayList<EditorWithProviderComposite> res = new ArrayList<EditorWithProviderComposite>();
for (final EditorWindow myWindow : myWindows) {
final EditorWithProviderComposite[] editors = myWindow.getEditors();
ContainerUtil.addAll(res, editors);
}
return res.toArray(new EditorWithProviderComposite[res.size()]);
}
/**
* @return breakpoints of one of the category: LINE_BREAKPOINTS, EXCEPTION_BREAKPOINTS,
* FIELD_BREAKPOINTS, METHOD_BREAKPOINTS
*/
public <T extends Breakpoint> Breakpoint[] getBreakpoints(@NotNull final Key<T> category) {
ApplicationManager.getApplication().assertIsDispatchThread();
removeInvalidBreakpoints();
final ArrayList<Breakpoint> breakpoints = new ArrayList<Breakpoint>();
for (Breakpoint breakpoint : getBreakpoints()) {
if (category.equals(breakpoint.getCategory())) {
breakpoints.add(breakpoint);
}
}
return breakpoints.toArray(new Breakpoint[breakpoints.size()]);
}
@Override
public Configurable[] getConfigurables() {
if (myConfigurables == null) {
final ArrayList<Configurable> configurables = new ArrayList<Configurable>();
for (LanguageInjectionSupport support : InjectorUtils.getActiveInjectionSupports()) {
ContainerUtil.addAll(configurables, support.createSettings(myProject, myConfiguration));
}
Collections.sort(
configurables,
new Comparator<Configurable>() {
public int compare(final Configurable o1, final Configurable o2) {
return Comparing.compare(o1.getDisplayName(), o2.getDisplayName());
}
});
myConfigurables = configurables.toArray(new Configurable[configurables.size()]);
}
return myConfigurables;
}
public boolean setHostInjectionEnabled(
final PsiLanguageInjectionHost host,
final Collection<String> languages,
final boolean enabled) {
final ArrayList<BaseInjection> originalInjections = new ArrayList<BaseInjection>();
final ArrayList<BaseInjection> newInjections = new ArrayList<BaseInjection>();
for (LanguageInjectionSupport support : InjectorUtils.getActiveInjectionSupports()) {
for (BaseInjection injection : getInjections(support.getId())) {
if (!languages.contains(injection.getInjectedLanguageId())) continue;
boolean replace = false;
final ArrayList<InjectionPlace> newPlaces = new ArrayList<InjectionPlace>();
for (InjectionPlace place : injection.getInjectionPlaces()) {
if (place.isEnabled() != enabled
&& place.getElementPattern() != null
&& (place.getElementPattern().accepts(host)
|| place.getElementPattern().accepts(host.getParent()))) {
newPlaces.add(place.enabled(enabled));
replace = true;
} else newPlaces.add(place);
}
if (replace) {
originalInjections.add(injection);
final BaseInjection newInjection = injection.copy();
newInjection.setInjectionPlaces(newPlaces.toArray(new InjectionPlace[newPlaces.size()]));
newInjections.add(newInjection);
}
}
}
if (!originalInjections.isEmpty()) {
replaceInjectionsWithUndo(
host.getProject(),
newInjections,
originalInjections,
Collections.<PsiElement>emptyList());
return true;
}
return false;
}
@NotNull
private GroovyResolveResult[] resolveTypeOrPropertyInner() {
PsiElement nameElement = getReferenceNameElement();
String name = getReferenceName();
if (name == null || nameElement == null) return GroovyResolveResult.EMPTY_ARRAY;
IElementType nameType = nameElement.getNode().getElementType();
if (nameType == GroovyTokenTypes.kTHIS) {
GroovyResolveResult[] results = GrThisReferenceResolver.resolveThisExpression(this);
if (results != null) {
return results;
}
} else if (nameType == GroovyTokenTypes.kSUPER) {
GroovyResolveResult[] results = GrSuperReferenceResolver.resolveSuperExpression(this);
if (results != null) {
return results;
}
}
EnumSet<ClassHint.ResolveKind> kinds =
getParent() instanceof GrReferenceExpression
? ClassHint.RESOLVE_KINDS_CLASS_PACKAGE
: ClassHint.RESOLVE_KINDS_CLASS;
GroovyResolveResult[] classCandidates = null;
GrReferenceResolveRunner resolveRunner = new GrReferenceResolveRunner(this);
ResolverProcessor processor = new PropertyResolverProcessor(name, this);
resolveRunner.resolveImpl(processor);
final GroovyResolveResult[] fieldCandidates = processor.getCandidates();
if (hasAt()) {
return fieldCandidates;
}
boolean canBeClassOrPackage = ResolveUtil.canBeClassOrPackage(this);
if (canBeClassOrPackage && findClassOrPackageAtFirst()) {
ResolverProcessor classProcessor = new ClassResolverProcessor(name, this, kinds);
resolveRunner.resolveImpl(classProcessor);
classCandidates = classProcessor.getCandidates();
if (classCandidates.length > 0 && containsPackage(classCandidates)) {
final PsiElement firstNonReferenceExprParent =
PsiTreeUtil.skipParentsOfType(this, GrReferenceExpressionImpl.class);
final GrReferenceExpressionImpl topRef =
(GrReferenceExpressionImpl)
PsiTreeUtil.findFirstParent(
this,
new Condition<PsiElement>() {
@Override
public boolean value(PsiElement parent) {
return parent.getParent() == firstNonReferenceExprParent
&& parent instanceof GrReferenceExpressionImpl;
}
});
if (topRef != null) {
final String fqn = topRef.getTextSkipWhiteSpaceAndComments();
if (JavaPsiFacade.getInstance(getProject()).findClass(fqn, getResolveScope()) != null) {
return classCandidates;
}
}
}
}
// if reference expression is in class we need to return field instead of accessor method
for (GroovyResolveResult candidate : fieldCandidates) {
final PsiElement element = candidate.getElement();
if (element instanceof PsiField) {
final PsiClass containingClass = ((PsiField) element).getContainingClass();
if (containingClass != null && PsiUtil.getContextClass(this) == containingClass)
return fieldCandidates;
} else if (!(element instanceof GrBindingVariable)) {
return fieldCandidates;
}
}
if (classCandidates != null && classCandidates.length > 0) return classCandidates;
final boolean isLValue = PsiUtil.isLValue(this);
String[] accessorNames =
isLValue
? GroovyPropertyUtils.suggestSettersName(name)
: GroovyPropertyUtils.suggestGettersName(name);
List<GroovyResolveResult> accessorResults = new ArrayList<GroovyResolveResult>();
for (String accessorName : accessorNames) {
AccessorResolverProcessor accessorResolver =
new AccessorResolverProcessor(
accessorName,
name,
this,
!isLValue,
false,
PsiImplUtil.getQualifierType(this),
getTypeArguments());
resolveRunner.resolveImpl(accessorResolver);
final GroovyResolveResult[] candidates = accessorResolver.getCandidates();
// can be only one correct candidate or some incorrect
if (candidates.length == 1 && candidates[0].isStaticsOK() && candidates[0].isAccessible()) {
return candidates;
} else {
ContainerUtil.addAll(accessorResults, candidates);
}
}
final ArrayList<GroovyResolveResult> fieldList = ContainerUtil.newArrayList(fieldCandidates);
filterOutBindings(fieldList);
if (!fieldList.isEmpty()) {
return fieldList.toArray(new GroovyResolveResult[fieldList.size()]);
}
if (classCandidates == null && canBeClassOrPackage) {
ResolverProcessor classProcessor = new ClassResolverProcessor(name, this, kinds);
resolveRunner.resolveImpl(classProcessor);
classCandidates = classProcessor.getCandidates();
}
if (classCandidates != null && classCandidates.length > 0) return classCandidates;
if (!accessorResults.isEmpty()) return new GroovyResolveResult[] {accessorResults.get(0)};
return GroovyResolveResult.EMPTY_ARRAY;
}
