@Override
protected void collectAdditionalElementsToRename(List<Pair<PsiElement, TextRange>> stringUsages) {
if (isReplaceAllOccurrences()) {
for (E expression : getOccurrences()) {
LOG.assertTrue(expression.isValid(), expression.getText());
stringUsages.add(
Pair.<PsiElement, TextRange>create(
expression, new TextRange(0, expression.getTextLength())));
}
} else if (getExpr() != null) {
correctExpression();
final E expr = getExpr();
LOG.assertTrue(expr.isValid(), expr.getText());
stringUsages.add(
Pair.<PsiElement, TextRange>create(expr, new TextRange(0, expr.getTextLength())));
}
final V localVariable = getLocalVariable();
if (localVariable != null) {
final PsiElement nameIdentifier = localVariable.getNameIdentifier();
if (nameIdentifier != null) {
int length = nameIdentifier.getTextLength();
stringUsages.add(
Pair.<PsiElement, TextRange>create(nameIdentifier, new TextRange(0, length)));
}
}
}
public void actionPerformed(AnActionEvent e) {
final PackageDependenciesNode leftNode = myLeftTree.getSelectedNode();
final PackageDependenciesNode rightNode = myRightTree.getSelectedNode();
if (leftNode != null && rightNode != null) {
boolean hasDirectDependencies = myTransitiveBorder == 0;
if (myTransitiveBorder > 0) {
final Set<PsiFile> searchIn = getSelectedScope(myLeftTree);
final Set<PsiFile> searchFor = getSelectedScope(myRightTree);
for (DependenciesBuilder builder : myBuilders) {
if (hasDirectDependencies) break;
for (PsiFile from : searchIn) {
if (hasDirectDependencies) break;
for (PsiFile to : searchFor) {
if (hasDirectDependencies) break;
final List<List<PsiFile>> paths = builder.findPaths(from, to);
for (List<PsiFile> path : paths) {
if (path.isEmpty()) {
hasDirectDependencies = true;
break;
}
}
}
}
}
}
final PatternDialectProvider provider =
PatternDialectProvider.getInstance(mySettings.SCOPE_TYPE);
PackageSet leftPackageSet = provider.createPackageSet(leftNode, true);
if (leftPackageSet == null) {
leftPackageSet = provider.createPackageSet(leftNode, false);
}
LOG.assertTrue(leftPackageSet != null);
PackageSet rightPackageSet = provider.createPackageSet(rightNode, true);
if (rightPackageSet == null) {
rightPackageSet = provider.createPackageSet(rightNode, false);
}
LOG.assertTrue(rightPackageSet != null);
if (hasDirectDependencies) {
DependencyValidationManager.getInstance(myProject)
.addRule(
new DependencyRule(
new NamedScope.UnnamedScope(leftPackageSet),
new NamedScope.UnnamedScope(rightPackageSet),
true));
rebuild();
} else {
Messages.showErrorDialog(
DependenciesPanel.this,
"Rule was not added.\n There is no direct dependency between \'"
+ leftPackageSet.getText()
+ "\' and \'"
+ rightPackageSet.getText()
+ "\'",
AnalysisScopeBundle.message("mark.dependency.illegal.text"));
}
}
}
@Override
public void actionPerformed(@NotNull AnActionEvent e) {
final OrderEntry selectedEntry = getSelectedEntry();
GlobalSearchScope targetScope;
if (selectedEntry instanceof ModuleOrderEntry) {
final Module module = ((ModuleOrderEntry) selectedEntry).getModule();
LOG.assertTrue(module != null);
targetScope = GlobalSearchScope.moduleScope(module);
} else {
Library library = ((LibraryOrderEntry) selectedEntry).getLibrary();
LOG.assertTrue(library != null);
targetScope = new LibraryScope(getProject(), library);
}
new AnalyzeDependenciesOnSpecifiedTargetHandler(
getProject(), new AnalysisScope(myState.getRootModel().getModule()), targetScope) {
@Override
protected boolean shouldShowDependenciesPanel(List<DependenciesBuilder> builders) {
for (DependenciesBuilder builder : builders) {
for (Set<PsiFile> files : builder.getDependencies().values()) {
if (!files.isEmpty()) {
Messages.showInfoMessage(
myProject,
"Dependencies were successfully collected in \""
+ ToolWindowId.DEPENDENCIES
+ "\" toolwindow",
FindBundle.message("find.pointcut.applications.not.found.title"));
return true;
}
}
}
String message = "No code dependencies were found.";
if (DependencyVisitorFactory.VisitorOptions.fromSettings(myProject).skipImports()) {
message += " ";
message += AnalysisScopeBundle.message("dependencies.in.imports.message");
}
message += " Would you like to remove the dependency?";
if (Messages.showOkCancelDialog(
myProject, message, CommonBundle.getWarningTitle(), Messages.getWarningIcon())
== Messages.OK) {
removeSelectedItems(TableUtil.removeSelectedItems(myEntryTable));
}
return false;
}
@Override
protected boolean canStartInBackground() {
return false;
}
}.analyze();
}
public void actionPerformed(final AnActionEvent e) {
final AnalysisScope scope = getScope();
LOG.assertTrue(scope != null);
final DependenciesBuilder builder;
if (!myForward) {
builder = new BackwardDependenciesBuilder(myProject, scope, myScopeOfInterest);
} else {
builder = new ForwardDependenciesBuilder(myProject, scope, myTransitiveBorder);
}
ProgressManager.getInstance()
.runProcessWithProgressAsynchronously(
myProject,
AnalysisScopeBundle.message("package.dependencies.progress.title"),
new Runnable() {
public void run() {
builder.analyze();
}
},
new Runnable() {
public void run() {
myBuilders.add(builder);
myDependencies.putAll(builder.getDependencies());
myIllegalDependencies.putAll(builder.getIllegalDependencies());
exclude(myExcluded);
rebuild();
}
},
null,
new PerformAnalysisInBackgroundOption(myProject));
}
protected void createLocalProcess(String className)
throws ExecutionException, InterruptedException, InvocationTargetException {
LOG.assertTrue(myDebugProcess == null);
myDebuggerSession =
createLocalProcess(DebuggerSettings.SOCKET_TRANSPORT, createJavaParameters(className));
myDebugProcess = myDebuggerSession.getProcess();
}
@Override
public void contentsChanged(VirtualFileEvent event) {
if (event.isFromSave()) { // commit
assertThread();
VirtualFile file = event.getFile();
LOG.assertTrue(file.isValid());
if (myFile.equals(file)) {
updateModifiedProperty();
}
}
}
ReadAccessToken(boolean explicit) {
myExplicit = explicit;
LOG.assertTrue(
!Thread.holdsLock(PsiLock.LOCK),
"Thread must not hold PsiLock while performing readAction");
try {
myActionsLock.readLock().acquire();
if (myExplicit) acquired();
} catch (InterruptedException e) {
throw new RuntimeInterruptedException(e);
}
}
@Override
public Component getTreeCellEditorComponent(
JTree tree, Object value, boolean isSelected, boolean expanded, boolean leaf, int row) {
final JTextField field =
(JTextField)
super.getTreeCellEditorComponent(tree, value, isSelected, expanded, leaf, row);
final Object node = ((DefaultMutableTreeNode) value).getUserObject();
final PackagingElement<?> element = ((PackagingElementNode) node).getElementIfSingle();
LOG.assertTrue(element != null);
final String name = ((RenameablePackagingElement) element).getName();
field.setText(name);
int i = name.lastIndexOf('.');
field.setSelectionStart(0);
field.setSelectionEnd(i != -1 ? i : name.length());
return field;
}
@Override
protected void addHighlights(
@NotNull Map<TextRange, TextAttributes> ranges,
@NotNull Editor editor,
@NotNull Collection<RangeHighlighter> highlighters,
@NotNull HighlightManager highlightManager) {
final TextAttributes attributes =
EditorColorsManager.getInstance()
.getGlobalScheme()
.getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES);
final V variable = getVariable();
if (variable != null) {
final String name = variable.getName();
LOG.assertTrue(name != null, variable);
final int variableNameLength = name.length();
if (isReplaceAllOccurrences()) {
for (RangeMarker marker : getOccurrenceMarkers()) {
final int startOffset = marker.getStartOffset();
highlightManager.addOccurrenceHighlight(
editor,
startOffset,
startOffset + variableNameLength,
attributes,
0,
highlighters,
null);
}
} else if (getExpr() != null) {
final int startOffset = getExprMarker().getStartOffset();
highlightManager.addOccurrenceHighlight(
editor,
startOffset,
startOffset + variableNameLength,
attributes,
0,
highlighters,
null);
}
}
for (RangeHighlighter highlighter : highlighters) {
highlighter.setGreedyToLeft(true);
highlighter.setGreedyToRight(true);
}
}
public WriteAccessToken(Class _clazz) {
clazz = _clazz;
assertCanRunWriteAction();
ActivityTracker.getInstance().inc();
fireBeforeWriteActionStart(_clazz);
final AtomicBoolean stopped = new AtomicBoolean(false);
if (ourDumpThreadsOnLongWriteActionWaiting > 0) {
executeOnPooledThread(
new Runnable() {
@Override
public void run() {
while (!stopped.get()) {
try {
Thread.sleep(ourDumpThreadsOnLongWriteActionWaiting);
if (!stopped.get()) {
PerformanceWatcher.getInstance().dumpThreads(true);
}
} catch (InterruptedException ignored) {
}
}
}
});
}
LOG.assertTrue(
myActionsLock.isWriteLockAcquired(Thread.currentThread())
|| !Thread.holdsLock(PsiLock.LOCK),
"Thread must not hold PsiLock while performing writeAction");
try {
myActionsLock.writeLock().acquire();
acquired();
} catch (InterruptedException e) {
throw new RuntimeInterruptedException(e);
}
stopped.set(true);
myWriteActionsStack.push(_clazz);
fireWriteActionStarted(_clazz);
}
@Nullable
private AnalysisScope getScope() {
final Set<PsiFile> selectedScope = getSelectedScope(myRightTree);
Set<PsiFile> result = new HashSet<PsiFile>();
((PackageDependenciesNode) myLeftTree.getModel().getRoot())
.fillFiles(result, !mySettings.UI_FLATTEN_PACKAGES);
selectedScope.removeAll(result);
if (selectedScope.isEmpty()) return null;
List<VirtualFile> files = new ArrayList<VirtualFile>();
final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(myProject).getFileIndex();
for (PsiFile psiFile : selectedScope) {
final VirtualFile file = psiFile.getVirtualFile();
LOG.assertTrue(file != null);
if (fileIndex.isInContent(file)) {
files.add(file);
}
}
if (!files.isEmpty()) {
return new AnalysisScope(myProject, files);
}
return null;
}
@Override
protected JPanel processFiles(@NotNull List<Element> fileElements, final JPanel context) {
final Ref<EditorWindow> windowRef = new Ref<EditorWindow>();
UIUtil.invokeAndWaitIfNeeded(
new Runnable() {
@Override
public void run() {
windowRef.set(context == null ? createEditorWindow() : findWindowWith(context));
}
});
final EditorWindow window = windowRef.get();
LOG.assertTrue(window != null);
VirtualFile focusedFile = null;
for (int i = 0; i < fileElements.size(); i++) {
final Element file = fileElements.get(i);
if (i == 0) {
EditorTabbedContainer tabbedPane = window.getTabbedPane();
if (tabbedPane != null) {
try {
int limit =
Integer.parseInt(
file.getParentElement()
.getAttributeValue(
JBTabsImpl.SIDE_TABS_SIZE_LIMIT_KEY.toString(),
String.valueOf(JBTabsImpl.DEFAULT_MAX_TAB_WIDTH)));
UIUtil.putClientProperty(
tabbedPane.getComponent(), JBTabsImpl.SIDE_TABS_SIZE_LIMIT_KEY, limit);
} catch (NumberFormatException e) {
// ignore
}
}
}
try {
final FileEditorManagerImpl fileEditorManager = getManager();
Element historyElement = file.getChild(HistoryEntry.TAG);
final HistoryEntry entry =
HistoryEntry.createLight(fileEditorManager.getProject(), historyElement);
final VirtualFile virtualFile = entry.getFile();
if (virtualFile == null)
throw new InvalidDataException("No file exists: " + entry.getFilePointer().getUrl());
Document document =
ApplicationManager.getApplication()
.runReadAction(
new Computable<Document>() {
@Override
public Document compute() {
return virtualFile.isValid()
? FileDocumentManager.getInstance().getDocument(virtualFile)
: null;
}
});
final boolean isCurrentInTab =
Boolean.valueOf(file.getAttributeValue(CURRENT_IN_TAB)).booleanValue();
Boolean pin = Boolean.valueOf(file.getAttributeValue(PINNED));
fileEditorManager.openFileImpl4(
window, virtualFile, entry, isCurrentInTab, isCurrentInTab, pin, i);
if (isCurrentInTab) {
focusedFile = virtualFile;
}
if (document != null) {
// This is just to make sure document reference is kept on stack till this point
// so that document is available for folding state deserialization in HistoryEntry
// constructor
// and that document will be created only once during file opening
document.putUserData(DUMMY_KEY, null);
}
updateProgress();
} catch (InvalidDataException e) {
if (ApplicationManager.getApplication().isUnitTestMode()) {
LOG.error(e);
}
}
}
if (focusedFile != null) {
getManager().addSelectionRecord(focusedFile, window);
}
return window.myPanel;
}