private void processDeletedFiles(Project project) {
final List<Pair<FilePath, WorkingCopyFormat>> deletedFiles =
new ArrayList<Pair<FilePath, WorkingCopyFormat>>();
final Collection<FilePath> filesToProcess = new ArrayList<FilePath>();
List<VcsException> exceptions = new ArrayList<VcsException>();
final AbstractVcsHelper vcsHelper = AbstractVcsHelper.getInstance(project);
try {
fillDeletedFiles(project, deletedFiles, filesToProcess);
if (deletedFiles.isEmpty() && filesToProcess.isEmpty() || myUndoingMove) return;
SvnVcs vcs = SvnVcs.getInstance(project);
final VcsShowConfirmationOption.Value value = vcs.getDeleteConfirmation().getValue();
if (value != VcsShowConfirmationOption.Value.DO_NOTHING_SILENTLY) {
if (!deletedFiles.isEmpty()) {
final Collection<FilePath> confirmed =
promptAboutDeletion(deletedFiles, vcs, value, vcsHelper);
if (confirmed != null) {
filesToProcess.addAll(confirmed);
}
}
if (filesToProcess != null && !filesToProcess.isEmpty()) {
runInBackground(
project,
"Deleting files from Subversion",
createDeleteRunnable(project, vcs, filesToProcess, exceptions));
}
final List<FilePath> deletedFilesFiles =
ObjectsConvertor.convert(
deletedFiles,
new Convertor<Pair<FilePath, WorkingCopyFormat>, FilePath>() {
@Override
public FilePath convert(Pair<FilePath, WorkingCopyFormat> o) {
return o.getFirst();
}
});
for (FilePath file : deletedFilesFiles) {
final FilePath parent = file.getParentPath();
if (parent != null) {
myFilesToRefresh.add(parent.getVirtualFile());
}
}
if (filesToProcess != null) {
deletedFilesFiles.removeAll(filesToProcess);
}
for (FilePath file : deletedFilesFiles) {
FileUtil.delete(file.getIOFile());
}
}
} catch (SVNException e) {
exceptions.add(new VcsException(e));
}
if (!exceptions.isEmpty()) {
vcsHelper.showErrors(exceptions, SvnBundle.message("delete.files.errors.title"));
}
}
private Collection<VirtualFile> promptAboutAddition(
SvnVcs vcs,
List<VirtualFile> addedVFiles,
VcsShowConfirmationOption.Value value,
AbstractVcsHelper vcsHelper) {
Collection<VirtualFile> filesToProcess;
if (value == VcsShowConfirmationOption.Value.DO_ACTION_SILENTLY) {
filesToProcess = addedVFiles;
} else {
final String singleFilePrompt;
if (addedVFiles.size() == 1 && addedVFiles.get(0).isDirectory()) {
singleFilePrompt = SvnBundle.getString("confirmation.text.add.dir");
} else {
singleFilePrompt = SvnBundle.getString("confirmation.text.add.file");
}
filesToProcess =
vcsHelper.selectFilesToProcess(
addedVFiles,
SvnBundle.message("confirmation.title.add.multiple.files"),
null,
SvnBundle.message("confirmation.title.add.file"),
singleFilePrompt,
vcs.getAddConfirmation());
}
return filesToProcess;
}
@Override
public void run(ContinuationContext context) {
final StringBuilder message =
new StringBuilder().append("Theirs changes merged for ").append(myOldPresentation);
VcsBalloonProblemNotifier.showOverChangesView(
myVcs.getProject(), message.toString(), MessageType.INFO);
if (!myWarnings.isEmpty()) {
AbstractVcsHelper.getInstance(myVcs.getProject())
.showErrors(myWarnings, TreeConflictRefreshablePanel.TITLE);
}
}
private void doRun() {
myIndicator = ProgressManager.getInstance().getProgressIndicator();
final List<Change> changesToRefresh = new ArrayList<Change>();
try {
ChangesUtil.processChangesByVcs(
myProject,
myChanges,
new ChangesUtil.PerVcsProcessor<Change>() {
public void process(AbstractVcs vcs, List<Change> changes) {
final RollbackEnvironment environment = vcs.getRollbackEnvironment();
if (environment != null) {
changesToRefresh.addAll(changes);
if (myIndicator != null) {
myIndicator.setText(vcs.getDisplayName() + ": performing rollback...");
myIndicator.setIndeterminate(false);
myIndicator.checkCanceled();
}
environment.rollbackChanges(
changes,
myExceptions,
new RollbackProgressModifier(changes.size(), myIndicator));
if (myIndicator != null) {
myIndicator.setText2("");
myIndicator.checkCanceled();
}
if (myExceptions.isEmpty() && myDeleteLocallyAddedFiles) {
deleteAddedFilesLocally(changes);
}
}
}
});
} catch (ProcessCanceledException e) {
// still do refresh
}
if (myIndicator != null) {
myIndicator.startNonCancelableSection();
myIndicator.setIndeterminate(true);
myIndicator.setText2("");
myIndicator.setText(VcsBundle.message("progress.text.synchronizing.files"));
}
doRefresh(myProject, changesToRefresh);
AbstractVcsHelper.getInstance(myProject)
.showErrors(myExceptions, VcsBundle.message("changes.action.rollback.text"));
}
private void processAddedFiles(Project project) {
SvnVcs vcs = SvnVcs.getInstance(project);
List<VirtualFile> addedVFiles = new ArrayList<VirtualFile>();
Map<VirtualFile, File> copyFromMap = new HashMap<VirtualFile, File>();
final Set<VirtualFile> recursiveItems = new HashSet<VirtualFile>();
fillAddedFiles(project, vcs, addedVFiles, copyFromMap, recursiveItems);
if (addedVFiles.isEmpty()) return;
final VcsShowConfirmationOption.Value value = vcs.getAddConfirmation().getValue();
if (value != VcsShowConfirmationOption.Value.DO_NOTHING_SILENTLY) {
final AbstractVcsHelper vcsHelper = AbstractVcsHelper.getInstance(project);
final Collection<VirtualFile> filesToProcess =
promptAboutAddition(vcs, addedVFiles, value, vcsHelper);
if (filesToProcess != null && !filesToProcess.isEmpty()) {
final List<VcsException> exceptions = new ArrayList<VcsException>();
runInBackground(
project,
"Adding files to Subversion",
createAdditionRunnable(project, vcs, copyFromMap, filesToProcess, exceptions));
if (!exceptions.isEmpty()) {
vcsHelper.showErrors(exceptions, SvnBundle.message("add.files.errors.title"));
}
}
}
}
void commandFinished(final Project project) {
checkOverwrites(project);
if (myAddedFiles.containsKey(project)) {
processAddedFiles(project);
}
processMovedFiles(project);
if (myDeletedFiles.containsKey(project)) {
processDeletedFiles(project);
}
final List<VcsException> exceptionList = myMoveExceptions.get(project);
if (exceptionList != null && !exceptionList.isEmpty()) {
AbstractVcsHelper.getInstance(project)
.showErrors(exceptionList, SvnBundle.message("move.files.errors.title"));
}
if (!myFilesToRefresh.isEmpty()) {
refreshFiles(project);
}
}
private Collection<FilePath> chooseBinaryFiles(List<Change> converted, Set<FilePath> paths) {
String singleMessage = "";
if (paths.size() == 1) {
final Change change = converted.get(0);
final FileStatus status = change.getFileStatus();
final FilePath path = ChangesUtil.getFilePath(change);
final String stringPath = TreeConflictRefreshablePanel.filePath(path);
if (FileStatus.DELETED.equals(status)) {
singleMessage = "Delete binary file " + stringPath + " (according to theirs changes)?";
} else if (FileStatus.ADDED.equals(status)) {
singleMessage = "Create binary file " + stringPath + " (according to theirs changes)?";
} else {
singleMessage =
"Apply changes to binary file " + stringPath + " (according to theirs changes)?";
}
}
return AbstractVcsHelper.getInstance(myVcs.getProject())
.selectFilePathsToProcess(
new ArrayList<FilePath>(paths),
TreeConflictRefreshablePanel.TITLE,
"Select binary files to patch",
TreeConflictRefreshablePanel.TITLE,
singleMessage,
new VcsShowConfirmationOption() {
@Override
public Value getValue() {
return null;
}
@Override
public void setValue(Value value) {}
@Override
public boolean isPersistent() {
return false;
}
});
}
private Collection<FilePath> promptAboutDeletion(
List<Pair<FilePath, WorkingCopyFormat>> deletedFiles,
SvnVcs vcs,
VcsShowConfirmationOption.Value value,
AbstractVcsHelper vcsHelper) {
final Convertor<Pair<FilePath, WorkingCopyFormat>, FilePath> convertor =
new Convertor<Pair<FilePath, WorkingCopyFormat>, FilePath>() {
@Override
public FilePath convert(Pair<FilePath, WorkingCopyFormat> o) {
return o.getFirst();
}
};
Collection<FilePath> filesToProcess;
if (value == VcsShowConfirmationOption.Value.DO_ACTION_SILENTLY) {
filesToProcess = ObjectsConvertor.convert(deletedFiles, convertor);
} else {
final String singleFilePrompt;
if (deletedFiles.size() == 1 && deletedFiles.get(0).getFirst().isDirectory()) {
singleFilePrompt =
WorkingCopyFormat.ONE_DOT_SEVEN.equals(deletedFiles.get(0).getSecond())
? SvnBundle.getString("confirmation.text.delete.dir.17")
: SvnBundle.getString("confirmation.text.delete.dir");
} else {
singleFilePrompt = SvnBundle.getString("confirmation.text.delete.file");
}
final Collection<FilePath> files =
vcsHelper.selectFilePathsToProcess(
ObjectsConvertor.convert(deletedFiles, convertor),
SvnBundle.message("confirmation.title.delete.multiple.files"),
null,
SvnBundle.message("confirmation.title.delete.file"),
singleFilePrompt,
vcs.getDeleteConfirmation());
filesToProcess = files == null ? null : new ArrayList<FilePath>(files);
}
return filesToProcess;
}
public void actionPerformed(AnActionEvent e) {
final Project project = e.getData(CommonDataKeys.PROJECT);
VirtualFile vFile = e.getData(CommonDataKeys.VIRTUAL_FILE);
assert vFile != null;
AbstractVcs vcs = ProjectLevelVcsManager.getInstance(project).getVcsFor(vFile);
assert vcs != null;
final CommittedChangesProvider provider = vcs.getCommittedChangesProvider();
assert provider != null;
ChangeBrowserSettings settings = provider.createDefaultSettings();
CommittedChangesFilterDialog dlg =
new CommittedChangesFilterDialog(project, provider.createFilterUI(true), settings);
dlg.show();
if (!dlg.isOK()) return;
int maxCount = 0;
if (!settings.isAnyFilterSpecified()) {
int rc =
Messages.showYesNoCancelDialog(
project,
VcsBundle.message("browse.changes.no.filter.prompt"),
VcsBundle.message("browse.changes.title"),
VcsBundle.message("browse.changes.show.recent.button"),
VcsBundle.message("browse.changes.show.all.button"),
CommonBundle.getCancelButtonText(),
Messages.getQuestionIcon());
if (rc == Messages.CANCEL) {
return;
}
if (rc == Messages.YES) {
maxCount = 50;
}
}
AbstractVcsHelper.getInstance(project)
.openCommittedChangesTab(vcs, vFile, settings, maxCount, null);
}
