@CalledInAwt
public static void refreshPassedFilesAndMoveToChangelist(
@NotNull final Project project,
final Collection<FilePath> directlyAffected,
final Collection<VirtualFile> indirectlyAffected,
final Consumer<Collection<FilePath>> targetChangelistMover) {
final LocalFileSystem lfs = LocalFileSystem.getInstance();
for (FilePath filePath : directlyAffected) {
lfs.refreshAndFindFileByIoFile(filePath.getIOFile());
}
if (project.isDisposed()) return;
final ChangeListManager changeListManager = ChangeListManager.getInstance(project);
if (!directlyAffected.isEmpty() && targetChangelistMover != null) {
changeListManager.invokeAfterUpdate(
new Runnable() {
@Override
public void run() {
targetChangelistMover.consume(directlyAffected);
}
},
InvokeAfterUpdateMode.SYNCHRONOUS_CANCELLABLE,
VcsBundle.message("change.lists.manager.move.changes.to.list"),
new Consumer<VcsDirtyScopeManager>() {
@Override
public void consume(final VcsDirtyScopeManager vcsDirtyScopeManager) {
markDirty(vcsDirtyScopeManager, directlyAffected, indirectlyAffected);
}
},
null);
} else {
markDirty(VcsDirtyScopeManager.getInstance(project), directlyAffected, indirectlyAffected);
}
}
@Override
public void rebuildList() {
if (myInRebuildList) return;
try {
myInRebuildList = true;
if (myChangesToDisplay == null) {
// changes set not fixed === local changes
final ChangeListManager manager = ChangeListManager.getInstance(myProject);
myChangeListsMap = new HashMap<Change, LocalChangeList>();
final List<LocalChangeList> lists = manager.getChangeListsCopy();
Collection<Change> allChanges = new ArrayList<Change>();
for (LocalChangeList list : lists) {
final Collection<Change> changes = list.getChanges();
allChanges.addAll(changes);
for (Change change : changes) {
myChangeListsMap.put(change, list);
}
}
myAllChanges = allChanges;
// refresh selected list also
updateListsInChooser();
}
super.rebuildList();
if (myRebuildListListener != null) {
myRebuildListListener.run();
}
} finally {
myInRebuildList = false;
}
}
@Nullable
private static Consumer<Collection<FilePath>> createMover(
final Project project, final LocalChangeList targetChangeList) {
final ChangeListManager clm = ChangeListManager.getInstance(project);
if (targetChangeList == null || clm.getDefaultListName().equals(targetChangeList.getName()))
return null;
return new FilesMover(clm, targetChangeList);
}
@Override
public boolean fileIsUnderVcs(FilePath path) {
final ChangeListManager clManager = ChangeListManager.getInstance(myProject);
final VirtualFile file = path.getVirtualFile();
if (file == null) {
return false;
}
return !SvnStatusUtil.isIgnoredInAnySense(clManager, file) && !clManager.isUnversioned(file);
}
public void doRollback(
final Collection<Change> changes,
final boolean deleteLocallyAddedFiles,
@Nullable final Runnable afterVcsRefreshInAwt,
@Nullable final String localHistoryActionName) {
final ChangeListManager changeListManager = ChangeListManager.getInstance(myProject);
final Runnable notifier = changeListManager.prepareForChangeDeletion(changes);
final Runnable afterRefresh =
new Runnable() {
public void run() {
changeListManager.invokeAfterUpdate(
new Runnable() {
public void run() {
notifier.run();
if (afterVcsRefreshInAwt != null) {
afterVcsRefreshInAwt.run();
}
}
},
InvokeAfterUpdateMode.SILENT,
"Refresh change lists after update",
ModalityState.current());
}
};
final Runnable rollbackAction =
new MyRollbackRunnable(
changes, deleteLocallyAddedFiles, afterRefresh, localHistoryActionName);
if (ApplicationManager.getApplication().isDispatchThread()) {
ProgressManager.getInstance()
.run(
new Task.Backgroundable(
myProject,
VcsBundle.message("changes.action.rollback.text"),
true,
new PerformInBackgroundOption() {
public boolean shouldStartInBackground() {
return VcsConfiguration.getInstance(myProject).PERFORM_ROLLBACK_IN_BACKGROUND;
}
public void processSentToBackground() {
VcsConfiguration.getInstance(myProject).PERFORM_ROLLBACK_IN_BACKGROUND = true;
}
}) {
public void run(@NotNull ProgressIndicator indicator) {
rollbackAction.run();
}
});
} else {
rollbackAction.run();
}
((ChangeListManagerImpl) changeListManager).showLocalChangesInvalidated();
}
@Test
public void testDeletion() throws Exception {
final File f = new File(myClientRoot, "f.txt");
f.createNewFile();
final VirtualFile vf = myLFS.refreshAndFindFileByIoFile(f);
myChangeListManager.ensureUpToDate(false);
((ChangeListManagerImpl) myChangeListManager).getUnversionedFiles().contains(vf);
FileUtil.delete(f);
myWorkingCopyDir.refresh(false, true);
myChangeListManager.ensureUpToDate(false);
((ChangeListManagerImpl) myChangeListManager).getUnversionedFiles().isEmpty();
}
@Override
public void consume(Collection<FilePath> directlyAffected) {
List<Change> changes = new ArrayList<>();
for (FilePath file : directlyAffected) {
final Change change = myChangeListManager.getChange(file);
if (change != null) {
changes.add(change);
}
}
myChangeListManager.moveChangesTo(
myTargetChangeList, changes.toArray(new Change[changes.size()]));
}
public void projectOpened() {
TaskProjectConfiguration projectConfiguration = getProjectConfiguration();
servers:
for (TaskProjectConfiguration.SharedServer server : projectConfiguration.servers) {
if (server.type == null || server.url == null) {
continue;
}
for (TaskRepositoryType<?> repositoryType : TaskRepositoryType.getRepositoryTypes()) {
if (repositoryType.getName().equals(server.type)) {
for (TaskRepository repository : myRepositories) {
if (!repositoryType.equals(repository.getRepositoryType())) {
continue;
}
if (server.url.equals(repository.getUrl())) {
continue servers;
}
}
TaskRepository repository = repositoryType.createRepository();
repository.setUrl(server.url);
myRepositories.add(repository);
}
}
}
myContextManager.pack(200, 50);
// make sure the task is associated with default changelist
LocalTask defaultTask = findTask(LocalTaskImpl.DEFAULT_TASK_ID);
LocalChangeList defaultList = myChangeListManager.findChangeList(LocalChangeList.DEFAULT_NAME);
if (defaultList != null && defaultTask != null) {
ChangeListInfo listInfo = new ChangeListInfo(defaultList);
if (!defaultTask.getChangeLists().contains(listInfo)) {
defaultTask.addChangelist(listInfo);
}
}
// remove already not existing changelists from tasks changelists
for (LocalTask localTask : getLocalTasks()) {
for (Iterator<ChangeListInfo> iterator = localTask.getChangeLists().iterator();
iterator.hasNext(); ) {
final ChangeListInfo changeListInfo = iterator.next();
if (myChangeListManager.getChangeList(changeListInfo.id) == null) {
iterator.remove();
}
}
}
myChangeListManager.addChangeListListener(myChangeListListener);
}
private void createChangeList(LocalTask task, String name, @Nullable String comment) {
LocalChangeList changeList = myChangeListManager.findChangeList(name);
if (changeList == null) {
changeList = myChangeListManager.addChangeList(name, comment);
} else {
final LocalTask associatedTask = getAssociatedTask(changeList);
if (associatedTask != null) {
associatedTask.removeChangelist(new ChangeListInfo(changeList));
}
changeList.setComment(comment);
}
task.addChangelist(new ChangeListInfo(changeList));
myChangeListManager.setDefaultChangeList(changeList);
}
@Override
public void deactivate() {
FrameStateManager.getInstance().removeListener(myFrameStateListener);
final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(myProject);
if (myVcsListener != null) {
vcsManager.removeVcsListener(myVcsListener);
}
if (myEntriesFileListener != null) {
VirtualFileManager.getInstance().removeVirtualFileListener(myEntriesFileListener);
}
SvnApplicationSettings.getInstance().svnDeactivated();
if (myCommittedChangesProvider != null) {
myCommittedChangesProvider.deactivate();
}
if (myChangeListListener != null && !myProject.isDefault()) {
ChangeListManager.getInstance(myProject).removeChangeListListener(myChangeListListener);
}
vcsManager.removeVcsListener(myRootsToWorkingCopies);
myRootsToWorkingCopies.clear();
myAuthNotifier.stop();
myAuthNotifier.clear();
mySvnBranchPointsCalculator.deactivate();
mySvnBranchPointsCalculator = null;
myWorkingCopiesContent.deactivate();
myLoadedBranchesStorage.deactivate();
myPool.dispose();
myPool = null;
}
/** call in setUp */
public DuringChangeListManagerUpdateTestScheme(final Project project, final String tmpDirPath) {
final MockAbstractVcs vcs = new MockAbstractVcs(project);
myChangeProvider = new MockDelayingChangeProvider();
vcs.setChangeProvider(myChangeProvider);
final File mockVcsRoot = new File(tmpDirPath, "mock");
mockVcsRoot.mkdir();
final VirtualFile vRoot = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(mockVcsRoot);
final ProjectLevelVcsManagerImpl projectLevelVcsManager =
(ProjectLevelVcsManagerImpl) ProjectLevelVcsManager.getInstance(project);
projectLevelVcsManager.registerVcs(vcs);
// projectLevelVcsManager.setDirectoryMapping(mockVcsRoot.getAbsolutePath(), vcs.getName());
final ArrayList<VcsDirectoryMapping> list =
new ArrayList<VcsDirectoryMapping>(projectLevelVcsManager.getDirectoryMappings());
list.add(new VcsDirectoryMapping(vRoot.getPath(), vcs.getName()));
projectLevelVcsManager.setDirectoryMappings(list);
AbstractVcs vcsFound = projectLevelVcsManager.findVcsByName(vcs.getName());
final VirtualFile[] roots = projectLevelVcsManager.getRootsUnderVcs(vcsFound);
assert roots.length == 1
: Arrays.asList(roots)
+ "; "
+ vcs.getName()
+ "; "
+ Arrays.toString(AllVcses.getInstance(project).getAll());
myDirtyScopeManager = VcsDirtyScopeManager.getInstance(project);
myClManager = ChangeListManager.getInstance(project);
}
public ChangesBrowserChangeListNode(
Project project, ChangeList userObject, final ChangeListRemoteState changeListRemoteState) {
super(userObject);
myChangeListRemoteState = changeListRemoteState;
myClManager = (ChangeListManagerEx) ChangeListManager.getInstance(project);
myDecorators = ComponentsPackage.getComponents(project, ChangeListDecorator.class);
}
@Override
public void run(ContinuationContext context) {
final ChangeListManager clManager = ChangeListManager.getInstance(myVcs.getProject());
final LocalChangeList changeList = clManager.getChangeList(myChange);
final ApplyPatchDifferentiatedDialog dialog =
new ApplyPatchDifferentiatedDialog(
myVcs.getProject(),
new TreeConflictApplyTheirsPatchExecutor(myVcs, context, myBaseForPatch),
Collections.<ApplyPatchExecutor>singletonList(
new ApplyPatchSaveToFileExecutor(myVcs.getProject(), myBaseForPatch)),
ApplyPatchMode.APPLY_PATCH_IN_MEMORY,
myTextPatches,
changeList);
context.suspend();
dialog.show();
}
public SvnVcs(
final Project project,
MessageBus bus,
SvnConfiguration svnConfiguration,
final SvnLoadedBrachesStorage storage) {
super(project, VCS_NAME);
myLoadedBranchesStorage = storage;
LOG.debug("ct");
myRootsToWorkingCopies = new RootsToWorkingCopies(this);
myConfiguration = svnConfiguration;
myAuthNotifier = new SvnAuthenticationNotifier(this);
dumpFileStatus(FileStatus.ADDED);
dumpFileStatus(FileStatus.DELETED);
dumpFileStatus(FileStatus.MERGE);
dumpFileStatus(FileStatus.MODIFIED);
dumpFileStatus(FileStatus.NOT_CHANGED);
dumpFileStatus(FileStatus.UNKNOWN);
dumpFileStatus(SvnFileStatus.REPLACED);
dumpFileStatus(SvnFileStatus.EXTERNAL);
dumpFileStatus(SvnFileStatus.OBSTRUCTED);
final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(project);
myAddConfirmation =
vcsManager.getStandardConfirmation(VcsConfiguration.StandardConfirmation.ADD, this);
myDeleteConfirmation =
vcsManager.getStandardConfirmation(VcsConfiguration.StandardConfirmation.REMOVE, this);
myCheckoutOptions =
vcsManager.getStandardOption(VcsConfiguration.StandardOption.CHECKOUT, this);
if (myProject.isDefault()) {
myChangeListListener = null;
myEntriesFileListener = null;
} else {
myEntriesFileListener = new SvnEntriesFileListener(project);
upgradeIfNeeded(bus);
myChangeListListener = new SvnChangelistListener(myProject, this);
myVcsListener =
new VcsListener() {
@Override
public void directoryMappingChanged() {
invokeRefreshSvnRoots(true);
}
};
}
myFrameStateListener =
project.isDefault()
? null
: new MyFrameStateListener(
ChangeListManager.getInstance(project), VcsDirtyScopeManager.getInstance(project));
myWorkingCopiesContent = new WorkingCopiesContent(this);
// remove used some time before old notification group ids
correctNotificationIds();
myChecker = new SvnExecutableChecker(myProject);
}
// todo terrible constructor
public MultipleChangeListBrowser(
Project project,
List<? extends ChangeList> changeLists,
List<Change> changes,
Disposable parentDisposable,
ChangeList initialListSelection,
boolean capableOfExcludingChanges,
boolean highlightProblems,
Runnable rebuildListListener,
@Nullable Runnable inclusionListener,
AnAction... additionalActions) {
super(
project,
changeLists,
changes,
initialListSelection,
capableOfExcludingChanges,
highlightProblems,
inclusionListener,
MyUseCase.LOCAL_CHANGES,
null);
myParentDisposable = parentDisposable;
myRebuildListListener = rebuildListListener;
myChangeListChooser = new ChangeListChooser(changeLists);
myHeaderPanel.add(myChangeListChooser, BorderLayout.EAST);
myShowingAllChangeLists =
Comparing.haveEqualElements(
changeLists, ChangeListManager.getInstance(project).getChangeLists());
ChangeListManager.getInstance(myProject).addChangeListListener(myChangeListListener);
myExtender = new Extender(project, this, additionalActions);
ActionManager actionManager = ActionManager.getInstance();
final AnAction moveAction = actionManager.getAction(IdeActions.MOVE_TO_ANOTHER_CHANGE_LIST);
actionManager.addAnActionListener(
new AnActionListener.Adapter() {
@Override
public void afterActionPerformed(
AnAction action, DataContext dataContext, AnActionEvent event) {
if (moveAction.equals(action)) {
rebuildList();
}
}
},
myParentDisposable);
}
@Nullable
private static Change[] loadFakeRevisions(final Project project, final Change[] changes) {
List<Change> matchingChanges = new ArrayList<Change>();
for (Change change : changes) {
matchingChanges.addAll(
ChangeListManager.getInstance(project).getChangesIn(ChangesUtil.getFilePath(change)));
}
return matchingChanges.toArray(new Change[matchingChanges.size()]);
}
public static void checkDeletedFilesAreInList(
final VirtualFile[] files, final String listName, final ChangeListManager manager) {
assert manager.findChangeList(listName) != null;
final LocalChangeList list = manager.findChangeList(listName);
final Collection<Change> changes = list.getChanges();
assert changes.size() == files.length : debugRealListContent(list);
for (Change change : changes) {
final File vf = change.getBeforeRevision().getFile().getIOFile();
boolean found = false;
for (VirtualFile vfile : files) {
final File file = new File(vfile.getPath());
if (file.equals(vf)) {
found = true;
break;
}
}
assert found == true : debugRealListContent(list);
}
}
public static void checkFilesAreInList(
final String listName, final ChangeListManager manager, final VirtualFile... files) {
assert manager.findChangeList(listName) != null;
final LocalChangeList list = manager.findChangeList(listName);
final Collection<Change> changes = list.getChanges();
assert changes.size() == files.length
: "size: " + changes.size() + " " + debugRealListContent(list);
for (Change change : changes) {
final VirtualFile vf = change.getAfterRevision().getFile().getVirtualFile();
boolean found = false;
for (VirtualFile file : files) {
if (file.equals(vf)) {
found = true;
break;
}
}
assert found == true : debugRealListContent(list);
}
}
private LocalTask restoreVcsContext(LocalTask task) {
if (!isVcsEnabled()) return task;
List<ChangeListInfo> changeLists = task.getChangeLists();
if (!changeLists.isEmpty()) {
ChangeListInfo info = changeLists.get(0);
LocalChangeList changeList = myChangeListManager.getChangeList(info.id);
if (changeList == null) {
changeList = myChangeListManager.addChangeList(info.name, info.comment);
info.id = changeList.getId();
}
myChangeListManager.setDefaultChangeList(changeList);
}
List<BranchInfo> branches = task.getBranches(false);
VcsTaskHandler.TaskInfo info = fromBranches(branches);
VcsTaskHandler[] handlers = VcsTaskHandler.getAllHandlers(myProject);
for (VcsTaskHandler handler : handlers) {
handler.switchToTask(info);
}
return task;
}
public void doTest(final Runnable runnable) {
final TimeoutWaiter waiter = new TimeoutWaiter();
final DuringUpdateTest test = new DuringUpdateTest(waiter, runnable);
myChangeProvider.setTest(test);
waiter.setControlled(test);
myDirtyScopeManager.markEverythingDirty();
myClManager.ensureUpToDate(false);
waiter.startTimeout();
if (test.getException() != null) {
test.getException().printStackTrace();
}
assert test.get() : (test.getException() == null ? null : test.getException().getMessage());
}
@Test
public void testGeneration() throws Exception {
for (int i = 0; i < 100; i++) {
final File f = new File(myClientRoot, "f" + i + ".txt");
f.createNewFile();
}
myWorkingCopyDir.refresh(false, true);
myChangeListManager.ensureUpToDate(false);
final List<VirtualFile> unversionedFiles =
((ChangeListManagerImpl) myChangeListManager).getUnversionedFiles();
final Pattern pattern = Pattern.compile("f([0-9])+\\.txt");
int cnt = 0;
for (VirtualFile unversionedFile : unversionedFiles) {
if (VfsUtil.isAncestor(myWorkingCopyDir, unversionedFile, true)) {
++cnt;
Assert.assertTrue(pattern.matcher(unversionedFile.getName()).matches());
}
}
Assert.assertEquals(100, cnt);
}
private void createChangelist(final ContinuationPause context) {
final ChangeListManager listManager = ChangeListManager.getInstance(myProject);
String name = myTitle;
int i = 1;
boolean updateDefaultList = false;
while (true) {
final LocalChangeList changeList = listManager.findChangeList(name);
if (changeList == null) {
final LocalChangeList newList = listManager.addChangeList(name, null);
listManager.setDefaultChangeList(newList);
updateDefaultList = true;
break;
}
if (changeList.getChanges().isEmpty()) {
if (!changeList.isDefault()) {
listManager.setDefaultChangeList(changeList);
updateDefaultList = true;
}
break;
}
name = myTitle + " (" + i + ")";
++i;
}
if (updateDefaultList) {
context.suspend();
listManager.invokeAfterUpdate(
new Runnable() {
public void run() {
context.ping();
}
},
InvokeAfterUpdateMode.BACKGROUND_NOT_CANCELLABLE_NOT_AWT,
"",
ModalityState.NON_MODAL);
}
}
@Override
public void setUp() throws Exception {
super.setUp();
myVcs = new MockAbstractVcs(getProject());
AllVcses.getInstance(getProject()).registerManually(myVcs);
myChangeListManager = (ChangeListManagerImpl) ChangeListManager.getInstance(getProject());
myTaskManager = (TaskManagerImpl) TaskManager.getManager(getProject());
ProjectLevelVcsManager.getInstance(getProject()).setDirectoryMapping("", myVcs.getName());
ProjectLevelVcsManager.getInstance(getProject()).hasActiveVcss();
myRepository = new TestRepository();
myRepository.setTasks(
new Task() {
@NotNull
@Override
public String getId() {
return "TEST-001";
}
@NotNull
@Override
public String getSummary() {
return "Summary";
}
@Override
public String getDescription() {
return null;
}
@NotNull
@Override
public Comment[] getComments() {
return new Comment[0];
}
@NotNull
@Override
public Icon getIcon() {
return TasksIcons.Unknown;
}
@NotNull
@Override
public TaskType getType() {
return TaskType.BUG;
}
@Override
public Date getUpdated() {
return null;
}
@Override
public Date getCreated() {
return null;
}
@Override
public boolean isClosed() {
return false;
}
@Override
public boolean isIssue() {
return true;
}
@Override
public String getIssueUrl() {
return null;
}
@Override
public TaskRepository getRepository() {
return myRepository;
}
});
myTaskManager.setRepositories(Collections.singletonList(myRepository));
}
@Before
public void setUp() throws Exception {
System.setProperty("svnkit.wc.17", "false");
UIUtil.invokeAndWaitIfNeeded(
new Runnable() {
@Override
public void run() {
try {
final IdeaTestFixtureFactory fixtureFactory =
IdeaTestFixtureFactory.getFixtureFactory();
myTempDirFixture = fixtureFactory.createTempDirTestFixture();
myTempDirFixture.setUp();
final File svnRoot = new File(myTempDirFixture.getTempDirPath(), "svnroot");
svnRoot.mkdir();
File pluginRoot = new File(PluginPathManager.getPluginHomePath("svn4idea"));
if (!pluginRoot.isDirectory()) {
// try standalone mode
Class aClass = SvnTestCase.class;
String rootPath =
PathManager.getResourceRoot(
aClass, "/" + aClass.getName().replace('.', '/') + ".class");
pluginRoot = new File(rootPath).getParentFile().getParentFile().getParentFile();
}
myClientBinaryPath = new File(pluginRoot, "testData/svn/bin");
ZipUtil.extract(new File(pluginRoot, "testData/svn/newrepo.zip"), svnRoot, null);
myWcRoot = new File(myTempDirFixture.getTempDirPath(), "wcroot");
myWcRoot.mkdir();
myRepoUrl = "file:///" + FileUtil.toSystemIndependentName(svnRoot.getPath());
initProject(myWcRoot);
activateVCS(SvnVcs17.VCS_NAME);
verify(runSvn("co", myRepoUrl, "."));
myGate = new MockChangeListManagerGate(ChangeListManager.getInstance(myProject));
myRefreshCopiesStub =
new AtomicSectionsAware() {
@Override
public void enter() {}
@Override
public void exit() {}
@Override
public boolean shouldExitAsap() {
return false;
}
@Override
public void checkShouldExit() throws ProcessCanceledException {}
};
final SvnVcs17 vcs = SvnVcs17.getInstance(myProject);
((StartupManagerImpl) StartupManager.getInstance(myProject))
.runPostStartupActivities();
// vcs.postStartup();
((SvnFileUrlMappingImpl17) vcs.getSvnFileUrlMapping()).realRefresh();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
});
// there should be kind-a waiting for after change list manager finds all changes and runs inner
// refresh of copies in the above method
ChangeListManager changeListManager = ChangeListManager.getInstance(myProject);
VcsDirtyScopeManager.getInstance(myProject).markEverythingDirty();
changeListManager.ensureUpToDate(false);
}
public void disposeComponent() {
if (myCacheRefreshTimer != null) {
myCacheRefreshTimer.stop();
}
myChangeListManager.removeChangeListListener(myChangeListListener);
}
public void actionPerformed(final AnActionEvent e) {
final Project project = e.getData(CommonDataKeys.PROJECT);
if (project == null) return;
if (ChangeListManager.getInstance(project).isFreezedWithNotification(null)) return;
final Change[] changes = e.getData(VcsDataKeys.CHANGES);
if (changes == null) return;
final boolean needsConvertion = checkIfThereAreFakeRevisions(project, changes);
final List<Change> changesInList = e.getData(VcsDataKeys.CHANGES_IN_LIST_KEY);
// this trick is essential since we are under some conditions to refresh changes;
// but we can only rely on callback after refresh
final Runnable performer =
new Runnable() {
public void run() {
Change[] convertedChanges;
if (needsConvertion) {
convertedChanges = loadFakeRevisions(project, changes);
} else {
convertedChanges = changes;
}
if (convertedChanges == null || convertedChanges.length == 0) {
return;
}
List<Change> changesInListCopy = changesInList;
int index = 0;
if (convertedChanges.length == 1) {
final Change selectedChange = convertedChanges[0];
ChangeList changeList =
((ChangeListManagerImpl) ChangeListManager.getInstance(project))
.getIdentityChangeList(selectedChange);
if (changeList != null) {
if (changesInListCopy == null) {
changesInListCopy = new ArrayList<Change>(changeList.getChanges());
Collections.sort(
changesInListCopy,
new Comparator<Change>() {
public int compare(final Change o1, final Change o2) {
return ChangesUtil.getFilePath(o1)
.getName()
.compareToIgnoreCase(ChangesUtil.getFilePath(o2).getName());
}
});
}
convertedChanges = changesInListCopy.toArray(new Change[changesInListCopy.size()]);
index =
Math.max(0, ContainerUtil.indexOfIdentity(changesInListCopy, selectedChange));
}
}
showDiffForChange(convertedChanges, index, project);
}
};
if (needsConvertion) {
ChangeListManager.getInstance(project)
.invokeAfterUpdate(
performer,
InvokeAfterUpdateMode.BACKGROUND_CANCELLABLE,
ourText,
ModalityState.current());
} else {
performer.run();
}
}
@Override
public void dispose() {
ChangeListManager.getInstance(myProject).removeChangeListListener(myChangeListListener);
}
@Override
public void activate() {
createPool();
final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(myProject);
if (!myProject.isDefault()) {
ChangeListManager.getInstance(myProject).addChangeListListener(myChangeListListener);
vcsManager.addVcsListener(myVcsListener);
}
SvnApplicationSettings.getInstance().svnActivated();
if (myEntriesFileListener != null) {
VirtualFileManager.getInstance().addVirtualFileListener(myEntriesFileListener);
}
// this will initialize its inner listener for committed changes upload
LoadedRevisionsCache.getInstance(myProject);
FrameStateManager.getInstance().addListener(myFrameStateListener);
myAuthNotifier.init();
mySvnBranchPointsCalculator = new SvnBranchPointsCalculator(myProject);
mySvnBranchPointsCalculator.activate();
if (SystemInfo.isWindows) {
if (!SVNJNAUtil.isJNAPresent()) {
Notifications.Bus.notify(
new Notification(
getDisplayName(),
"Subversion plugin: no JNA",
"A problem with JNA initialization for svnkit library. Encryption is not available.",
NotificationType.WARNING),
NotificationDisplayType.BALLOON,
myProject);
} else if (!SVNJNAUtil.isWinCryptEnabled()) {
Notifications.Bus.notify(
new Notification(
getDisplayName(),
"Subversion plugin: no encryption",
"A problem with encryption module (Crypt32.dll) initialization for svnkit library. Encryption is not available.",
NotificationType.WARNING),
NotificationDisplayType.BALLOON,
myProject);
}
}
final SvnConfiguration.UseAcceleration accelerationType =
SvnConfiguration.getInstance(myProject).myUseAcceleration;
if (SvnConfiguration.UseAcceleration.javaHL.equals(accelerationType)) {
CheckJavaHL.runtimeCheck(myProject);
} else if (SvnConfiguration.UseAcceleration.commandLine.equals(accelerationType)
&& !ApplicationManager.getApplication().isHeadlessEnvironment()) {
myChecker.checkExecutableAndNotifyIfNeeded();
}
// do one time after project loaded
StartupManager.getInstance(myProject)
.runWhenProjectIsInitialized(
new DumbAwareRunnable() {
@Override
public void run() {
postStartup();
// for IDEA, it takes 2 minutes - and anyway this can be done in background, no
// sense...
// once it could be mistaken about copies for 2 minutes on start...
/*if (! myMapping.getAllWcInfos().isEmpty()) {
invokeRefreshSvnRoots();
return;
}
ProgressManager.getInstance().runProcessWithProgressSynchronously(new Runnable() {
public void run() {
myCopiesRefreshManager.getCopiesRefresh().ensureInit();
}
}, SvnBundle.message("refreshing.working.copies.roots.progress.text"), true, myProject);*/
}
});
vcsManager.addVcsListener(myRootsToWorkingCopies);
myLoadedBranchesStorage.activate();
}
@Override
public void run(ContinuationContext context) {
final String message;
final Intersection intersection;
final ChangeListManager listManager = ChangeListManager.getInstance(myProject);
final List<LocalChangeList> localChangeLists = listManager.getChangeListsCopy();
if (myMergeAll) {
intersection = getMergeAllIntersection(localChangeLists);
message =
"There are local changes that can potentially intersect with merge changes.\nDo you want to continue?";
} else {
intersection = checkIntersection(myLists, localChangeLists);
message =
"There are local changes that will intersect with merge changes.\nDo you want to continue?";
}
if (intersection == null || intersection.getChangesSubset().isEmpty()) return;
final LocalChangesAction action;
if (!myMergeAll) {
final LocalChangesAction[] possibleResults = {
LocalChangesAction.shelve,
LocalChangesAction.inspect,
LocalChangesAction.continueMerge,
LocalChangesAction.cancel
};
final int result =
Messages.showDialog(
message,
myTitle,
new String[] {
"Shelve local changes", "Inspect changes", "Continue merge", "Cancel"
},
0,
Messages.getQuestionIcon());
action = possibleResults[result];
} else {
final LocalChangesAction[] possibleResults = {
LocalChangesAction.shelve, LocalChangesAction.continueMerge, LocalChangesAction.cancel
};
final int result =
Messages.showDialog(
message,
myTitle,
new String[] {"Shelve local changes", "Continue merge", "Cancel"},
0,
Messages.getQuestionIcon());
action = possibleResults[result];
}
switch (action) {
// shelve
case shelve:
context.next(new ShelveLocalChanges(intersection));
return;
// cancel
case cancel:
context.cancelEverything();
return;
// continue
case continueMerge:
return;
// inspect
case inspect:
final Collection<Change> changes =
(Collection<Change>) intersection.getChangesSubset().values();
final List<FilePath> paths = ChangesUtil.getPaths(changes);
Collections.sort(paths, FilePathByPathComparator.getInstance());
// todo rework message
IntersectingLocalChangesPanel.showInVersionControlToolWindow(
myProject,
myTitle + ", local changes intersection",
paths,
"The following file(s) have local changes that will intersect with merge changes:");
context.cancelEverything();
return;
default:
}
}
