private boolean ensureUsagesWritable(
ReplaceContext replaceContext, Collection<Usage> selectedUsages) {
Set<VirtualFile> readOnlyFiles = null;
for (final Usage usage : selectedUsages) {
final VirtualFile file = ((UsageInFile) usage).getFile();
if (file != null && !file.isWritable()) {
if (readOnlyFiles == null) readOnlyFiles = new HashSet<VirtualFile>();
readOnlyFiles.add(file);
}
}
if (readOnlyFiles != null) {
ReadonlyStatusHandler.getInstance(myProject)
.ensureFilesWritable(VfsUtilCore.toVirtualFileArray(readOnlyFiles));
}
if (hasReadOnlyUsages(selectedUsages)) {
int result =
Messages.showOkCancelDialog(
replaceContext.getUsageView().getComponent(),
FindBundle.message("find.replace.occurrences.in.read.only.files.prompt"),
FindBundle.message("find.replace.occurrences.in.read.only.files.title"),
Messages.getWarningIcon());
if (result != Messages.OK) {
return false;
}
}
return true;
}
public boolean execute(boolean drop, boolean isInsideStartFinishGroup) {
if (!myUndoableGroup.isUndoable()) {
reportCannotUndo(
CommonBundle.message("cannot.undo.error.contains.nonundoable.changes.message"),
myUndoableGroup.getAffectedDocuments());
return false;
}
Set<DocumentReference> clashing = getStackHolder().collectClashingActions(myUndoableGroup);
if (!clashing.isEmpty()) {
reportCannotUndo(
CommonBundle.message("cannot.undo.error.other.affected.files.changed.message"), clashing);
return false;
}
if (!isInsideStartFinishGroup && myUndoableGroup.shouldAskConfirmation(isRedo())) {
if (!askUser()) return false;
} else {
if (restore(getBeforeState())) {
setBeforeState(new EditorAndState(myEditor, myEditor.getState(FileEditorStateLevel.UNDO)));
return true;
}
}
Collection<VirtualFile> readOnlyFiles = collectReadOnlyAffectedFiles();
if (!readOnlyFiles.isEmpty()) {
final Project project = myManager.getProject();
final VirtualFile[] files = VfsUtil.toVirtualFileArray(readOnlyFiles);
if (project == null) {
return false;
}
final ReadonlyStatusHandler.OperationStatus operationStatus =
ReadonlyStatusHandler.getInstance(project).ensureFilesWritable(files);
if (operationStatus.hasReadonlyFiles()) {
return false;
}
}
Collection<Document> readOnlyDocuments = collectReadOnlyDocuments();
if (!readOnlyDocuments.isEmpty()) {
for (Document document : readOnlyDocuments) {
document.fireReadOnlyModificationAttempt();
}
return false;
}
getStackHolder().removeFromStacks(myUndoableGroup);
if (!drop) {
getReverseStackHolder().addToStacks(myUndoableGroup);
}
performAction();
restore(getAfterState());
return true;
}
protected void setToBeShown(boolean value, boolean onOk) {
if (onOk) {
((ReadonlyStatusHandlerImpl) ReadonlyStatusHandler.getInstance(myProject))
.getState()
.SHOW_DIALOG =
value;
}
}
private boolean checkReadonlyUsages() {
final Set<VirtualFile> readOnlyUsages = getReadOnlyUsagesFiles();
return readOnlyUsages.isEmpty()
|| !ReadonlyStatusHandler.getInstance(myProject)
.ensureFilesWritable(VfsUtil.toVirtualFileArray(readOnlyUsages))
.hasReadonlyFiles();
}
@Override
public boolean deannotate(
@NotNull final PsiModifierListOwner listOwner, @NotNull final String annotationFQN) {
try {
final List<XmlFile> files = findExternalAnnotationsXmlFiles(listOwner);
if (files == null) {
return false;
}
for (XmlFile file : files) {
if (!file.isValid()) {
continue;
}
final XmlDocument document = file.getDocument();
if (document == null) {
continue;
}
final XmlTag rootTag = document.getRootTag();
if (rootTag == null) {
continue;
}
final String externalName = getExternalName(listOwner, false);
final String oldExternalName = getNormalizedExternalName(listOwner);
for (final XmlTag tag : rootTag.getSubTags()) {
final String className = tag.getAttributeValue("name");
if (!Comparing.strEqual(className, externalName)
&& !Comparing.strEqual(className, oldExternalName)) {
continue;
}
for (XmlTag annotationTag : tag.getSubTags()) {
if (!Comparing.strEqual(annotationTag.getAttributeValue("name"), annotationFQN)) {
continue;
}
if (ReadonlyStatusHandler.getInstance(myPsiManager.getProject())
.ensureFilesWritable(file.getVirtualFile())
.hasReadonlyFiles()) {
return false;
}
try {
annotationTag.delete();
if (tag.getSubTags().length == 0) {
tag.delete();
}
} catch (IncorrectOperationException e) {
LOG.error(e);
}
return true;
}
return false;
}
}
return false;
} finally {
dropCache();
}
}
private static boolean clearReadOnly(final Project project, final File dstFile) {
//noinspection EmptyCatchBlock
final URL url;
try {
url = dstFile.toURL();
} catch (MalformedURLException e) {
return true;
}
final VirtualFile vfile = VfsUtil.findFileByURL(url);
return vfile == null
|| !ReadonlyStatusHandler.getInstance(project)
.ensureFilesWritable(vfile)
.hasReadonlyFiles();
}
private void doReplaceSelected(final ReplaceContext replaceContext) {
final Set<Usage> selectedUsages = replaceContext.getUsageView().getSelectedUsages();
if (selectedUsages == null) {
return;
}
Set<VirtualFile> readOnlyFiles = null;
for (final Usage usage : selectedUsages) {
final VirtualFile file = ((UsageInFile) usage).getFile();
if (file != null && !file.isWritable()) {
if (readOnlyFiles == null) readOnlyFiles = new HashSet<VirtualFile>();
readOnlyFiles.add(file);
}
}
if (readOnlyFiles != null) {
ReadonlyStatusHandler.getInstance(myProject)
.ensureFilesWritable(VfsUtilCore.toVirtualFileArray(readOnlyFiles));
}
if (hasReadOnlyUsages(selectedUsages)) {
int result =
Messages.showOkCancelDialog(
replaceContext.getUsageView().getComponent(),
FindBundle.message("find.replace.occurrences.in.read.only.files.prompt"),
FindBundle.message("find.replace.occurrences.in.read.only.files.title"),
Messages.getWarningIcon());
if (result != 0) {
return;
}
}
CommandProcessor.getInstance()
.executeCommand(
myProject,
new Runnable() {
@Override
public void run() {
final boolean success = doReplace(replaceContext, selectedUsages);
final UsageView usageView = replaceContext.getUsageView();
if (closeUsageViewIfEmpty(usageView, success)) return;
usageView.getComponent().requestFocus();
}
},
FindBundle.message("find.replace.command"),
null);
}
public void run() {
final ReadonlyStatusHandler roHandler = ReadonlyStatusHandler.getInstance(myField.getProject());
final PsiFile psiFile = myField.getContainingFile();
if (psiFile == null) return;
final ReadonlyStatusHandler.OperationStatus status =
roHandler.ensureFilesWritable(psiFile.getVirtualFile());
if (status.hasReadonlyFiles()) return;
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
public void run() {
CommandProcessor.getInstance()
.executeCommand(
myField.getProject(),
new Runnable() {
public void run() {
try {
final PsiManager manager = myField.getManager();
myField
.getTypeElement()
.replace(
JavaPsiFacade.getInstance(manager.getProject())
.getElementFactory()
.createTypeElement(myNewType));
} catch (final IncorrectOperationException e) {
ApplicationManager.getApplication()
.invokeLater(
new Runnable() {
public void run() {
Messages.showErrorDialog(
myEditor,
UIDesignerBundle.message(
"error.cannot.change.field.type",
myField.getName(),
e.getMessage()),
CommonBundle.getErrorTitle());
}
});
}
}
},
getName(),
null);
}
});
}
private void commitToOriginal(final DocumentEvent e) {
VirtualFile origVirtualFile = PsiUtilCore.getVirtualFile(myNewFile.getContext());
myCommittingToOriginal = true;
try {
if (origVirtualFile == null
|| !ReadonlyStatusHandler.getInstance(myProject)
.ensureFilesWritable(origVirtualFile)
.hasReadonlyFiles()) {
PostprocessReformattingAspect.getInstance(myProject)
.disablePostprocessFormattingInside(
() -> {
if (myAltFullRange != null) {
altCommitToOriginal(e);
return;
}
commitToOriginalInner();
});
PsiDocumentManager.getInstance(myProject)
.doPostponedOperationsAndUnblockDocument(myOrigDocument);
}
} finally {
myCommittingToOriginal = false;
}
}
private boolean processExistingExternalAnnotations(
@NotNull final PsiModifierListOwner listOwner,
@NotNull final String annotationFQN,
@NotNull final Processor<XmlTag> annotationTagProcessor) {
try {
final List<XmlFile> files = findExternalAnnotationsXmlFiles(listOwner);
if (files == null) {
notifyAfterAnnotationChanging(listOwner, annotationFQN, false);
return false;
}
boolean processedAnything = false;
for (final XmlFile file : files) {
if (!file.isValid()) {
continue;
}
if (ReadonlyStatusHandler.getInstance(myPsiManager.getProject())
.ensureFilesWritable(file.getVirtualFile())
.hasReadonlyFiles()) {
continue;
}
final XmlDocument document = file.getDocument();
if (document == null) {
continue;
}
final XmlTag rootTag = document.getRootTag();
if (rootTag == null) {
continue;
}
final String externalName = getExternalName(listOwner, false);
final String oldExternalName = getNormalizedExternalName(listOwner);
for (final XmlTag tag : rootTag.getSubTags()) {
final String className = StringUtil.unescapeXml(tag.getAttributeValue("name"));
if (!Comparing.strEqual(className, externalName)
&& !Comparing.strEqual(className, oldExternalName)) {
continue;
}
for (final XmlTag annotationTag : tag.getSubTags()) {
if (!Comparing.strEqual(annotationTag.getAttributeValue("name"), annotationFQN)) {
continue;
}
CommandProcessor.getInstance()
.executeCommand(
myPsiManager.getProject(),
new Runnable() {
@Override
public void run() {
try {
annotationTagProcessor.process(annotationTag);
commitChanges(file);
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
},
ExternalAnnotationsManagerImpl.class.getName(),
null);
processedAnything = true;
}
}
}
notifyAfterAnnotationChanging(listOwner, annotationFQN, processedAnything);
return processedAnything;
} finally {
dropCache();
}
}
protected boolean isToBeShown() {
return ((ReadonlyStatusHandlerImpl) ReadonlyStatusHandler.getInstance(myProject))
.getState()
.SHOW_DIALOG;
}
@NotNull
@Override
public Collection<BooleanOptionDescription> getOptions(@Nullable Project project) {
if (project == null || ProjectLevelVcsManager.getInstance(project).getAllVcss().length == 0) {
return Collections.emptyList();
}
VcsConfiguration vcs = VcsConfiguration.getInstance(project);
if (vcs == null) {
return Collections.emptyList();
}
ArrayList<BooleanOptionDescription> options = new ArrayList<>();
String id = "project.propVCSSupport.Mappings"; // process Version Control settings
options.add(
option(vcs, id, "Limit history by " + vcs.MAXIMUM_HISTORY_ROWS + " rows", "LIMIT_HISTORY"));
options.add(
option(vcs, id, "Show directories with changed descendants", "SHOW_DIRTY_RECURSIVELY"));
options.add(
option(
vcs, id, VcsBundle.message("vcs.shelf.store.base.content"), "INCLUDE_TEXT_INTO_SHELF"));
VcsContentAnnotationSettings vcsCA = VcsContentAnnotationSettings.getInstance(project);
if (vcsCA != null) {
options.add(
option(
vcsCA,
id,
"Show changed in last " + vcsCA.getLimitDays() + " days",
"isShow",
"setShow"));
}
options.add(option(vcs, id, "Notify about VCS root errors", "SHOW_VCS_ERROR_NOTIFICATIONS"));
options.add(
option(
vcs,
id,
"Commit message right margin " + vcs.COMMIT_MESSAGE_MARGIN_SIZE + " columns",
"USE_COMMIT_MESSAGE_MARGIN"));
options.add(
option(
vcs,
id,
ApplicationBundle.message("checkbox.wrap.typing.on.right.margin"),
"WRAP_WHEN_TYPING_REACHES_RIGHT_MARGIN"));
id = "project.propVCSSupport.Confirmation"; // process Version Control / Confirmation settings
ReadonlyStatusHandler vcsROSH = ReadonlyStatusHandler.getInstance(project);
if (vcsROSH instanceof ReadonlyStatusHandlerImpl) {
options.add(
option(
((ReadonlyStatusHandlerImpl) vcsROSH).getState(),
id,
"Show \"Clear Read-only Status\" Dialog",
"SHOW_DIALOG"));
}
options.add(
option(
vcs,
id,
"Confirmation: Suggest to move uncommitted changes to another changelist",
"OFFER_MOVE_TO_ANOTHER_CHANGELIST_ON_PARTIAL_COMMIT"));
options.add(
option(
vcs, id, "Confirmation: Force non-empty checkin comments", "FORCE_NON_EMPTY_COMMENT"));
options.add(
option(
vcs, id, "Confirmation: Clear initial commit message", "CLEAR_INITIAL_COMMIT_MESSAGE"));
id = "project.propVCSSupport.Background"; // process Version Control / Background settings
options.add(
option(vcs, id, "Perform in background: update from VCS", "PERFORM_UPDATE_IN_BACKGROUND"));
options.add(
option(vcs, id, "Perform in background: commit to VCS", "PERFORM_COMMIT_IN_BACKGROUND"));
options.add(
option(
vcs, id, "Perform in background: checkout from VCS", "PERFORM_CHECKOUT_IN_BACKGROUND"));
options.add(
option(vcs, id, "Perform in background: Edit/Checkout", "PERFORM_EDIT_IN_BACKGROUND"));
options.add(
option(vcs, id, "Perform in background: Add/Remove", "PERFORM_ADD_REMOVE_IN_BACKGROUND"));
options.add(option(vcs, id, "Perform in background: revert", "PERFORM_ROLLBACK_IN_BACKGROUND"));
if (!project.isDefault()) {
// process Version Control / Changelist Conflicts settings
options.add(
tracker(project, "Changelists: Enable changelist conflict tracking", "TRACKING_ENABLED"));
options.add(tracker(project, "Changelists: Show conflict resolving dialog", "SHOW_DIALOG"));
options.add(
tracker(project, "Changelists: Highlight files with conflicts", "HIGHLIGHT_CONFLICTS"));
options.add(
tracker(
project,
"Changelists: Highlight files from non-active changelists",
"HIGHLIGHT_NON_ACTIVE_CHANGELIST"));
}
return Collections.unmodifiableCollection(options);
}
private ReadonlyStatusHandler.OperationStatus getReadOnlyFilesStatus(
@NotNull final List<VirtualFile> filesToMakeWritable) {
final VirtualFile[] fileArray = VfsUtilCore.toVirtualFileArray(filesToMakeWritable);
return ReadonlyStatusHandler.getInstance(myProject).ensureFilesWritable(fileArray);
}
