@Override
public void onFrameActivated() {
final List<VirtualFile> folders = ((ChangeListManagerImpl) myClManager).getLockedFolders();
if (!folders.isEmpty()) {
myDirtyScopeManager.filesDirty(null, folders);
}
}
public <T extends TaskRepository> void setRepositories(List<T> repositories) {
Set<TaskRepository> set = new HashSet<TaskRepository>(myRepositories);
set.removeAll(repositories);
myBadRepositories.removeAll(set); // remove all changed reps
myIssueCache.clear();
myRepositories.clear();
myRepositories.addAll(repositories);
reps:
for (T repository : repositories) {
if (repository.isShared() && repository.getUrl() != null) {
List<TaskProjectConfiguration.SharedServer> servers = getProjectConfiguration().servers;
TaskRepositoryType type = repository.getRepositoryType();
for (TaskProjectConfiguration.SharedServer server : servers) {
if (repository.getUrl().equals(server.url) && type.getName().equals(server.type)) {
continue reps;
}
}
TaskProjectConfiguration.SharedServer server = new TaskProjectConfiguration.SharedServer();
server.type = type.getName();
server.url = repository.getUrl();
servers.add(server);
}
}
}
@Override
public boolean isLocallyClosed(final LocalTask localTask) {
if (isVcsEnabled()) {
List<ChangeListInfo> lists = localTask.getChangeLists();
if (lists.isEmpty()) return true;
for (ChangeListInfo list : lists) {
if (StringUtil.isEmpty(list.id)) {
return true;
}
}
}
return false;
}
@SuppressWarnings({"unchecked"})
public void loadState(Config config) {
XmlSerializerUtil.copyBean(config, myConfig);
myTasks.clear();
for (LocalTaskImpl task : config.tasks) {
addTask(task);
}
myRepositories.clear();
Element element = config.servers;
List<TaskRepository> repositories = loadRepositories(element);
myRepositories.addAll(repositories);
}
/**
* Returns real working copies roots - if there is <Project Root> -> Subversion setting, and there
* is one working copy, will return one root
*/
public List<WCInfo> getAllWcInfos() {
final SvnFileUrlMapping urlMapping = getSvnFileUrlMapping();
final List<RootUrlInfo> infoList = urlMapping.getAllWcInfos();
final List<WCInfo> infos = new ArrayList<WCInfo>();
for (RootUrlInfo info : infoList) {
final File file = info.getIoFile();
infos.add(
new WCInfo(
file.getAbsolutePath(),
info.getAbsoluteUrlAsUrl(),
info.getFormat(),
info.getRepositoryUrl(),
SvnUtil.isWorkingCopyRoot(file),
info.getType(),
SvnUtil.getDepth(this, file)));
}
return infos;
}
@Override
public List<Task> getIssues(
@Nullable String query,
int max,
long since,
boolean forceRequest,
final boolean withClosed,
@NotNull final ProgressIndicator cancelled) {
List<Task> tasks = getIssuesFromRepositories(query, max, since, forceRequest, cancelled);
if (tasks == null) return getCachedIssues(withClosed);
myIssueCache.putAll(ContainerUtil.newMapFromValues(tasks.iterator(), KEY_CONVERTOR));
return ContainerUtil.filter(
tasks,
new Condition<Task>() {
@Override
public boolean value(final Task task) {
return withClosed || !task.isClosed();
}
});
}
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 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;
}
@Override
public <S> List<S> filterUniqueRoots(
final List<S> in, final Convertor<S, VirtualFile> convertor) {
if (in.size() <= 1) return in;
final List<MyPair<S>> infos = new ArrayList<MyPair<S>>(in.size());
final SvnFileUrlMappingImpl mapping = (SvnFileUrlMappingImpl) getSvnFileUrlMapping();
final List<S> notMatched = new LinkedList<S>();
for (S s : in) {
final VirtualFile vf = convertor.convert(s);
if (vf == null) continue;
final File ioFile = new File(vf.getPath());
SVNURL url = mapping.getUrlForFile(ioFile);
if (url == null) {
url = SvnUtil.getUrl(this, ioFile);
if (url == null) {
notMatched.add(s);
continue;
}
}
infos.add(new MyPair<S>(vf, url.toString(), s));
}
final List<MyPair<S>> filtered = new ArrayList<MyPair<S>>(infos.size());
ForNestedRootChecker.filterOutSuperfluousChildren(this, infos, filtered);
final List<S> converted =
ObjectsConvertor.convert(
filtered,
new Convertor<MyPair<S>, S>() {
@Override
public S convert(final MyPair<S> o) {
return o.getSrc();
}
});
if (!notMatched.isEmpty()) {
// potential bug is here: order is not kept. but seems it only occurs for cases where result
// is sorted after filtering so ok
converted.addAll(notMatched);
}
return converted;
}
@Override
public TaskRepository[] getAllRepositories() {
return myRepositories.toArray(new TaskRepository[myRepositories.size()]);
}