Attachment #85142 for bug #181388

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




import org.eclipse.mylyn.internal.bugzilla.core.BugzillaCorePlugin;
import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
import org.eclipse.mylyn.internal.bugzilla.ui.tasklist.StackTrace;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.ui.search.AbstractRepositorySearchQuery;
import org.eclipse.mylyn.monitor.core.StatusHandler;
import org.eclipse.mylyn.tasks.core.AbstractTask;

		collector.setProgressMonitor(monitor);

		// get all of the root tasks and start the search
		Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
				LocalRepositoryConnector.REPOSITORY_URL).getChildren();
		searchLocal(tasks, collector, elementName, monitor);
		for (AbstractTaskContainer cat : TasksUiPlugin.getTaskListManager().getTaskList().getTaskContainers()) {
			searchLocal(cat.getChildren(), collector, elementName, monitor);

		collector.setProgressMonitor(monitor);

		// get all of the root tasks and start the search
		Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
				LocalRepositoryConnector.REPOSITORY_URL).getChildren();
		searchLocal(tasks, collector, elementName, monitor);
		for (AbstractTaskContainer cat : TasksUiPlugin.getTaskListManager().getTaskList().getTaskContainers()) {
			searchLocal(cat.getChildren(), collector, elementName, monitor);




import junit.framework.TestCase;

import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.mylyn.internal.bugzilla.core.BugzillaCorePlugin;
import org.eclipse.mylyn.internal.bugzilla.core.BugzillaRepositoryQuery;
import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
import org.eclipse.mylyn.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.internal.tasks.ui.planner.CompletedTaskCollector;
import org.eclipse.mylyn.internal.tasks.ui.planner.TaskReportGenerator;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.TaskListManager;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;



	public void testCompletedTasksRetrieved() throws InvocationTargetException, InterruptedException {
		AbstractTask task1 = manager.createNewLocalTask("task 1");
		manager.getTaskList().addTask(task1);

		CompletedTaskCollector collector = new CompletedTaskCollector(new Date(0), new Date());
		TaskReportGenerator generator = new TaskReportGenerator(manager.getTaskList());


	public void testCompletedTasksDateBoundsRetrieved() throws InvocationTargetException, InterruptedException {
		AbstractTask task1 = manager.createNewLocalTask("task 1");
		manager.getTaskList().addTask(task1);
		task1.setCompleted(true);
		Thread.sleep(1000);
		long now = new Date().getTime();

	}

	public void testCompletedBugzillaTasksRetrieved() throws InvocationTargetException, InterruptedException {
		TaskRepository repository = new TaskRepository(BugzillaCorePlugin.REPOSITORY_KIND,
				IBugzillaConstants.ECLIPSE_BUGZILLA_URL);
		TasksUiPlugin.getRepositoryManager().addRepository(repository,
				TasksUiPlugin.getDefault().getRepositoriesFilePath());
		BugzillaTask task1 = new BugzillaTask(IBugzillaConstants.ECLIPSE_BUGZILLA_URL, "1", "bugzillatask 1");
		manager.getTaskList().addTask(task1);

		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.MINUTE, 5);
		CompletedTaskCollector collector = new CompletedTaskCollector(new Date(0), cal.getTime());
		TaskReportGenerator generator = new TaskReportGenerator(manager.getTaskList());
		generator.addCollector(collector);
		generator.run(new NullProgressMonitor());

		generator.run(new NullProgressMonitor());
		assertEquals(1, generator.getAllCollectedTasks().size());
		assertEquals(task1, generator.getAllCollectedTasks().get(0));
		TasksUiPlugin.getRepositoryManager().removeRepository(repository,
				TasksUiPlugin.getDefault().getRepositoriesFilePath());
		manager.resetTaskList();
	}

	public void testCompletedTasksInCategoryRetrieved() throws InvocationTargetException, InterruptedException {
		AbstractTask task1 = manager.createNewLocalTask("task 1");
		manager.getTaskList().addTask(task1);
		task1.setCompleted(true);
		TaskCategory cat1 = new TaskCategory("TaskReportGeneratorTest Category");
		manager.getTaskList().addCategory(cat1);

		generator.run(new NullProgressMonitor());
		assertEquals(0, generator.getAllCollectedTasks().size());

		manager.getTaskList().moveTask(task1, cat1);

		generator.run(new NullProgressMonitor());
		assertEquals(1, generator.getAllCollectedTasks().size());


	public void testCompletedBugzillaTasksInCategoryRetrieved() throws InvocationTargetException, InterruptedException {
		BugzillaTask task1 = new BugzillaTask("repo", "1", "task 1");
		manager.getTaskList().addTask(task1);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
		task1.setCompleted(true);
		TaskCategory cat1 = new TaskCategory("TaskReportGeneratorTest Category");
		manager.getTaskList().addCategory(cat1);

		generator.run(new NullProgressMonitor());
		assertEquals(0, generator.getAllCollectedTasks().size());

		manager.getTaskList().moveTask(task1, cat1);

		generator.run(new NullProgressMonitor());
		assertEquals(1, generator.getAllCollectedTasks().size());


	public void testCompletedBugzillaTasksInQueryRetrieved() throws InvocationTargetException, InterruptedException {
		BugzillaTask task1 = new BugzillaTask("repo", "1", "task 1");
		manager.getTaskList().addTask(task1);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
		task1.setCompleted(false);

		BugzillaRepositoryQuery bugQuery = new BugzillaRepositoryQuery("repositoryUrl", "queryUrl",




		AbstractTask task = new LocalTask("1", "task 1");
		Date dueDate = new Date();
		task.setDueDate(dueDate);
		manager.getTaskList().addTask(task);
		assertEquals(1, manager.getTaskList().getAllTasks().size());

		manager.saveTaskList();

		Date creation = new Date();
		AbstractTask task = new LocalTask("1", "task 1");

		manager.getTaskList().addTask(task);
		assertDatesCloseEnough(task.getCreationDate(), start);

		task.setCompleted(true);

		task.setScheduledForDate(start);
		assertDatesCloseEnough(task.getScheduledForDate(), start);

		assertEquals(1, manager.getTaskList().getRootElements().size());
		manager.saveTaskList();

		assertNotNull(manager.getTaskList());

Lines 12-17 Link Here

(-)src/org/eclipse/mylyn/bugzilla/tests/RepositoryTaskHandleTest.java (-6 / +12 lines)
12		12
13	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;	13	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
14	import org.eclipse.mylyn.internal.bugzilla.core.IBugzillaConstants;	14	import org.eclipse.mylyn.internal.bugzilla.core.IBugzillaConstants;
		15	import org.eclipse.mylyn.tasks.core.TaskRepository;
		16	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryConnector;
15	import org.eclipse.mylyn.tasks.ui.TaskListManager;	17	import org.eclipse.mylyn.tasks.ui.TaskListManager;
16	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;	18	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
17		19
Lines 51-74 Link Here
51	// }	53	// }
52		54
53	public void testRepositoryUrlHandles() {	55	public void testRepositoryUrlHandles() {
		56	String repositoryUrl = IBugzillaConstants.ECLIPSE_BUGZILLA_URL;
		57	TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, repositoryUrl);
		58	TasksUiPlugin.getRepositoryManager().addRepository(repository,
		59	TasksUiPlugin.getDefault().getRepositoriesFilePath());
54		60
55	String repository = IBugzillaConstants.ECLIPSE_BUGZILLA_URL;
56	String id = "123";	61	String id = "123";
57	BugzillaTask bugTask = new BugzillaTask(repository, id, "label 124");	62	BugzillaTask bugTask = new BugzillaTask(repositoryUrl, id, "label 124");
58	assertEquals(repository, bugTask.getRepositoryUrl());	63	assertEquals(repositoryUrl, bugTask.getRepositoryUrl());
59		64
60	manager.getTaskList().moveToContainer(bugTask,	65	manager.getTaskList().addTask(bugTask);
61	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
62	manager.saveTaskList();	66	manager.saveTaskList();
63	manager.resetTaskList();	67	manager.resetTaskList();
64	manager.readExistingOrCreateNewList();	68	manager.readExistingOrCreateNewList();
65		69
66	BugzillaTask readReport = (BugzillaTask) manager.getTaskList()	70	BugzillaTask readReport = (BugzillaTask) manager.getTaskList()
67	.getDefaultCategory()	71	.getOrphanContainer(repositoryUrl)
68	.getChildren()	72	.getChildren()
69	.iterator()	73	.iterator()
70	.next();	74	.next();
71	assertEquals(readReport.getSummary(), readReport.getSummary());	75	assertEquals(readReport.getSummary(), readReport.getSummary());
72	assertEquals(readReport.getRepositoryUrl(), readReport.getRepositoryUrl());	76	assertEquals(readReport.getRepositoryUrl(), readReport.getRepositoryUrl());
		77	TasksUiPlugin.getRepositoryManager().removeRepository(repository,
		78	TasksUiPlugin.getDefault().getRepositoriesFilePath());
73	}	79	}
74	}	80	}




				task.getTaskId());
		assertNotNull(taskData);

		TasksUiPlugin.getTaskListManager().getTaskList().addTask(task);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());

		String newCommentText = "BugzillaRepositoryClientTest.testMidAirCollision(): test " + (new Date()).toString();
		taskData.setNewComment(newCommentText);

				task.getTaskId());
		assertNotNull(taskData);

		TasksUiPlugin.getTaskListManager().getTaskList().addTask(task);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());

		assertEquals("rob.elves@eclipse.org", taskData.getAssignedTo());
		// Modify it (reassign to tests2@mylyn.eclipse.org)

				task.getTaskId());
		assertNotNull(taskData);

		TasksUiPlugin.getTaskListManager().getTaskList().moveTask(task,
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());

		assertEquals(defaultAssignee, taskData.getAssignedTo());

				task.getTaskId());
		assertNotNull(taskData);

		TasksUiPlugin.getTaskListManager().getTaskList().addTask(task);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
		int numComments = taskData.getComments().size();

		// Modify it

Lines 59-65 Link Here

(-)src/org/eclipse/mylyn/bugzilla/tests/AbstractBugzillaTest.java (-2 / +2 lines)
59	super.setUp();	59	super.setUp();
60	TasksUiPlugin.getTaskDataManager().clear();	60	TasksUiPlugin.getTaskDataManager().clear();
61	manager = TasksUiPlugin.getRepositoryManager();	61	manager = TasksUiPlugin.getRepositoryManager();
62	TasksUiPlugin.getTaskListManager().getTaskList().reset();	62	TasksUiPlugin.getTaskListManager().resetTaskList();//getTaskList().reset();
63	manager.clearRepositories(TasksUiPlugin.getDefault().getRepositoriesFilePath());	63	manager.clearRepositories(TasksUiPlugin.getDefault().getRepositoriesFilePath());
64	}	64	}
65		65
Lines 122-128 Link Here
122	new NullProgressMonitor());	122	new NullProgressMonitor());
123	TasksUiPlugin.getSynchronizationManager().setTaskRead(task, true);	123	TasksUiPlugin.getSynchronizationManager().setTaskRead(task, true);
124	assertNotNull(task);	124	assertNotNull(task);
125	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task,	125	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(task,
126	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());	126	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
127		127
128	return task;	128	return task;




import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;
import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.core.TaskList;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.TaskListManager;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;


	}

	public void testRepositoryTaskExternalization() {
		BugzillaTask repositoryTask = new BugzillaTask(IBugzillaConstants.ECLIPSE_BUGZILLA_URL, "1", "label");
		repositoryTask.setTaskKind("kind");
		manager.getTaskList().addTask(repositoryTask);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
		manager.saveTaskList();

		manager.resetTaskList();

		// TaskList list = new TaskList();
		// manager.setTaskList(list);
		manager.readExistingOrCreateNewList();
		assertEquals(1, manager.getTaskList()
				.getOrphanContainer(IBugzillaConstants.ECLIPSE_BUGZILLA_URL)
				.getChildren()
				.size());
		AbstractTask readTask = manager.getTaskList()
				.getOrphanContainer(IBugzillaConstants.ECLIPSE_BUGZILLA_URL)
				.getChildren()
				.iterator()
				.next();

		assertEquals(repositoryTask.getHandleIdentifier(), readTask.getHandleIdentifier());
		assertEquals(repositoryTask.getSummary(), readTask.getSummary());

Lines 120-126 Link Here

(-)src/org/eclipse/mylyn/jira/tests/JiraTaskExternalizationTest.java (-2 / +2 lines)
120	public void testCompletionSave() {	120	public void testCompletionSave() {
121	JiraTask jiraTask = new JiraTask(SERVER_URL, TEST_TASK, TEST_LABEL);	121	JiraTask jiraTask = new JiraTask(SERVER_URL, TEST_TASK, TEST_LABEL);
122	jiraTask.setCompleted(true);	122	jiraTask.setCompleted(true);
123	manager.getTaskList().moveToContainer(jiraTask, manager.getTaskList().getDefaultCategory());	123	manager.getTaskList().addTask(jiraTask);
124		124
125	manager.saveTaskList();	125	manager.saveTaskList();
126	manager.resetTaskList();	126	manager.resetTaskList();
Lines 133-139 Link Here
133	JiraTask jiraTask = new JiraTask(SERVER_URL + "testSave", TEST_TASK, TEST_LABEL);	133	JiraTask jiraTask = new JiraTask(SERVER_URL + "testSave", TEST_TASK, TEST_LABEL);
134	String testUrl = "http://foo";	134	String testUrl = "http://foo";
135	jiraTask.setUrl(testUrl);	135	jiraTask.setUrl(testUrl);
136	manager.getTaskList().moveToContainer(jiraTask, manager.getTaskList().getDefaultCategory());	136	manager.getTaskList().addTask(jiraTask);
137		137
138	manager.saveTaskList();	138	manager.saveTaskList();
139	manager.resetTaskList();	139	manager.resetTaskList();

Lines 14-19 Link Here

(-)src/org/eclipse/mylyn/jira/tests/JiraTaskArchiveTest.java (-3 / +13 lines)
14	import org.eclipse.mylyn.internal.jira.ui.JiraUiPlugin;	14	import org.eclipse.mylyn.internal.jira.ui.JiraUiPlugin;
15	import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;	15	import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
16	import org.eclipse.mylyn.tasks.core.TaskList;	16	import org.eclipse.mylyn.tasks.core.TaskList;
		17	import org.eclipse.mylyn.tasks.core.TaskRepository;
17	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;	18	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
18		19
19	/**	20	/**
Lines 58-71 Link Here
58	AbstractRepositoryConnector client = TasksUiPlugin.getRepositoryManager().getRepositoryConnector(	59	AbstractRepositoryConnector client = TasksUiPlugin.getRepositoryManager().getRepositoryConnector(
59	JiraUiPlugin.REPOSITORY_KIND);	60	JiraUiPlugin.REPOSITORY_KIND);
60	assertNotNull(client);	61	assertNotNull(client);
61	assertEquals(0, taskList.getArchiveContainer().getChildren().size());	62
		63	TaskRepository repository = new TaskRepository(JiraUiPlugin.REPOSITORY_KIND, "repo");
		64	TasksUiPlugin.getRepositoryManager().addRepository(repository,
		65	TasksUiPlugin.getDefault().getRepositoriesFilePath());
		66
62	JiraTask task1 = new JiraTask("repo", HANDLE1, LABEL);	67	JiraTask task1 = new JiraTask("repo", HANDLE1, LABEL);
		68	task1.setLastReadTimeStamp("now");
63	JiraTask task2 = new JiraTask("repo", HANDLE1, LABEL);	69	JiraTask task2 = new JiraTask("repo", HANDLE1, LABEL);
64		70	task2.setLastReadTimeStamp("now");
65	taskList.addTask(task1);	71	taskList.addTask(task1);
66	taskList.addTask(task2);	72	taskList.addTask(task2);
67		73
68	assertEquals(1, taskList.getArchiveContainer().getChildren().size());	74	assertEquals(1, taskList.getOrphanContainer("repo").getChildren().size());
69	assertEquals(taskList.getTask("repo-" + HANDLE1), task1);	75	assertEquals(taskList.getTask("repo-" + HANDLE1), task1);
		76
		77	TasksUiPlugin.getRepositoryManager().removeRepository(repository,
		78	TasksUiPlugin.getDefault().getRepositoriesFilePath());
		79	TasksUiPlugin.getTaskListManager().resetTaskList();
70	}	80	}
71	}	81	}




import java.util.concurrent.CopyOnWriteArraySet;

import org.eclipse.core.runtime.PlatformObject;
import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;
import org.eclipse.mylyn.tasks.core.AbstractTask.PriorityLevel;

/**

 */
public abstract class AbstractTaskContainer extends PlatformObject implements Comparable<AbstractTaskContainer> {

	/**
	 * TODO: consider removing in 3.0 if handled by content provider
	 */
	private static final int MAX_SUBTASK_DEPTH = 10;

	private String handleIdentifier = "";

	private Set<AbstractTask> children = new CopyOnWriteArraySet<AbstractTask>();

	}

	private boolean containsHelper(Set<AbstractTask> children, String handle, int depth) {
		if (depth < ITasksCoreConstants.MAX_SUBTASK_DEPTH && children != null && !children.isEmpty()) {
			for (AbstractTask child : children) {
				if (handle.equals(child.getHandleIdentifier())
						|| containsHelper(child.getChildrenInternal(), handle, depth + 1)) {

Lines 46-52 Link Here

(-)src/org/eclipse/mylyn/tasks/core/TaskSelection.java (-1 / +1 lines)
46		46
47	public TaskSelection(String summary, String description) {	47	public TaskSelection(String summary, String description) {
48	RepositoryTaskData taskData = new RepositoryTaskData(new IdentityAttributeFactory(),	48	RepositoryTaskData taskData = new RepositoryTaskData(new IdentityAttributeFactory(),
49	LocalRepositoryConnector.REPOSITORY_KIND, LocalRepositoryConnector.REPOSITORY_URL, "");	49	LocalRepositoryConnector.CONNECTOR_KIND, LocalRepositoryConnector.REPOSITORY_URL, "");
50	taskData.setSummary(summary);	50	taskData.setSummary(summary);
51	taskData.setDescription(description);	51	taskData.setDescription(description);
52	this.taskData = taskData;	52	this.taskData = taskData;

Lines 23-28 Link Here

(-)src/org/eclipse/mylyn/tasks/core/AbstractTaskCategory.java (+2 lines)
23	/**	23	/**
24	* Override to return true for categories that the user creates, deletes, and renames. Return false for categories	24	* Override to return true for categories that the user creates, deletes, and renames. Return false for categories
25	* that are managed	25	* that are managed
		26	*
		27	* @API-3.0: Move up into AbstractTaskContainer
26	*/	28	*/
27	public abstract boolean isUserDefined();	29	public abstract boolean isUserDefined();
28		30

Lines 19-24 Link Here

(-)src/org/eclipse/mylyn/tasks/core/TaskRepositoryManager.java (+5 lines)
19	import java.util.Set;	19	import java.util.Set;
20		20
21	import org.eclipse.core.runtime.Platform;	21	import org.eclipse.core.runtime.Platform;
		22	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
22	import org.eclipse.mylyn.internal.tasks.core.TaskRepositoriesExternalizer;	23	import org.eclipse.mylyn.internal.tasks.core.TaskRepositoriesExternalizer;
23	import org.eclipse.mylyn.monitor.core.StatusHandler;	24	import org.eclipse.mylyn.monitor.core.StatusHandler;
24		25
Lines 96-101 Link Here
96	}	97	}
97	repositories.add(repository);	98	repositories.add(repository);
98	saveRepositories(repositoryFilePath);	99	saveRepositories(repositoryFilePath);
		100
		101	taskList.addOrphanContainer(new OrphanedTasksContainer(repository.getConnectorKind(), repository.getUrl()));
		102
99	for (ITaskRepositoryListener listener : listeners) {	103	for (ITaskRepositoryListener listener : listeners) {
100	listener.repositoryAdded(repository);	104	listener.repositoryAdded(repository);
101	}	105	}
Lines 106-111 Link Here
106	if (repositories != null) {	110	if (repositories != null) {
107	repository.flushAuthenticationCredentials();	111	repository.flushAuthenticationCredentials();
108	repositories.remove(repository);	112	repositories.remove(repository);
		113	taskList.removeOrphanContainer(repository.getUrl());
109	}	114	}
110	saveRepositories(repositoryFilePath);	115	saveRepositories(repositoryFilePath);
111	for (ITaskRepositoryListener listener : listeners) {	116	for (ITaskRepositoryListener listener : listeners) {

Lines 19-25 Link Here

(-)src/org/eclipse/mylyn/tasks/core/TaskList.java (-45 / +285 lines)
19	import java.util.concurrent.CopyOnWriteArrayList;	19	import java.util.concurrent.CopyOnWriteArrayList;
20	import java.util.concurrent.CopyOnWriteArraySet;	20	import java.util.concurrent.CopyOnWriteArraySet;
21		21
		22	import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;
		23	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
22	import org.eclipse.mylyn.internal.tasks.core.LocalTask;	24	import org.eclipse.mylyn.internal.tasks.core.LocalTask;
		25	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
23	import org.eclipse.mylyn.internal.tasks.core.RepositoryTaskHandleUtil;	26	import org.eclipse.mylyn.internal.tasks.core.RepositoryTaskHandleUtil;
24	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;	27	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;
25	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;	28	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
Lines 38-79 Link Here
38		41
39	private Set<ITaskListChangeListener> changeListeners = new CopyOnWriteArraySet<ITaskListChangeListener>();	42	private Set<ITaskListChangeListener> changeListeners = new CopyOnWriteArraySet<ITaskListChangeListener>();
40		43
		44	private Map<String, OrphanedTasksContainer> repositoryOrphansMap;
		45
41	private Map<String, AbstractTask> tasks;	46	private Map<String, AbstractTask> tasks;
42		47
43	private Map<String, AbstractTaskCategory> categories;	48	private Map<String, AbstractTaskCategory> categories;
44		49
45	private Map<String, AbstractRepositoryQuery> queries;	50	private Map<String, AbstractRepositoryQuery> queries;
46		51
		52	private List<AbstractTask> activeTasks;
		53
47	private TaskArchive archiveContainer;	54	private TaskArchive archiveContainer;
48		55
49	private UnfiledCategory defaultCategory;	56	private UnfiledCategory defaultCategory;
50		57
51	private List<AbstractTask> activeTasks;
52
53	public TaskList() {	58	public TaskList() {
54	reset();	59	reset();
55	}	60	}
56		61
		62	private void addOrphan(AbstractTask task, Set<TaskContainerDelta> delta) {
		63	addOrphan(task, delta, 0);
		64	}
		65
		66	private void addOrphan(AbstractTask task, Set<TaskContainerDelta> delta, int depth) {
		67	if (/task.getLastReadTimeStamp() == null \|\|/!getQueriesForHandle(task.getHandleIdentifier()).isEmpty()
		68	\|\| getCategoryForHandle(task.getHandleIdentifier()) != null) {
		69	// Current policy is not to archive/orphan if the task exists in some other container
		70	return;
		71	}
		72
		73	if (task instanceof LocalTask) {
		74	moveTask(task, defaultCategory);
		75	return;
		76	}
		77
		78	OrphanedTasksContainer orphans = repositoryOrphansMap.get(task.getRepositoryUrl());
		79	// if (orphans == null) {
		80	// orphans = new OrphanedTasksContainer(task.getConnectorKind(), task.getRepositoryUrl());
		81	// repositoryOrphansMap.put(task.getRepositoryUrl(), orphans);
		82	// //categories.put(orphans.getHandleIdentifier(), orphans);
		83	// }
		84
		85	if (orphans != null) {
		86	if (!orphans.contains(task.getHandleIdentifier())) {
		87	orphans.internalAddChild(task);
		88	if (delta != null) {
		89	delta.add(new TaskContainerDelta(orphans, TaskContainerDelta.Kind.CHANGED));
		90	}
		91	}
		92	task.addParentContainer(orphans);
		93	} else {
		94	//StatusHandler.log("Orphan container not found for: " + task.getRepositoryUrl(), this);
		95	}
		96
		97	if (depth < ITasksCoreConstants.MAX_SUBTASK_DEPTH && !task.isEmpty()) {
		98	for (AbstractTask child : task.getChildren()) {
		99	addOrphan(child, delta, depth + 1);
		100	}
		101	}
		102
		103	}
		104
		105	private void removeOrphan(AbstractTask task, Set<TaskContainerDelta> delta) {
		106	removeOrphan(task, delta, 0);
		107	}
		108
		109	private void removeOrphan(AbstractTask task, Set<TaskContainerDelta> delta, int depth) {
		110	OrphanedTasksContainer orphans = repositoryOrphansMap.get(task.getRepositoryUrl());
		111	if (orphans != null) {
		112	if (orphans.contains(task.getHandleIdentifier())) {
		113	orphans.internalRemoveChild(task);
		114	if (delta != null) {
		115	delta.add(new TaskContainerDelta(orphans, TaskContainerDelta.Kind.CHANGED));
		116	}
		117
		118	if (depth < ITasksCoreConstants.MAX_SUBTASK_DEPTH && !task.isEmpty()) {
		119	for (AbstractTask child : task.getChildren()) {
		120	removeOrphan(child, delta, depth + 1);
		121	}
		122	}
		123
		124	}
		125
126	// if (orphans.isEmpty() && !orphans.getRepositoryUrl().equals(LocalRepositoryConnector.REPOSITORY_URL)) {
127	// repositoryOrphansMap.remove(task.getRepositoryUrl());
128	// if (delta != null) {
129	// delta.add(new TaskContainerDelta(orphans, TaskContainerDelta.Kind.CHANGED));
130	// }
131	// }
132	task.removeParentContainer(orphans);
133	}
134	}
135
136	/**
137	* @since 2.2
138	*/
139	public Set<OrphanedTasksContainer> getOrphanContainers() {
140	return Collections.unmodifiableSet(new HashSet<OrphanedTasksContainer>(repositoryOrphansMap.values()));
141	}
142
143	/**
144	* @since 2.2
145	*/
146	public OrphanedTasksContainer getOrphanContainer(String repositoryUrl) {
147	return repositoryOrphansMap.get(repositoryUrl);
148	}
149
57	/**	150	/**
58	* Public for testing.	151	* Public for testing.
59	*/	152	*/
60	public void reset() {	153	public void reset() {
61	tasks = new ConcurrentHashMap<String, AbstractTask>();	154	tasks = new ConcurrentHashMap<String, AbstractTask>();
62		155
		156	repositoryOrphansMap = new ConcurrentHashMap<String, OrphanedTasksContainer>();
		157	// repositoryOrphansMap.put(LocalRepositoryConnector.REPOSITORY_URL, new OrphanedTasksContainer(
		158	// LocalRepositoryConnector.CONNECTOR_KIND, LocalRepositoryConnector.REPOSITORY_URL));
		159
63	categories = new ConcurrentHashMap<String, AbstractTaskCategory>();	160	categories = new ConcurrentHashMap<String, AbstractTaskCategory>();
64	queries = new ConcurrentHashMap<String, AbstractRepositoryQuery>();	161	queries = new ConcurrentHashMap<String, AbstractRepositoryQuery>();
65		162
66	archiveContainer = new TaskArchive();	163	archiveContainer = new TaskArchive(this);
67	defaultCategory = new UnfiledCategory();	164	defaultCategory = new UnfiledCategory();
68		165
69	activeTasks = new CopyOnWriteArrayList<AbstractTask>();	166	activeTasks = new CopyOnWriteArrayList<AbstractTask>();
70	lastLocalTaskId = 0;	167	lastLocalTaskId = 0;
71	categories.put(defaultCategory.getHandleIdentifier(), defaultCategory);	168	categories.put(defaultCategory.getHandleIdentifier(), defaultCategory);
72	categories.put(archiveContainer.getHandleIdentifier(), archiveContainer);	169	// categories.put(archiveContainer.getHandleIdentifier(), archiveContainer);
73	}	170	}
74		171
		172	/**
		173	* Add orphaned task to the task list
		174	*/
75	public void addTask(AbstractTask task) throws IllegalArgumentException {	175	public void addTask(AbstractTask task) throws IllegalArgumentException {
76	addTask(task, archiveContainer);	176	addTask(task, null);
77	}	177	}
78		178
79	/**	179	/**
Lines 94-100 Link Here
94	}	194	}
95		195
96	/**	196	/**
97	* Precondition: {@code container} already exists in tasklist (be it a parent task, category, or query)	197	* Precondition: {@code container} already exists in tasklist (be it a parent task, category, or query) If the
		198	* parentContainer is null the task is considered an orphan and added to the appropriate repository's orphaned tasks
		199	* container.
98	*	200	*
99	* @param task	201	* @param task
100	* to be added (hit, subtask, etc)	202	* to be added (hit, subtask, etc)
Lines 111-118 Link Here
111	if (newTask == null) {	213	if (newTask == null) {
112	newTask = task;	214	newTask = task;
113	tasks.put(newTask.getHandleIdentifier(), newTask);	215	tasks.put(newTask.getHandleIdentifier(), newTask);
114	// archiveContainer.addChild(newTask);
115	// newTask.addParentContainer(archiveContainer);
116		216
117	// NOTE: only called for newly-created tasks	217	// NOTE: only called for newly-created tasks
118	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();	218	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
Lines 126-141 Link Here
126	}	226	}
127		227
128	if (parentContainer != null) {	228	if (parentContainer != null) {
		229	if (parentContainer instanceof AbstractTask) {
		230	// Ensure the parent task exists in the task list
		231	tasks.put(parentContainer.getHandleIdentifier(), (AbstractTask) parentContainer);
		232	addOrphan((AbstractTask) parentContainer, null);
		233	// TODO: will need to update map of children to parents here
		234	}
		235
		236	removeOrphan(newTask, null);
		237
129	parentContainer.internalAddChild(newTask);	238	parentContainer.internalAddChild(newTask);
		239
130	if (!(parentContainer instanceof AbstractTask) && !(parentContainer instanceof AbstractRepositoryQuery)) {	240	if (!(parentContainer instanceof AbstractTask) && !(parentContainer instanceof AbstractRepositoryQuery)) {
131	newTask.addParentContainer(parentContainer);	241	newTask.addParentContainer(parentContainer);
132	}	242	}
133	} else {	243	} else {
134	defaultCategory.internalAddChild(newTask);	244	// TODO: if the task has a parent task which isn't orphaned than the current task isn't orphaned
135	newTask.addParentContainer(defaultCategory);	245	// check map of children to parents first
		246	addOrphan(task, null);
136	}	247	}
137	}	248	}
138		249
		250	/**
		251	* @since 2.2
		252	*/
		253	public void moveTask(AbstractTask task, AbstractTaskContainer container) {
		254	if (!tasks.containsKey(task.getHandleIdentifier())) {
		255	tasks.put(task.getHandleIdentifier(), task);
		256	}
		257	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
		258	delta.add(new TaskContainerDelta(container, TaskContainerDelta.Kind.CHANGED));
		259
		260	Set<AbstractTaskContainer> currentContainers = task.getParentContainers();
		261	for (AbstractTaskContainer taskContainer : currentContainers) {
		262	if (taskContainer instanceof AbstractTaskCategory) {
		263	if (!(taskContainer instanceof OrphanedTasksContainer)) {
		264	taskContainer.internalRemoveChild(task);
		265	}
		266	task.removeParentContainer(taskContainer);
		267	delta.add(new TaskContainerDelta(taskContainer, TaskContainerDelta.Kind.CHANGED));
		268	}
		269	}
		270	if (container != null) {
		271	addTask(task, container);
		272	//internalAddTask(task, container);
		273	delta.add(new TaskContainerDelta(container, TaskContainerDelta.Kind.CHANGED));
		274	if (!(container instanceof OrphanedTasksContainer)) {
		275	removeOrphan(task, delta);
		276	}
		277	} else {
		278	internalAddTask(task, null);
		279	}
		280	for (ITaskListChangeListener listener : changeListeners) {
		281	listener.containersChanged(delta);
		282	}
		283	}
		284
		285	/**
		286	* @deprecated
		287	*/
139	public void moveToContainer(AbstractTask task, AbstractTaskCategory container) {	288	public void moveToContainer(AbstractTask task, AbstractTaskCategory container) {
140	if (!tasks.containsKey(task.getHandleIdentifier())) {	289	if (!tasks.containsKey(task.getHandleIdentifier())) {
141	tasks.put(task.getHandleIdentifier(), task);	290	tasks.put(task.getHandleIdentifier(), task);
Lines 146-154 Link Here
146	Set<AbstractTaskContainer> currentContainers = task.getParentContainers();	295	Set<AbstractTaskContainer> currentContainers = task.getParentContainers();
147	for (AbstractTaskContainer taskContainer : currentContainers) {	296	for (AbstractTaskContainer taskContainer : currentContainers) {
148	if (taskContainer instanceof AbstractTaskCategory) {	297	if (taskContainer instanceof AbstractTaskCategory) {
149	if (!(taskContainer instanceof TaskArchive)) {	298	if (!(taskContainer instanceof OrphanedTasksContainer)) {
150	(taskContainer).internalRemoveChild(task);	299	(taskContainer).internalRemoveChild(task);
151	}	300	}
		301	// if (!(taskContainer instanceof TaskArchive)) {
		302	// (taskContainer).internalRemoveChild(task);
		303	// }
152	task.removeParentContainer(taskContainer);	304	task.removeParentContainer(taskContainer);
153	delta.add(new TaskContainerDelta(taskContainer, TaskContainerDelta.Kind.CHANGED));	305	delta.add(new TaskContainerDelta(taskContainer, TaskContainerDelta.Kind.CHANGED));
154	}	306	}
Lines 156-167 Link Here
156	if (container != null) {	308	if (container != null) {
157	internalAddTask(task, container);	309	internalAddTask(task, container);
158	delta.add(new TaskContainerDelta(container, TaskContainerDelta.Kind.CHANGED));	310	delta.add(new TaskContainerDelta(container, TaskContainerDelta.Kind.CHANGED));
159	if (archiveContainer.contains(task.getHandleIdentifier())) {	311	if (!(container instanceof OrphanedTasksContainer)) {
160	archiveContainer.internalRemoveChild(task);	312	removeOrphan(task, delta);
161	delta.add(new TaskContainerDelta(archiveContainer, TaskContainerDelta.Kind.CHANGED));
162	}	313	}
		314	// if (archiveContainer.contains(task.getHandleIdentifier())) {
		315	// archiveContainer.internalRemoveChild(task);
		316	// delta.add(new TaskContainerDelta(archiveContainer, TaskContainerDelta.Kind.CHANGED));
		317	// }
163	} else {	318	} else {
164	internalAddTask(task, archiveContainer);	319	internalAddTask(task, null);
165	}	320	}
166	for (ITaskListChangeListener listener : changeListeners) {	321	for (ITaskListChangeListener listener : changeListeners) {
167	listener.containersChanged(delta);	322	listener.containersChanged(delta);
Lines 189-194 Link Here
189	delta.add(new TaskContainerDelta(query, TaskContainerDelta.Kind.CHANGED));	344	delta.add(new TaskContainerDelta(query, TaskContainerDelta.Kind.CHANGED));
190	}	345	}
191	}	346	}
		347
		348	for (OrphanedTasksContainer orphans : repositoryOrphansMap.values()) {
		349	if (orphans.getRepositoryUrl().equals(oldRepositoryUrl)) {
		350	repositoryOrphansMap.remove(oldRepositoryUrl);
		351	//categories.remove(orphans.getHandleIdentifier());
		352	orphans.setRepositoryUrl(newRepositoryUrl);
		353	repositoryOrphansMap.put(newRepositoryUrl, orphans);
		354	//categories.put(orphans.getHandleIdentifier(), orphans);
		355	delta.add(new TaskContainerDelta(orphans, TaskContainerDelta.Kind.CHANGED));
		356	}
		357	}
192	for (ITaskListChangeListener listener : changeListeners) {	358	for (ITaskListChangeListener listener : changeListeners) {
193	listener.containersChanged(delta);	359	listener.containersChanged(delta);
194	}	360	}
Lines 209-215 Link Here
209	}	375	}
210		376
211	public void removeFromCategory(TaskCategory category, AbstractTask task) {	377	public void removeFromCategory(TaskCategory category, AbstractTask task) {
212	moveToContainer(task, archiveContainer);	378	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
		379	delta.add(new TaskContainerDelta(category, TaskContainerDelta.Kind.CHANGED));
		380	category.internalRemoveChild(task);
		381	addOrphan(task, delta);
		382	for (ITaskListChangeListener listener : changeListeners) {
		383	listener.containersChanged(delta);
		384	}
		385	//moveToContainer(task, null);
213	}	386	}
214		387
215	/**	388	/**
Lines 218-228 Link Here
218	* @since 2.1	391	* @since 2.1
219	*/	392	*/
220	public void removeFromQuery(AbstractRepositoryQuery query, AbstractTask task) {	393	public void removeFromQuery(AbstractRepositoryQuery query, AbstractTask task) {
		394
		395	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
		396	delta.add(new TaskContainerDelta(task, TaskContainerDelta.Kind.CHANGED));
		397
221	query.internalRemoveChild(task);	398	query.internalRemoveChild(task);
222	if (task.getParentContainers().size() == 0 && task.getLastReadTimeStamp() != null) {	399	addOrphan(task, delta);
223	task.addParentContainer(archiveContainer);	400
224	archiveContainer.internalAddChild(task);	401	for (ITaskListChangeListener listener : changeListeners) {
		402	listener.containersChanged(delta);
225	}	403	}
		404
		405	// if (task.getParentContainers().size() == 0 && task.getLastReadTimeStamp() != null) {
		406	// task.addParentContainer(archiveContainer);
		407	// archiveContainer.internalAddChild(task);
		408	// }
226	}	409	}
227		410
228	public void renameTask(AbstractTask task, String description) {	411	public void renameTask(AbstractTask task, String description) {
Lines 242-248 Link Here
242	public void renameContainer(AbstractTaskContainer container, String newDescription) {	425	public void renameContainer(AbstractTaskContainer container, String newDescription) {
243	if (container instanceof AbstractTask) {	426	if (container instanceof AbstractTask) {
244	return;	427	return;
245	} else if (!(container instanceof TaskArchive) && !(container instanceof UnfiledCategory)) {	428	} else if (!(container instanceof TaskArchive) && !(container instanceof OrphanedTasksContainer)) {
246	if (queries.remove(container.getHandleIdentifier()) != null) {	429	if (queries.remove(container.getHandleIdentifier()) != null) {
247	if (container instanceof AbstractTaskCategory) {	430	if (container instanceof AbstractTaskCategory) {
248	((AbstractTaskCategory) container).setHandleIdentifier(newDescription);	431	((AbstractTaskCategory) container).setHandleIdentifier(newDescription);
Lines 284-290 Link Here
284	* deletion of subtasks)	467	* deletion of subtasks)
285	*/	468	*/
286	public void deleteTask(AbstractTask task) {	469	public void deleteTask(AbstractTask task) {
287	archiveContainer.internalRemoveChild(task);
288	defaultCategory.internalRemoveChild(task);	470	defaultCategory.internalRemoveChild(task);
289		471
290	for (AbstractTaskContainer container : task.getParentContainers()) {	472	for (AbstractTaskContainer container : task.getParentContainers()) {
Lines 294-299 Link Here
294	tasks.remove(task.getHandleIdentifier());	476	tasks.remove(task.getHandleIdentifier());
295		477
296	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();	478	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
		479	removeOrphan(task, delta);
297	delta.add(new TaskContainerDelta(task, TaskContainerDelta.Kind.REMOVED));	480	delta.add(new TaskContainerDelta(task, TaskContainerDelta.Kind.REMOVED));
298	for (ITaskListChangeListener listener : changeListeners) {	481	for (ITaskListChangeListener listener : changeListeners) {
299	listener.containersChanged(delta);	482	listener.containersChanged(delta);
Lines 301-313 Link Here
301	}	484	}
302		485
303	public void deleteCategory(AbstractTaskCategory category) {	486	public void deleteCategory(AbstractTaskCategory category) {
		487	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
		488
		489	categories.remove(category.getHandleIdentifier());
304	for (AbstractTask task : category.getChildren()) {	490	for (AbstractTask task : category.getChildren()) {
305	defaultCategory.internalAddChild(task);	491	addOrphan(task, delta);
306	}	492	}
307	categories.remove(category.getHandleIdentifier());
308		493
309	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
310	delta.add(new TaskContainerDelta(defaultCategory, TaskContainerDelta.Kind.CHANGED));
311	delta.add(new TaskContainerDelta(category, TaskContainerDelta.Kind.REMOVED));	494	delta.add(new TaskContainerDelta(category, TaskContainerDelta.Kind.REMOVED));
312		495
313	for (ITaskListChangeListener listener : changeListeners) {	496	for (ITaskListChangeListener listener : changeListeners) {
Lines 316-331 Link Here
316	}	499	}
317		500
318	public void deleteQuery(AbstractRepositoryQuery query) {	501	public void deleteQuery(AbstractRepositoryQuery query) {
319	queries.remove(query.getHandleIdentifier());	502	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
320		503
		504	queries.remove(query.getHandleIdentifier());
321	for (AbstractTask task : query.getChildren()) {	505	for (AbstractTask task : query.getChildren()) {
322	if (task.getParentContainers().size() == 0 && task.getLastReadTimeStamp() != null) {	506	addOrphan(task, delta);
323	task.addParentContainer(archiveContainer);
324	archiveContainer.internalAddChild(task);
325	}
326	}	507	}
327		508
328	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
329	delta.add(new TaskContainerDelta(query, TaskContainerDelta.Kind.REMOVED));	509	delta.add(new TaskContainerDelta(query, TaskContainerDelta.Kind.REMOVED));
330	for (ITaskListChangeListener listener : changeListeners) {	510	for (ITaskListChangeListener listener : changeListeners) {
331	listener.containersChanged(delta);	511	listener.containersChanged(delta);
Lines 357-377 Link Here
357	categories.put(category.getHandleIdentifier(), category);	537	categories.put(category.getHandleIdentifier(), category);
358	}	538	}
359		539
		540	/**
		541	* @deprecated
		542	*/
360	public void internalAddTask(AbstractTask task, AbstractTaskCategory container) {	543	public void internalAddTask(AbstractTask task, AbstractTaskCategory container) {
		544	internalAddTask(task, (AbstractTaskContainer) container);
		545	// //tasks.put(task.getHandleIdentifier(), task);
		546	// if (container != null) {
		547	// tasks.put(task.getHandleIdentifier(), task);
		548	// container.internalAddChild(task);
		549	// if (container instanceof TaskCategory \|\| container instanceof OrphanedTasksContainer) {
		550	// task.addParentContainer(container);
		551	// }
		552	// } else {
		553	// if (task.getLastReadTimeStamp() != null) {
		554	// // any unread task (hit) that is an orphan is discarded
		555	// tasks.put(task.getHandleIdentifier(), task);
		556	// addOrphan(task, null);
		557	// }
		558	//// defaultCategory.internalAddChild(task);
		559	//// task.addParentContainer(defaultCategory);
		560	// }
		561	}
		562
		563	private void internalAddTask(AbstractTask task, AbstractTaskContainer container) {
361	tasks.put(task.getHandleIdentifier(), task);	564	tasks.put(task.getHandleIdentifier(), task);
362	if (container != null) {	565	if (container != null) {
363	container.internalAddChild(task);	566	container.internalAddChild(task);
364	if (container instanceof TaskCategory \|\| container instanceof UnfiledCategory) {	567	if (container instanceof TaskCategory \|\| container instanceof OrphanedTasksContainer) {
365	task.addParentContainer(container);	568	task.addParentContainer(container);
366	}	569	}
367	} else {	570	} else {
368	defaultCategory.internalAddChild(task);	571	//if (task.getLastReadTimeStamp() != null) {
369	task.addParentContainer(defaultCategory);	572	// any unread task (hit) that is an orphan is discarded
		573	addOrphan(task, null);
		574	//}
		575	// defaultCategory.internalAddChild(task);
		576	// task.addParentContainer(defaultCategory);
370	}	577	}
371	}	578	}
372		579
		580	/**
		581	* @API-3.0 remove
		582	*/
373	public void internalAddRootTask(AbstractTask task) {	583	public void internalAddRootTask(AbstractTask task) {
374	internalAddTask(task, defaultCategory);	584	internalAddTask(task, null);
375	}	585	}
376		586
377	public void internalAddQuery(AbstractRepositoryQuery query) {	587	public void internalAddQuery(AbstractRepositoryQuery query) {
Lines 412-420 Link Here
412	public List<AbstractTaskCategory> getUserCategories() {	622	public List<AbstractTaskCategory> getUserCategories() {
413	List<AbstractTaskCategory> included = new ArrayList<AbstractTaskCategory>();	623	List<AbstractTaskCategory> included = new ArrayList<AbstractTaskCategory>();
414	for (AbstractTaskCategory category : categories.values()) {	624	for (AbstractTaskCategory category : categories.values()) {
415	if (!(category instanceof TaskArchive)) {	625	included.add(category);
416	included.add(category);
417	}
418	}	626	}
419	return included;	627	return included;
420	}	628	}
Lines 431-436 Link Here
431	roots.add(cat);	639	roots.add(cat);
432	for (AbstractRepositoryQuery query : queries.values())	640	for (AbstractRepositoryQuery query : queries.values())
433	roots.add(query);	641	roots.add(query);
		642	for (OrphanedTasksContainer orphanContainer : repositoryOrphansMap.values())
		643	roots.add(orphanContainer);
434	return roots;	644	return roots;
435	}	645	}
436		646
Lines 460-469 Link Here
460	return null;	670	return null;
461	}	671	}
462		672
		673	private AbstractTaskCategory getCategoryForHandle(String handle) {
		674	if (handle == null) {
		675	return null;
		676	}
		677	for (AbstractTaskCategory category : categories.values()) {
		678	if (!(category instanceof OrphanedTasksContainer) && category.contains(handle)) {
		679	return category;
		680	}
		681	}
		682	return null;
		683	}
		684
463	public boolean isEmpty() {	685	public boolean isEmpty() {
464	boolean archiveIsEmpty = getCategories().size() == 2 && getCategories().contains(archiveContainer)	686	boolean isEmpty = getCategories().size() == 1 && getCategories().contains(defaultCategory) /&& archiveContainer.getChildren().isEmpty()/;
465	&& getCategories().contains(defaultCategory) && archiveContainer.getChildren().isEmpty();	687	return getAllTasks().size() == 0 && isEmpty && getQueries().size() == 0;
466	return getAllTasks().size() == 0 && archiveIsEmpty && getQueries().size() == 0;
467	}	688	}
468		689
469	/**	690	/**
Lines 540-545 Link Here
540	return defaultCategory;	761	return defaultCategory;
541	}	762	}
542		763
		764	/**
		765	* @deprecated
		766	*/
543	public TaskArchive getArchiveContainer() {	767	public TaskArchive getArchiveContainer() {
544	return archiveContainer;	768	return archiveContainer;
545	}	769	}
Lines 660-666 Link Here
660	if (containers == null) {	884	if (containers == null) {
661	delta = new HashSet<TaskContainerDelta>();	885	delta = new HashSet<TaskContainerDelta>();
662	delta.add(new TaskContainerDelta(null, TaskContainerDelta.Kind.ROOT));	886	delta.add(new TaskContainerDelta(null, TaskContainerDelta.Kind.ROOT));
663	} else {	887	} else {
664	delta = new HashSet<TaskContainerDelta>();	888	delta = new HashSet<TaskContainerDelta>();
665	for (AbstractTaskContainer abstractTaskContainer : containers) {	889	for (AbstractTaskContainer abstractTaskContainer : containers) {
666	delta.add(new TaskContainerDelta(abstractTaskContainer, TaskContainerDelta.Kind.CHANGED));	890	delta.add(new TaskContainerDelta(abstractTaskContainer, TaskContainerDelta.Kind.CHANGED));
Lines 710-717 Link Here
710	int max = 0;	934	int max = 0;
711	for (AbstractTask task : tasks) {	935	for (AbstractTask task : tasks) {
712	if (task instanceof LocalTask) {	936	if (task instanceof LocalTask) {
713	String string = task.getHandleIdentifier().substring(task.getHandleIdentifier().lastIndexOf('-') + 1,	937	String string = task.getHandleIdentifier().substring(
714	task.getHandleIdentifier().length());	938	task.getHandleIdentifier().lastIndexOf('-') + 1, task.getHandleIdentifier().length());
715	try {	939	try {
716	ihandle = Integer.parseInt(string);	940	ihandle = Integer.parseInt(string);
717	} catch (NumberFormatException nfe) {	941	} catch (NumberFormatException nfe) {
Lines 743-754 Link Here
743	task.addParentContainer(legacyCategory);	967	task.addParentContainer(legacyCategory);
744	legacyCategory.internalAddChild(task);	968	legacyCategory.internalAddChild(task);
745	} else {	969	} else {
746	this.internalAddTask(task, this.getArchiveContainer());	970	this.internalAddTask(task, null);
747	}	971	}
748		972
749	this.setActive(task, task.isActive());	973	this.setActive(task, task.isActive());
750	}	974	}
751		975
		976	/**
		977	* Internal API
		978	*/
		979	public void addOrphanContainer(OrphanedTasksContainer orphanedTasksContainer) {
		980	repositoryOrphansMap.put(orphanedTasksContainer.getRepositoryUrl(), orphanedTasksContainer);
		981	}
		982
		983	/**
		984	* Internal API
		985	*/
		986	public void removeOrphanContainer(String url) {
		987	if (url != null && !url.equals(LocalRepositoryConnector.REPOSITORY_URL)) {
		988	repositoryOrphansMap.remove(url);
		989	}
		990	}
		991
752	// /**	992	// /**
753	// * Orphaned hits arise when no query in the tasklist references a hit in the	993	// * Orphaned hits arise when no query in the tasklist references a hit in the
754	// * master list maintained by the tasklist. Orphaned hits don't span	994	// * master list maintained by the tasklist. Orphaned hits don't span

Lines 28-34 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/core/LocalTask.java (-2 / +2 lines)
28		28
29	@Override	29	@Override
30	public String getConnectorKind() {	30	public String getConnectorKind() {
31	return LocalRepositoryConnector.REPOSITORY_KIND;	31	return LocalRepositoryConnector.CONNECTOR_KIND;
32	}	32	}
33		33
34	@Override	34	@Override
Lines 43-49 Link Here
43		43
44	@Override	44	@Override
45	public String getOwner() {	45	public String getOwner() {
46	return LocalRepositoryConnector.REPOSITORY_KIND;	46	return LocalRepositoryConnector.CONNECTOR_KIND;
47	}	47	}
48		48
49	@Override	49	@Override

Lines 29-35 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/core/LocalRepositoryConnector.java (-2 / +2 lines)
29		29
30	public static final String REPOSITORY_LABEL = "Local Tasks";	30	public static final String REPOSITORY_LABEL = "Local Tasks";
31		31
32	public static final String REPOSITORY_KIND = "local";	32	public static final String CONNECTOR_KIND = "local";
33		33
34	public static final String REPOSITORY_URL = "local";	34	public static final String REPOSITORY_URL = "local";
35		35
Lines 70-76 Link Here
70		70
71	@Override	71	@Override
72	public String getConnectorKind() {	72	public String getConnectorKind() {
73	return REPOSITORY_KIND;	73	return CONNECTOR_KIND;
74	}	74	}
75		75
76	@Override	76	@Override

Lines 8-14 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/core/TaskArchive.java (-1 / +33 lines)
8		8
9	package org.eclipse.mylyn.internal.tasks.core;	9	package org.eclipse.mylyn.internal.tasks.core;
10		10
		11	import java.util.HashSet;
		12	import java.util.Set;
		13
		14	import org.eclipse.mylyn.tasks.core.AbstractTask;
11	import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;	15	import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;
		16	import org.eclipse.mylyn.tasks.core.TaskList;
12	import org.eclipse.mylyn.tasks.core.AbstractTask.PriorityLevel;	17	import org.eclipse.mylyn.tasks.core.AbstractTask.PriorityLevel;
13		18
14	/**	19	/**
Lines 20-27 Link Here
20		25
21	public static final String LABEL_ARCHIVE = "Archive (all tasks)";	26	public static final String LABEL_ARCHIVE = "Archive (all tasks)";
22		27
23	public TaskArchive() {	28	public TaskList taskList;
		29
		30	public TaskArchive(TaskList taskList) {
24	super(HANDLE);	31	super(HANDLE);
		32	this.taskList = taskList;
25	}	33	}
26		34
27	@Override	35	@Override
Lines 43-46 Link Here
43	public boolean isUserDefined() {	51	public boolean isUserDefined() {
44	return false;	52	return false;
45	}	53	}
		54
		55	@Override
		56	public Set<AbstractTask> getChildren() {
		57	Set<AbstractTask> children = new HashSet<AbstractTask>();
		58	for (OrphanedTasksContainer container : taskList.getOrphanContainers()) {
		59	children.addAll(container.getChildren());
		60	}
		61	return children;
		62	}
		63
		64	@Override
		65	public Set<AbstractTask> getChildrenInternal() {
		66	return getChildren();
		67	}
		68
		69	@Override
		70	public void internalAddChild(AbstractTask task) {
		71	// ignore
		72	}
		73
		74	@Override
		75	public void internalRemoveChild(AbstractTask task) {
		76	// ignore
		77	}
46	}	78	}

Added Link Here

(-).refactorings/2007/12/50/refactorings.index (+2 lines)
1	1197444181049 Extract constant 'MAX_ORPHAN_DEPTH'
2	1197481653716 Rename field 'MAX_ORPHAN_DEPTH'

Added Link Here

(-).refactorings/2007/12/49/refactorings.history (+3 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<session version="1.0"> <refactoring comment="Copy 1 elements(s) to 'org.eclipse.mylyn.tasks.core/src/org.eclipse.mylyn.internal.tasks.core' - Original project: 'org.eclipse.mylyn.tasks.core' - Destination element: 'org.eclipse.mylyn.tasks.core/src/org.eclipse.mylyn.internal.tasks.core' - Original element: 'org.eclipse.mylyn.internal.tasks.core.UnfiledCategory.java'" description="Copy compilation unit" destination="/src<org.eclipse.mylyn.internal.tasks.core" element1="/src<org.eclipse.mylyn.internal.tasks.core{UnfiledCategory.java" files="0" flags="589830" folders="0" id="org.eclipse.jdt.ui.copy" policy="org.eclipse.jdt.ui.copyResources" stamp="1196888061065" units="1" version="1.0"/> <refactoring comment="Rename type 'org.eclipse.mylyn.internal.tasks.core.OrphanedTasks' to 'OrphanedTasksContainer' - Original project: 'org.eclipse.mylyn.tasks.core' - Original element: 'org.eclipse.mylyn.internal.tasks.core.OrphanedTasks' - Renamed element: 'org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer' - Update references to refactored element - Rename similarly named elements - Update fully qualified names in '.xml, .xsd' files - Update textual occurrences in comments and strings" description="Rename type 'OrphanedTasks'" flags="589830" id="org.eclipse.jdt.ui.rename.type" input="/src<org.eclipse.mylyn.internal.tasks.core{OrphanedTasks.java[OrphanedTasks" matchStrategy="1" name="OrphanedTasksContainer" patterns=".xml, .xsd" qualified="true" references="true" similarDeclarations="true" stamp="1196889544235" textual="false" version="1.0"/> <refactoring comment="Rename field 'orphanedTaskContainers' in 'org.eclipse.mylyn.tasks.core.TaskList' to 'repositoryOrphansMap' - Original project: 'org.eclipse.mylyn.tasks.core' - Original element: 'org.eclipse.mylyn.tasks.core.TaskList.orphanedTaskContainers' - Renamed element: 'org.eclipse.mylyn.tasks.core.TaskList.repositoryOrphansMap' - Update references to refactored element - Update textual occurrences in comments and strings" delegate="false" deprecate="false" description="Rename field 'orphanedTaskContainers'" flags="589826" getter="false" id="org.eclipse.jdt.ui.rename.field" input="/src<org.eclipse.mylyn.tasks.core{TaskList.java[TaskList^orphanedTaskContainers" name="repositoryOrphansMap" references="true" setter="false" stamp="1196902163343" textual="false" version="1.0"/> <refactoring comment="Rename method 'org.eclipse.mylyn.tasks.core.TaskList.getOrphanedContainer(...)' to 'getOrphanContainer' - Original project: 'org.eclipse.mylyn.tasks.core' - Original element: 'org.eclipse.mylyn.tasks.core.TaskList.getOrphanedContainer(...)' - Renamed element: 'org.eclipse.mylyn.tasks.core.TaskList.getOrphanContainer(...)' - Update references to refactored element" delegate="false" deprecate="false" description="Rename method 'getOrphanedContainer'" flags="589830" id="org.eclipse.jdt.ui.rename.method" input="/src<org.eclipse.mylyn.tasks.core{TaskList.java[TaskList~getOrphanedContainer~QString;" name="getOrphanContainer" references="true" stamp="1196916697413" version="1.0"/> <refactoring comment="Rename field 'REPOSITORY_KIND' in 'org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector' to 'CONNECTOR_KIND' - Original project: 'org.eclipse.mylyn.tasks.core' - Original element: 'org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector.REPOSITORY_KIND' - Renamed element: 'org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector.CONNECTOR_KIND' - Update references to refactored element - Update textual occurrences in comments and strings" delegate="false" deprecate="false" description="Rename field 'REPOSITORY_KIND'" flags="589830" getter="false" id="org.eclipse.jdt.ui.rename.field" input="/src<org.eclipse.mylyn.internal.tasks.core{LocalRepositoryConnector.java[LocalRepositoryConnector^REPOSITORY_KIND" name="CONNECTOR_KIND" references="true" setter="false" stamp="1196923680591" textual="false" version="1.0"/>
3	</session>

Added Link Here

(-).refactorings/2007/12/49/refactorings.index (+5 lines)
1	1196888061065 Copy compilation unit
2	1196889544235 Rename type 'OrphanedTasks'
3	1196902163343 Rename field 'orphanedTaskContainers'
4	1196916697413 Rename method 'getOrphanedContainer'
5	1196923680591 Rename field 'REPOSITORY_KIND'




/*******************************************************************************
 * Copyright (c) 2004, 2007 Mylyn project committers and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.core;

import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;
import org.eclipse.mylyn.tasks.core.AbstractTask.PriorityLevel;

/**
 * Holds orphaned or uncategorized tasks for a given repository
 * 
 * @author Rob Elves
 */
public class OrphanedTasksContainer extends AbstractTaskCategory {

	public static final String LABEL = "Uncategorized";

	public static final String HANDLE = "orphans";

	private String repositoryUrl;

	private String connectorKind;

	public OrphanedTasksContainer(String connectorKind, String repositoryUrl) {
		super(repositoryUrl + "-" + HANDLE);
		this.repositoryUrl = repositoryUrl;
		this.connectorKind = connectorKind;
	}

	@Override
	public String getPriority() {
		return PriorityLevel.P1.toString();
	}

	@Override
	public String getSummary() {
		return "Archive: " + getRepositoryUrl();
	}

	@Override
	public boolean isUserDefined() {
		return false;
	}

	public String getRepositoryUrl() {
		return repositoryUrl;
	}

	public String getConnectorKind() {
		return connectorKind;
	}

	/**
	 * setting will also refactor handle
	 */
	public void setRepositoryUrl(String repositoryUrl) {
		this.repositoryUrl = repositoryUrl;
		this.setHandleIdentifier(repositoryUrl + "-" + HANDLE);
	}

	@Override
	public boolean contains(String handle) {
		for (AbstractTask child : getChildrenInternal()) {
			if (child.getHandleIdentifier().equals(handle)) {
				return true;
			}
		}
		return false;
	}
}




/*******************************************************************************
 * Copyright (c) 2004, 2007 Mylyn project committers and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.core;

/**
 * @author Rob Elves
 */
public interface ITasksCoreConstants {

	public static final int MAX_SUBTASK_DEPTH = 10;

}

Added Link Here

(-).refactorings/2007/12/50/refactorings.history (+3 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<session version="1.0"> <refactoring comment="Extract constant 'org.eclipse.mylyn.tasks.core.TaskList.MAX_ORPHAN_DEPTH' from expression '10' - Original project: 'org.eclipse.mylyn.tasks.core' - Constant name: 'MAX_ORPHAN_DEPTH' - Constant expression: '10' - Declared visibility: 'private'" description="Extract constant 'MAX_ORPHAN_DEPTH'" flags="786432" id="org.eclipse.jdt.ui.extract.constant" input="/src<org.eclipse.mylyn.tasks.core{TaskList.java" name="MAX_ORPHAN_DEPTH" qualify="false" replace="false" selection="3215 2" stamp="1197444181049" version="1.0" visibility="2"/> <refactoring comment="Rename field 'MAX_ORPHAN_DEPTH' in 'org.eclipse.mylyn.tasks.core.TaskList' to 'MAX_SUBTASK_DEPTH' - Original project: 'org.eclipse.mylyn.tasks.core' - Original element: 'org.eclipse.mylyn.tasks.core.TaskList.MAX_ORPHAN_DEPTH' - Renamed element: 'org.eclipse.mylyn.tasks.core.TaskList.MAX_SUBTASK_DEPTH' - Update references to refactored element - Update textual occurrences in comments and strings" delegate="false" deprecate="false" description="Rename field 'MAX_ORPHAN_DEPTH'" flags="589826" getter="false" id="org.eclipse.jdt.ui.rename.field" input="/src<org.eclipse.mylyn.tasks.core{TaskList.java[TaskList^MAX_ORPHAN_DEPTH" name="MAX_SUBTASK_DEPTH" references="true" setter="false" stamp="1197481653716" textual="false" version="1.0"/>
3	</session>

Lines 11-23 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/TaskListTableSorter.java (-10 / +20 lines)
11	import org.eclipse.jface.dialogs.MessageDialog;	11	import org.eclipse.jface.dialogs.MessageDialog;
12	import org.eclipse.jface.viewers.Viewer;	12	import org.eclipse.jface.viewers.Viewer;
13	import org.eclipse.jface.viewers.ViewerSorter;	13	import org.eclipse.jface.viewers.ViewerSorter;
		14	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
		15	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
14	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;	16	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
15	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;
16	import org.eclipse.mylyn.internal.tasks.core.UnfiledCategory;	17	import org.eclipse.mylyn.internal.tasks.core.UnfiledCategory;
17	import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;	18	import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;
18	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;	19	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
19	import org.eclipse.mylyn.tasks.core.AbstractTask;	20	import org.eclipse.mylyn.tasks.core.AbstractTask;
20	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;	21	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
		22	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
21	import org.eclipse.ui.PlatformUI;	23	import org.eclipse.ui.PlatformUI;
22		24
23	/**	25	/**
Lines 74-88 Link Here
74	return 1;	76	return 1;
75	}	77	}
76		78
77	if (o1 instanceof UnfiledCategory && o2 instanceof AbstractTaskContainer) {	79	// OrphanedTasksContainer localArchive = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
78	return -1;	80	// LocalRepositoryConnector.REPOSITORY_URL);
79	} else if (o1 instanceof AbstractTaskContainer && o2 instanceof UnfiledCategory) {	81	// if (o1 == localArchive && o2 instanceof AbstractTaskContainer) {
		82	// return -1;
		83	// } else if (o1 instanceof AbstractTaskContainer && o2 == localArchive) {
		84	// return 1;
		85	// }
		86
		87	if (o1 instanceof AbstractTaskContainer && o2 instanceof UnfiledCategory) {
80	return 1;	88	return 1;
		89	} else if (o2 instanceof AbstractTaskContainer && o1 instanceof UnfiledCategory) {
		90	return -1;
81	}	91	}
82		92
83	if (o1 instanceof AbstractTaskContainer && o2 instanceof TaskArchive) {	93	if (o1 instanceof AbstractTaskContainer && o2 instanceof OrphanedTasksContainer) {
84	return -1;	94	return -1;
85	} else if (o2 instanceof AbstractTaskContainer && o1 instanceof TaskArchive) {	95	} else if (o2 instanceof AbstractTaskContainer && o1 instanceof OrphanedTasksContainer) {
86	return 1;	96	return 1;
87	}	97	}
88		98
Lines 150-156 Link Here
150		160
151	/**	161	/**
152	* Determine the sort order of two tasks by id/summary	162	* Determine the sort order of two tasks by id/summary
153	*	163	*
154	* @param element1	164	* @param element1
155	* @param element2	165	* @param element2
156	* @return sort order	166	* @return sort order
Lines 162-168 Link Here
162		172
163	/**	173	/**
164	* Return a sortable string in the format "key: summary"	174	* Return a sortable string in the format "key: summary"
165	*	175	*
166	* @param element	176	* @param element
167	* @return sortable string	177	* @return sortable string
168	* @deprecated Use getSortableFromElement()	178	* @deprecated Use getSortableFromElement()
Lines 181-192 Link Here
181		191
182	/**	192	/**
183	* Return a array of values to pass to taskKeyComparator.compare() for sorting	193	* Return a array of values to pass to taskKeyComparator.compare() for sorting
184	*	194	*
185	* @param element	195	* @param element
186	* @return String array[component, taskId, summary]	196	* @return String array[component, taskId, summary]
187	*/	197	*/
188	public static String[] getSortableFromElement(AbstractTaskContainer element) {	198	public static String[] getSortableFromElement(AbstractTaskContainer element) {
189	final String a[] = new String[] {"", null, element.getSummary()};	199	final String a[] = new String[] { "", null, element.getSummary() };
190		200
191	if (element instanceof AbstractTask) {	201	if (element instanceof AbstractTask) {
192	AbstractTask task1 = (AbstractTask) element;	202	AbstractTask task1 = (AbstractTask) element;




import org.eclipse.jface.viewers.TreeExpansionEvent;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.window.Window;
import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.TaskArchive;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;

									refreshJob.refresh();
									break;
								default:
									if (taskContainerDelta.getContainer() == null) {
											TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory())) {
										refreshJob.refresh();
									} else {
										refreshJob.refreshTask(taskContainerDelta.getContainer());

					subMenu = new MenuManager("New", ID_MENU_NEW);
					manager.add(subMenu);
				}

				subMenu.add(new Separator(ID_SEPARATOR_NEW_REPOSITORY));
				subMenu.add(action);
				subMenu.add(new Separator(ID_SEPARATOR_NEW_LOCAL));


		addAction(copyDetailsAction, manager, element);
		if (task != null && !task.isLocal()) {
			// TODO: if selection parent is an Orphan container don't add this action
//			addAction(cloneThisBugAction, manager, element);
			addAction(removeFromCategoryAction, manager, element);
		}

			} else if (action instanceof MarkTaskIncompleteAction) {
				action.setEnabled(false);
			} else if (action instanceof DeleteAction) {
				if (element instanceof TaskArchive || element instanceof UnfiledCategory
						|| element instanceof OrphanedTasksContainer)
					action.setEnabled(false);
				else
					action.setEnabled(true);

			refreshJob.forceRefresh();
		}
	}

	public void refresh() {
		refreshJob.forceRefresh();
//		if (expand) {

			Set<AbstractTaskContainer> containers = new HashSet<AbstractTaskContainer>(
					TasksUiPlugin.getTaskListManager().getTaskList().getQueriesForHandle(task.getHandleIdentifier()));
			containers.addAll(task.getParentContainers());
			containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(task.getRepositoryUrl()));
//			containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getArchiveContainer());
//			containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
			for (AbstractTaskContainer container : containers) {
				refreshJob.refreshTask(container);
			}




import org.eclipse.jface.viewers.IColorProvider;
import org.eclipse.jface.viewers.IFontProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
import org.eclipse.mylyn.internal.tasks.core.Person;
import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;


	private CompositeImageDescriptor getImageDescriptor(Object object) {
		CompositeImageDescriptor compositeDescriptor = new CompositeImageDescriptor();
		if (object instanceof TaskArchive || object instanceof OrphanedTasksContainer) {
			compositeDescriptor.icon = TasksUiImages.CATEGORY_ARCHIVE;
			return compositeDescriptor;
		} else if (object instanceof TaskCategory || object instanceof UnfiledCategory) {

		} else if (object instanceof TaskGroup) {
			TaskGroup element = (TaskGroup) object;
			return element.getSummary();// + " / " + element.getChildren().size();
		} else if (object instanceof OrphanedTasksContainer) {

			OrphanedTasksContainer container = (OrphanedTasksContainer) object;

//			OrphanedTasksContainer localArchive = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
//					LocalRepositoryConnector.REPOSITORY_URL);
//			if (container == localArchive) {
//				return "Local Tasks";
//			}

			String result = container.getSummary();
			TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(
					container.getConnectorKind(), container.getRepositoryUrl());
			if (repository != null) {
				result = "Archive: " + repository.getRepositoryLabel();
			}

			return result;

		} else if (object instanceof AbstractTaskContainer) {
			AbstractTaskContainer element = (AbstractTaskContainer) object;
			return element.getSummary();

Lines 26-31 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/TaskListDropAdapter.java (-6 / +19 lines)
26	import org.eclipse.jface.viewers.ViewerDropAdapter;	26	import org.eclipse.jface.viewers.ViewerDropAdapter;
27	import org.eclipse.mylyn.context.core.ContextCorePlugin;	27	import org.eclipse.mylyn.context.core.ContextCorePlugin;
28	import org.eclipse.mylyn.internal.context.core.InteractionContext;	28	import org.eclipse.mylyn.internal.context.core.InteractionContext;
		29	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
29	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;	30	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
30	import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;	31	import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;
31	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;	32	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
Lines 162-170 Link Here
162		163
163	for (AbstractTask task : tasksToMove) {	164	for (AbstractTask task : tasksToMove) {
164	if (currentTarget instanceof UnfiledCategory) {	165	if (currentTarget instanceof UnfiledCategory) {
165	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task, (UnfiledCategory) currentTarget);	166	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(task, (UnfiledCategory) currentTarget);
166	} else if (currentTarget instanceof TaskCategory) {	167	} else if (currentTarget instanceof TaskCategory) {
167	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task, (TaskCategory) currentTarget);	168	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(task, (TaskCategory) currentTarget);
		169	} else if (currentTarget instanceof OrphanedTasksContainer) {
		170	if (((OrphanedTasksContainer) currentTarget).getRepositoryUrl().equals(task.getRepositoryUrl())) {
		171	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(task,
		172	(AbstractTaskCategory) currentTarget);
		173	}
168	} else if (currentTarget instanceof AbstractTask) {	174	} else if (currentTarget instanceof AbstractTask) {
169	AbstractTask targetTask = (AbstractTask) currentTarget;	175	AbstractTask targetTask = (AbstractTask) currentTarget;
170	AbstractTaskCategory targetCategory = null;	176	AbstractTaskCategory targetCategory = null;
Lines 173-182 Link Here
173	AbstractTaskContainer container = targetTask.getParentContainers().iterator().next();	179	AbstractTaskContainer container = targetTask.getParentContainers().iterator().next();
174	if (container instanceof TaskCategory \|\| container instanceof UnfiledCategory) {	180	if (container instanceof TaskCategory \|\| container instanceof UnfiledCategory) {
175	targetCategory = (AbstractTaskCategory) container;	181	targetCategory = (AbstractTaskCategory) container;
		182	} else if (container instanceof OrphanedTasksContainer) {
		183	if (((OrphanedTasksContainer) container).getRepositoryUrl().equals(task.getRepositoryUrl())) {
		184	targetCategory = (AbstractTaskCategory) container;
		185	}
176	}	186	}
177	}	187	}
178	if (targetCategory != null) {	188	if (targetCategory != null) {
179	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task, targetCategory);	189	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(task, targetCategory);
180	}	190	}
181	} else if (currentTarget instanceof ScheduledTaskContainer) {	191	} else if (currentTarget instanceof ScheduledTaskContainer) {
182	ScheduledTaskContainer container = (ScheduledTaskContainer) currentTarget;	192	ScheduledTaskContainer container = (ScheduledTaskContainer) currentTarget;
Lines 185-192 Link Here
185	TaskActivityUtil.snapEndOfWorkDay(newSchedule);	195	TaskActivityUtil.snapEndOfWorkDay(newSchedule);
186	TasksUiPlugin.getTaskActivityManager().setScheduledFor(task, newSchedule.getTime());	196	TasksUiPlugin.getTaskActivityManager().setScheduledFor(task, newSchedule.getTime());
187	} else if (currentTarget == null) {	197	} else if (currentTarget == null) {
188	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(newTask,	198	// TasksUiPlugin.getTaskListManager().getTaskList().moveTask(
189	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());	199	// newTask,
		200	// TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
		201	// LocalRepositoryConnector.REPOSITORY_URL));
190	}	202	}
191	}	203	}
192		204
Lines 307-313 Link Here
307	// handle all files	319	// handle all files
308	return true;	320	return true;
309	} else if (TaskTransfer.getInstance().isSupportedType(currentTransfer)) {	321	} else if (TaskTransfer.getInstance().isSupportedType(currentTransfer)) {
310	if (getCurrentTarget() instanceof TaskCategory \|\| getCurrentTarget() instanceof UnfiledCategory	322	if (getCurrentTarget() instanceof UnfiledCategory \|\| getCurrentTarget() instanceof TaskCategory
		323	\|\| getCurrentTarget() instanceof OrphanedTasksContainer
311	\|\| getCurrentTarget() instanceof ScheduledTaskContainer) {	324	\|\| getCurrentTarget() instanceof ScheduledTaskContainer) {
312	return true;	325	return true;
313	} else if (getCurrentTarget() instanceof AbstractTaskContainer	326	} else if (getCurrentTarget() instanceof AbstractTaskContainer




	}

	private boolean taskHasUnfilteredChildren(AbstractTask parent) {
		boolean groupSubtasks = !TasksUiPlugin.getDefault().groupSubtasks(parent);
		if (groupSubtasks)
			return false;
		Set<AbstractTask> children = parent.getChildren();
		if (children != null) {
			for (AbstractTask task : children) {

			// get all children
			for (AbstractTask element : parentTasks) {
				for (AbstractTask abstractTask : element.getChildren()) {
					//if (!filter(element, abstractTask)) {
					children.add(abstractTask);
					//}
				}
			}
			for (AbstractTask task : parentTasks) {





package org.eclipse.mylyn.internal.tasks.ui.views;

import java.util.Set;

import org.eclipse.mylyn.context.core.ContextCorePlugin;
import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.internal.tasks.ui.AbstractTaskListFilter;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPreferenceConstants;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
import org.eclipse.mylyn.tasks.core.AbstractTask.RepositoryTaskSyncState;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;

						taskListView.synchronizationOverlaid));
			} else {
				int imageOffset = 0;
				if (!hideDecorationOnContainer(element, (TreeItem) event.item)
						&& AbstractTaskListFilter.hasDescendantIncoming(element)) {
					if (taskListView.synchronizationOverlaid) {
						image = TasksUiImages.getImage(TasksUiImages.OVERLAY_SYNCH_INCOMMING);
					} else {

	}

	private boolean hideDecorationOnContainer(AbstractTaskContainer element, TreeItem treeItem) {
		if (element instanceof OrphanedTasksContainer) {
			return true;
		} else if (!taskListView.isFocusedMode()) {
			return false;

		}
	}

	/**
	 * NOTE: performance implication of looking down children
	 */
	private boolean hasDescendantIncoming(AbstractTaskContainer container) {
		Set<AbstractTask> children = container.getChildren();
		if (children == null) {
			return false;
		}

		for (AbstractTask task : children) {
			if (task != null) {
				AbstractTask containedRepositoryTask = task;
				if (containedRepositoryTask.getSynchronizationState() == RepositoryTaskSyncState.INCOMING) {
					return true;
				} else if (TasksUiPlugin.getDefault().groupSubtasks(container) && hasDescendantIncoming(task)) {
					return true;
				}
			}
		}
		return false;
	}

	private void drawActivationImage(final int activationImageOffset, Event event, Image image) {
		Rectangle rect = image.getBounds();
		int offset = Math.max(0, (event.height - rect.height) / 2);

Lines 154-160 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskPlanningEditor.java (-1 / +3 lines)
154	if (PlatformUI.getWorkbench() != null && !PlatformUI.getWorkbench().isClosing()) {	154	if (PlatformUI.getWorkbench() != null && !PlatformUI.getWorkbench().isClosing()) {
155	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {	155	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
156	public void run() {	156	public void run() {
157	updateTaskData(updateTask);	157	if (summaryEditor != null && summaryEditor.getTextWidget() != null) {
		158	updateTaskData(updateTask);
		159	}
158	}	160	}
159	});	161	});
160	}	162	}




import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;


					TreeItem item = this.view.getViewer().getTree().getSelection()[0];
					Set<AbstractTaskContainer> parentContainers = task.getParentContainers();

					if (item.getParentItem() != null && item.getParent().getData() instanceof TaskCategory) {
						TaskCategory category = (TaskCategory) item.getParentItem().getData();
						TasksUiPlugin.getTaskListManager().getTaskList().removeFromCategory(category, task);
					}
//						TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task,
//								TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
					else if (!parentContainers.isEmpty() && parentContainers.iterator().next() instanceof TaskCategory) {
						TasksUiPlugin.getTaskListManager().getTaskList().removeFromCategory(
								(TaskCategory) parentContainers.iterator().next(), task);
						//TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task, null);
					}/* else if (parentContainers.contains(TasksUiPlugin.getTaskListManager()
																																.getTaskList()
																																.getDefaultCategory())) {
																															MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
																																	LABEL, "Can not remove from the default category, move to another category instead.");
																														}*/else {
						TasksUiPlugin.getTaskListManager().getTaskList().moveTask(task,
								TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
					}
					
					if (item.getParentItem() != null && item.getParentItem().getData() instanceof TaskCategory) {

					}
				}
			}
		} catch (NullPointerException npe) {




		setId(ID);
		setActionDefinitionId(DEFINITION_ID);
		setImageDescriptor(TasksUiImages.OVERLAY_INCOMMING);
//		if (containsArchiveContainer(selectedElements)) {
//			setEnabled(false);
//		} else {
		if (selectedElements.size() == 1 && (selectedElements.get(0) instanceof AbstractTask)) {
			AbstractTask task = (AbstractTask) selectedElements.get(0);
			setEnabled(!task.isLocal());
		} else {
			setEnabled(true);
				AbstractTask task = (AbstractTask) selectedElements.get(0);
				setEnabled(!task.isLocal());
			} else {
				setEnabled(true);
			}
		}
//		}
	}

	@Override

Lines 21-27 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/actions/FilterArchiveContainerAction.java (-1 / +1 lines)
21		21
22	public static final String ID = "org.eclipse.mylyn.tasklist.actions.filter.archive";	22	public static final String ID = "org.eclipse.mylyn.tasklist.actions.filter.archive";
23		23
24	private static final String LABEL = "Filter Archive Category";	24	private static final String LABEL = "Filter Archives";
25		25
26	private final TaskListView view;	26	private final TaskListView view;
27		27

Lines 14-20 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/actions/AbstractTaskAction.java (-2 / +1 lines)
14	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;	14	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
15	import org.eclipse.mylyn.tasks.core.AbstractTask;	15	import org.eclipse.mylyn.tasks.core.AbstractTask;
16	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;	16	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
17	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
18		17
19	/**	18	/**
20	* @author Rob Elves	19	* @author Rob Elves
Lines 49-55 Link Here
49	protected abstract void performActionOnTask(AbstractTask repositoryTask);	48	protected abstract void performActionOnTask(AbstractTask repositoryTask);
50		49
51	protected boolean containsArchiveContainer(List<AbstractTaskContainer> selectedElements) {	50	protected boolean containsArchiveContainer(List<AbstractTaskContainer> selectedElements) {
52	return selectedElements.contains(TasksUiPlugin.getTaskListManager().getTaskList().getArchiveContainer());	51	return false;//selectedElements.contains(TasksUiPlugin.getTaskListManager().getTaskList().getArchiveContainer());
53	}	52	}
54		53
55	}	54	}

Lines 61-68 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/actions/OpenRepositoryTask.java (-2 / +1 lines)
61	*/	61	*/
62	private void openExistingTask(RemoteTaskSelectionDialog dlg) {	62	private void openExistingTask(RemoteTaskSelectionDialog dlg) {
63	if (dlg.shouldAddToTaskList()) {	63	if (dlg.shouldAddToTaskList()) {
64	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(dlg.getSelectedTask(),	64	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(dlg.getSelectedTask(), dlg.getSelectedCategory());
65	dlg.getSelectedCategory());
66	}	65	}
67	TasksUiUtil.refreshAndOpenTaskListElement(dlg.getSelectedTask());	66	TasksUiUtil.refreshAndOpenTaskListElement(dlg.getSelectedTask());
68	}	67	}




	public static final String ID = "org.eclipse.mylyn.tasklist.actions.mark.read";

	public static final String DEFINITION_ID = "org.eclipse.mylyn.tasks.ui.command.markTaskRead";

	public MarkTaskReadAction(List<AbstractTaskContainer> selectedElements) {
		super.selectedElements = selectedElements;
		setText(ACTION_NAME);
		setToolTipText("Mark " + ACTION_NAME);
		setId(ID);
		setActionDefinitionId(DEFINITION_ID);
//		if (containsArchiveContainer(selectedElements)) {
//			setEnabled(false);
//		} else {
		setEnabled(selectedElements.size() > 0);
		if (selectedElements.size() == 1 && (selectedElements.get(0) instanceof AbstractTask)) {
			AbstractTask task = (AbstractTask) selectedElements.get(0);
			setEnabled(!(task instanceof LocalTask));
		} else {
			setEnabled(true);
			if (selectedElements.size() == 1 && (selectedElements.get(0) instanceof AbstractTask)) {
				AbstractTask task = (AbstractTask) selectedElements.get(0);
				setEnabled(!(task instanceof LocalTask));
			} else {
				setEnabled(true);
			}
		}
//		}
	}

	@Override

Lines 296-308 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/util/DelegatingTaskExternalizer.java (-5 / +9 lines)
296	boolean hasCaughtException = false;	296	boolean hasCaughtException = false;
297	Element element = (Element) node;	297	Element element = (Element) node;
298		298
299	AbstractTaskCategory category;	299	AbstractTaskCategory category = null;
300	if (element.hasAttribute(DelegatingTaskExternalizer.KEY_NAME)) {	300	if (element.hasAttribute(DelegatingTaskExternalizer.KEY_NAME)) {
301	category = new TaskCategory(element.getAttribute(DelegatingTaskExternalizer.KEY_NAME));	301	category = new TaskCategory(element.getAttribute(DelegatingTaskExternalizer.KEY_NAME));
302	taskList.internalAddCategory((TaskCategory) category);	302	taskList.internalAddCategory((TaskCategory) category);
303	} else {	303	} else {
304	// LEGACY: registry categories did not have names	304	// LEGACY: registry categories did not have names
305	category = taskList.getArchiveContainer();	305	// category = taskList.getArchiveContainer();
		306	// a null category will now go into appropriate orphaned category
306	}	307	}
307		308
308	NodeList list = node.getChildNodes();	309	NodeList list = node.getChildNodes();
Lines 311-317 Link Here
311	try {	312	try {
312	// LEGACY: categories used to contain tasks?	313	// LEGACY: categories used to contain tasks?
313	AbstractTask task = readTask(child, category, null);	314	AbstractTask task = readTask(child, category, null);
314	category.internalAddChild(task);	315	if (category != null) {
		316	category.internalAddChild(task);
		317	}
315	taskList.insertTask(task, category, null);	318	taskList.insertTask(task, category, null);
316	} catch (Throwable t) {	319	} catch (Throwable t) {
317	hasCaughtException = true;	320	hasCaughtException = true;
Lines 379-385 Link Here
379	// return task;	382	// return task;
380	// }	383	// }
381		384
382	private void readTaskInfo(AbstractTask task, Element element, AbstractTask parent, AbstractTaskCategory legacyCategory) throws TaskExternalizationException {	385	private void readTaskInfo(AbstractTask task, Element element, AbstractTask parent,
		386	AbstractTaskCategory legacyCategory) throws TaskExternalizationException {
383	if (task == null) {	387	if (task == null) {
384	return;	388	return;
385	}	389	}
Lines 404-410 Link Here
404	// taskList.internalAddTask(task, taskList.getArchiveContainer());	408	// taskList.internalAddTask(task, taskList.getArchiveContainer());
405	// }	409	// }
406	task.setCategoryHandle(element.getAttribute(KEY_CATEGORY));	410	task.setCategoryHandle(element.getAttribute(KEY_CATEGORY));
407		411
408	if (element.hasAttribute(KEY_PRIORITY)) {	412	if (element.hasAttribute(KEY_PRIORITY)) {
409	task.setPriority(element.getAttribute(KEY_PRIORITY));	413	task.setPriority(element.getAttribute(KEY_PRIORITY));
410	} else {	414	} else {

Lines 23-28 Link Here

(-)src/org/eclipse/mylyn/tasks/ui/editors/AbstractNewRepositoryTaskEditor.java (-1 / +2 lines)
23	import org.eclipse.jface.viewers.IStructuredSelection;	23	import org.eclipse.jface.viewers.IStructuredSelection;
24	import org.eclipse.jface.viewers.SelectionChangedEvent;	24	import org.eclipse.jface.viewers.SelectionChangedEvent;
25	import org.eclipse.jface.viewers.StructuredSelection;	25	import org.eclipse.jface.viewers.StructuredSelection;
		26	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
26	import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;	27	import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;
27	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;	28	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
28	import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;	29	import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;
Lines 492-498 Link Here
492	.getSelection()).getFirstElement();	493	.getSelection()).getFirstElement();
493		494
494	if (selectedObject instanceof TaskCategory) {	495	if (selectedObject instanceof TaskCategory) {
495	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(newTask,	496	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(newTask,
496	((TaskCategory) selectedObject));	497	((TaskCategory) selectedObject));
497	}	498	}
498	}	499	}

Lines 3553-3559 Link Here

(-)src/org/eclipse/mylyn/tasks/ui/editors/AbstractRepositoryTaskEditor.java (-1 / +1 lines)
3553	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {	3553	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
3554	public void run() {	3554	public void run() {
3555	if (getCategory() != null) {	3555	if (getCategory() != null) {
3556	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(newTask, getCategory());	3556	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(newTask, getCategory());
3557	}	3557	}
3558	}	3558	}
3559	});	3559	});




			// initialized
			taskListManager.init();
			taskListManager.addActivityListener(CONTEXT_TASK_ACTIVITY_LISTENER);
			// readExistingOrCreateNewList() must be called after repositories have been read in
			taskListManager.readExistingOrCreateNewList();
			initialized = true;



		// Add standard local task repository
		if (taskRepositoryManager.getRepository(LocalRepositoryConnector.REPOSITORY_URL) == null) {
			TaskRepository localRepository = new TaskRepository(LocalRepositoryConnector.CONNECTOR_KIND,
					LocalRepositoryConnector.REPOSITORY_URL, LocalRepositoryConnector.REPOSITORY_VERSION);
			localRepository.setRepositoryLabel(LocalRepositoryConnector.REPOSITORY_LABEL);
			localRepository.setAnonymous(true);

	 * @param withProgress
	 */
	public void reloadDataDirectory(boolean withProgress) {
		getTaskListManager().resetTaskList();
		getTaskListManager().getTaskActivationHistory().clear();
		getRepositoryManager().readRepositories(getRepositoriesFilePath());
		loadTemplateRepositories();
		getTaskListManager().resetTaskList();
		getTaskListManager().setTaskListFile(
				new File(getDataDirectory() + File.separator + ITasksUiConstants.DEFAULT_TASK_LIST_FILE));
		ContextCorePlugin.getContextManager().loadActivityMetaContext();
		getTaskListManager().readExistingOrCreateNewList();
		getTaskListManager().initActivityHistory();
		checkForCredentials();

	 * 
	 * @Deprecated
	 */
	public TaskListNotification getIncommingNotification(AbstractRepositoryConnector connector, AbstractTask task) {
			AbstractTask task) {

		TaskListNotification notification = new TaskListNotification(task);
		RepositoryTaskData newTaskData = getTaskDataManager().getNewTaskData(task.getRepositoryUrl(), task.getTaskId());

				if (!"".equals(chnagedAttributes)) {
					description.append(chnagedAttributes);
				}

				notification.setDescription(description.toString());

				if (connector != null) {

Lines 33-38 Link Here

(-)src/org/eclipse/mylyn/tasks/ui/TaskListManager.java (-3 / +18 lines)
33	import org.eclipse.mylyn.internal.context.core.InteractionContextManager;	33	import org.eclipse.mylyn.internal.context.core.InteractionContextManager;
34	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;	34	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
35	import org.eclipse.mylyn.internal.tasks.core.LocalTask;	35	import org.eclipse.mylyn.internal.tasks.core.LocalTask;
		36	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
36	import org.eclipse.mylyn.internal.tasks.core.RepositoryTaskHandleUtil;	37	import org.eclipse.mylyn.internal.tasks.core.RepositoryTaskHandleUtil;
37	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;	38	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
38	import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;	39	import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;
Lines 109-116 Link Here
109		110
110	private TaskListSaveManager taskListSaveManager;	111	private TaskListSaveManager taskListSaveManager;
111		112
112	// TODO: guard against overwriting the single instance?	113	private final TaskList taskList = new TaskList();
113	private TaskList taskList = new TaskList();
114		114
115	private TaskActivationHistory taskActivityHistory = new TaskActivationHistory();	115	private TaskActivationHistory taskActivityHistory = new TaskActivationHistory();
116		116
Lines 157-166 Link Here
157	public TaskList resetTaskList() {	157	public TaskList resetTaskList() {
158	resetAndRollOver();	158	resetAndRollOver();
159	taskList.reset();	159	taskList.reset();
		160	prepareOrphanContainers();
		161
160	taskListInitialized = true;	162	taskListInitialized = true;
161	return taskList;	163	return taskList;
162	}	164	}
163		165
		166	private void prepareOrphanContainers() {
		167	for (TaskRepository repository : TasksUiPlugin.getRepositoryManager().getAllRepositories()) {
		168	if (!repository.getConnectorKind().equals(LocalRepositoryConnector.CONNECTOR_KIND)) {
		169	taskList.addOrphanContainer(new OrphanedTasksContainer(repository.getConnectorKind(),
		170	repository.getUrl()));
		171	}
		172	}
		173
		174	// taskList.addOrphanContainer(new OrphanedTasksContainer(LocalRepositoryConnector.CONNECTOR_KIND,
		175	// LocalRepositoryConnector.REPOSITORY_URL));
		176	}
		177
164	public void refactorRepositoryUrl(String oldUrl, String newUrl) {	178	public void refactorRepositoryUrl(String oldUrl, String newUrl) {
165	if (oldUrl == null \|\| newUrl == null \|\| oldUrl.equals(newUrl)) {	179	if (oldUrl == null \|\| newUrl == null \|\| oldUrl.equals(newUrl)) {
166	return;	180	return;
Lines 262-267 Link Here
262	public boolean readExistingOrCreateNewList() {	276	public boolean readExistingOrCreateNewList() {
263	try {	277	try {
264	if (taskListFile.exists()) {	278	if (taskListFile.exists()) {
		279	prepareOrphanContainers();
265	taskListWriter.readTaskList(taskList, taskListFile, TasksUiPlugin.getTaskDataManager());	280	taskListWriter.readTaskList(taskList, taskListFile, TasksUiPlugin.getTaskDataManager());
266	} else {	281	} else {
267	resetTaskList();	282	resetTaskList();
Lines 506-512 Link Here
506	MessageDialog.openInformation(Display.getCurrent().getActiveShell(), ITasksUiConstants.TITLE_DIALOG,	521	MessageDialog.openInformation(Display.getCurrent().getActiveShell(), ITasksUiConstants.TITLE_DIALOG,
507	"The new task has been added to the root of the list, since tasks can not be added to a query.");	522	"The new task has been added to the root of the list, since tasks can not be added to a query.");
508	}	523	}
509	taskList.addTask(newTask, taskList.getDefaultCategory());	524	taskList.addTask(newTask, TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
510	}	525	}
511	return newTask;	526	return newTask;
512	}	527	}

Lines 47-53 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/LocalTaskConnectorUi.java (-1 / +1 lines)
47		47
48	@Override	48	@Override
49	public String getConnectorKind() {	49	public String getConnectorKind() {
50	return LocalRepositoryConnector.REPOSITORY_KIND;	50	return LocalRepositoryConnector.CONNECTOR_KIND;
51	}	51	}
52		52
53	@Override	53	@Override

Lines 47-53 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/TaskRepositoryAdapterFactory.java (-1 / +1 lines)
47	.getRepositoryConnector(repository.getConnectorKind());	47	.getRepositoryConnector(repository.getConnectorKind());
48	return connector.canCreateNewTask(repository);	48	return connector.canCreateNewTask(repository);
49	} else if ("hasRepository".equals(name)) {	49	} else if ("hasRepository".equals(name)) {
50	return !repository.getConnectorKind().equals(LocalRepositoryConnector.REPOSITORY_KIND);	50	return !repository.getConnectorKind().equals(LocalRepositoryConnector.CONNECTOR_KIND);
51	}	51	}
52	return false;	52	return false;
53	}	53	}

Lines 7-12 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/TaskArchiveFilter.java (+8 lines)
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylyn.internal.tasks.ui;	8	package org.eclipse.mylyn.internal.tasks.ui;
9		9
		10	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
		11	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
10	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;	12	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;
11		13
12	/**	14	/**
Lines 16-21 Link Here
16		18
17	@Override	19	@Override
18	public boolean select(Object parent, Object element) {	20	public boolean select(Object parent, Object element) {
		21	if (element instanceof OrphanedTasksContainer) {
		22	// if (((OrphanedTasksContainer) element).getRepositoryUrl().equals(LocalRepositoryConnector.REPOSITORY_URL)) {
		23	// return true;
		24	// }
		25	return false;
		26	}
19	if (element instanceof TaskArchive) {	27	if (element instanceof TaskArchive) {
20	return false;	28	return false;
21	}	29	}




import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
import org.eclipse.mylyn.internal.tasks.ui.actions.NewCategoryAction;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;

				.getCategories());
		Collections.sort(categories);
		for (final AbstractTaskCategory category : categories) {
			if (!(category instanceof OrphanedTasksContainer)) {
				Action action = new Action() {
					@Override
					public void run() {

	private void moveToCategory(final List<AbstractTaskContainer> selectedElements, AbstractTaskCategory category) {
		for (AbstractTaskContainer element : selectedElements) {
			if (element instanceof AbstractTask) {
				TasksUiPlugin.getTaskListManager().getTaskList().moveTask((AbstractTask) element, category);
			}
		}
	}




import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;

							if (selectedObject instanceof TaskCategory) {
								category = (TaskCategory) selectedObject;
							} else {
								category = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
										LocalRepositoryConnector.REPOSITORY_URL);
							}
						}
						TasksUiPlugin.getTaskListManager().getTaskList().moveTask(newTask, category);
						taskListView.getViewer().setSelection(new StructuredSelection(newTask));
					}
				});

		}
		return Status.OK_STATUS;
	}

}

Lines 7-12 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/AbstractTaskListFilter.java (+37 lines)
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylyn.internal.tasks.ui;	8	package org.eclipse.mylyn.internal.tasks.ui;
9		9
		10	import java.util.Set;
		11
		12	import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;
		13	import org.eclipse.mylyn.tasks.core.AbstractTask;
		14	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
		15	import org.eclipse.mylyn.tasks.core.AbstractTask.RepositoryTaskSyncState;
		16	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
		17
10	/**	18	/**
11	* Custom filters are used so that the "Find:" filter can 'see through' any filters that may have been applied.	19	* Custom filters are used so that the "Find:" filter can 'see through' any filters that may have been applied.
12	*	20	*
Lines 16-19 Link Here
16		24
17	public abstract boolean select(Object parent, Object element);	25	public abstract boolean select(Object parent, Object element);
18		26
		27	/**
		28	* NOTE: performance implication of looking down children
		29	*
		30	* TODO: Move to an internal utility class
		31	*/
		32	public static boolean hasDescendantIncoming(AbstractTaskContainer container) {
		33	return hasDescendantIncoming(container, ITasksCoreConstants.MAX_SUBTASK_DEPTH);
		34	}
		35
		36	private static boolean hasDescendantIncoming(AbstractTaskContainer container, int depth) {
		37	Set<AbstractTask> children = container.getChildren();
		38	if (children == null \|\| depth <= 0) {
		39	return false;
		40	}
		41
		42	for (AbstractTask task : children) {
		43	if (task != null) {
		44	AbstractTask containedRepositoryTask = task;
		45	if (containedRepositoryTask.getSynchronizationState() == RepositoryTaskSyncState.INCOMING) {
		46	return true;
		47	} else if (TasksUiPlugin.getDefault().groupSubtasks(container)
		48	&& hasDescendantIncoming(task, depth - 1)) {
		49	return true;
		50	}
		51	}
		52	}
		53	return false;
		54	}
		55
19	}	56	}




 *******************************************************************************/
package org.eclipse.mylyn.internal.tasks.ui;

import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;

/**
 * @author Mik Kersten

	public boolean select(Object parent, Object element) {
		if (element instanceof AbstractTask) {
			AbstractTask task = (AbstractTask) element;

			if (task.isCompleted()
					&& TaskListView.getFromActivePerspective() != null
					&& !TaskListView.getFromActivePerspective().isFocusedMode()
					&& TasksUiPlugin.getDefault().getPreferenceStore().getBoolean(
							TasksUiPreferenceConstants.FILTER_COMPLETE_MODE)) {
				// but has child with incoming don't filter
				return (hasDescendantIncoming(task));
			}

			return !task.isCompleted();
		}
		return true;

Lines 159-165 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/wizards/SelectRepositoryPage.java (-1 / +1 lines)
159	viewer.setSelection(new StructuredSelection(selectedRepository));	159	viewer.setSelection(new StructuredSelection(selectedRepository));
160	} else {	160	} else {
161	TaskRepository localRepository = TasksUiPlugin.getRepositoryManager().getRepository(	161	TaskRepository localRepository = TasksUiPlugin.getRepositoryManager().getRepository(
162	LocalRepositoryConnector.REPOSITORY_KIND, LocalRepositoryConnector.REPOSITORY_URL);	162	LocalRepositoryConnector.CONNECTOR_KIND, LocalRepositoryConnector.REPOSITORY_URL);
163	viewer.setSelection(new StructuredSelection(localRepository));	163	viewer.setSelection(new StructuredSelection(localRepository));
164	}	164	}
165		165




import org.eclipse.mylyn.internal.monitor.core.util.ZipFileUtil;
import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;
import org.eclipse.mylyn.monitor.core.StatusHandler;
import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.TaskList;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.ui.IImportWizard;
import org.eclipse.ui.IWorkbench;

		}
	}

//	/** Returns all tasks in the task list root or a category in the task list */
//	protected List<AbstractTask> getAllTasks() {
//		List<AbstractTask> allTasks = new ArrayList<AbstractTask>();
//		TaskList taskList = TasksUiPlugin.getTaskListManager().getTaskList();
//
//		allTasks.addAll(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).getChildren());
//
//		for (AbstractTaskContainer category : taskList.getCategories()) {
//			allTasks.addAll(category.getChildren());
//		}
//
//		return allTasks;
//	}

	private void readTaskListData() {
		PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {

Lines 31-36 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/workingsets/TaskWorkingSetPage.java (+9 lines)
31	import org.eclipse.jface.viewers.Viewer;	31	import org.eclipse.jface.viewers.Viewer;
32	import org.eclipse.jface.viewers.ViewerSorter;	32	import org.eclipse.jface.viewers.ViewerSorter;
33	import org.eclipse.jface.wizard.WizardPage;	33	import org.eclipse.jface.wizard.WizardPage;
		34	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
34	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;	35	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;
35	import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;	36	import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;
36	import org.eclipse.mylyn.internal.tasks.ui.views.TaskElementLabelProvider;	37	import org.eclipse.mylyn.internal.tasks.ui.views.TaskElementLabelProvider;
Lines 138-143 Link Here
138	taskContainers.add(element);	139	taskContainers.add(element);
139	}	140	}
140	}	141	}
		142
		143	OrphanedTasksContainer orphansContainer = TasksUiPlugin.getTaskListManager()
		144	.getTaskList()
		145	.getOrphanContainer(((TaskRepository) parentElement).getUrl());
		146	if (orphansContainer != null) {
		147	taskContainers.add(orphansContainer);
		148	}
		149
141	return taskContainers.toArray();	150	return taskContainers.toArray();
142	} else if (parentElement instanceof TaskRepositoryProjectMapping) {	151	} else if (parentElement instanceof TaskRepositoryProjectMapping) {
143	return ((TaskRepositoryProjectMapping) parentElement).getProjects().toArray();	152	return ((TaskRepositoryProjectMapping) parentElement).getProjects().toArray();

Lines 33-38 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/commands/RemoteTaskSelectionDialog.java (+1 lines)
33	import org.eclipse.jface.viewers.Viewer;	33	import org.eclipse.jface.viewers.Viewer;
34	import org.eclipse.jface.viewers.ViewerFilter;	34	import org.eclipse.jface.viewers.ViewerFilter;
35	import org.eclipse.mylyn.internal.tasks.core.ITaskRepositoryFilter;	35	import org.eclipse.mylyn.internal.tasks.core.ITaskRepositoryFilter;
		36	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
36	import org.eclipse.mylyn.internal.tasks.ui.ITaskCommandIds;	37	import org.eclipse.mylyn.internal.tasks.ui.ITaskCommandIds;
37	import org.eclipse.mylyn.internal.tasks.ui.views.TaskElementLabelProvider;	38	import org.eclipse.mylyn.internal.tasks.ui.views.TaskElementLabelProvider;
38	import org.eclipse.mylyn.internal.tasks.ui.views.TaskRepositoryLabelProvider;	39	import org.eclipse.mylyn.internal.tasks.ui.views.TaskRepositoryLabelProvider;

Lines 19-24 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/planner/TaskActivityWizardPage.java (-1 / +2 lines)
19		19
20	import org.eclipse.jface.layout.GridDataFactory;	20	import org.eclipse.jface.layout.GridDataFactory;
21	import org.eclipse.jface.wizard.WizardPage;	21	import org.eclipse.jface.wizard.WizardPage;
		22	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
22	import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;	23	import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;
23	import org.eclipse.mylyn.internal.tasks.ui.views.TaskElementLabelProvider;	24	import org.eclipse.mylyn.internal.tasks.ui.views.TaskElementLabelProvider;
24	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;	25	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
Lines 217-223 Link Here
217	List<AbstractTaskContainer> containers = new ArrayList<AbstractTaskContainer>();	218	List<AbstractTaskContainer> containers = new ArrayList<AbstractTaskContainer>();
218	containers.addAll(manager.getTaskList().getUserCategories());	219	containers.addAll(manager.getTaskList().getUserCategories());
219	containers.addAll(manager.getTaskList().getQueries());	220	containers.addAll(manager.getTaskList().getQueries());
220	containers.add(manager.getTaskList().getArchiveContainer());	221	//containers.add(manager.getTaskList().getArchiveContainer());
221	Collections.sort(containers, new Comparator<AbstractTaskContainer>() {	222	Collections.sort(containers, new Comparator<AbstractTaskContainer>() {
222		223
223	public int compare(AbstractTaskContainer c1, AbstractTaskContainer c2) {	224	public int compare(AbstractTaskContainer c1, AbstractTaskContainer c2) {




import java.util.Calendar;
import java.util.Set;

import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;
import org.eclipse.mylyn.internal.tasks.core.TaskArchive;
import org.eclipse.mylyn.internal.tasks.ui.AbstractTaskListFilter;
import org.eclipse.mylyn.monitor.core.StatusHandler;
import org.eclipse.mylyn.tasks.core.AbstractTask;

					if (isUninteresting(parent, task)) {
						return false;
					} else if (isInteresting(parent, task)) {
//						if (parent instanceof TaskArchive) {
//							return (shouldAlwaysShow(child, task, TasksUiPlugin.getDefault().groupSubtasks(task)) && revealInArchive(task));
//						}
						return true;
					}
				}
			} /*else if (child instanceof TaskArchive) {
																				// Display Archive if contains otherwise non-visible tasks that should always show
																				boolean hasTasksToReveal = false;
																				for (AbstractTask task : ((TaskArchive) child).getChildren()) {
																					if (shouldAlwaysShow(child, task, TasksUiPlugin.getDefault().groupSubtasks(task))
																							&& revealInArchive(task)) {
																						hasTasksToReveal = true;
																						break;
																					}
																				}
																				return hasTasksToReveal;
																			}*/else if (child instanceof AbstractTaskContainer) {
				Set<AbstractTask> children = ((AbstractTaskContainer) child).getChildren();
				// Always display empty containers
				if (children.size() == 0) {

				}

				for (AbstractTask task : children) {
					if (shouldAlwaysShow(child, task, ITasksCoreConstants.MAX_SUBTASK_DEPTH)) {
						return true;
					}
				}

		return false;
	}

//	private boolean revealInArchive(AbstractTask task) {
//		if (TasksUiPlugin.getTaskListManager().getTaskList().getContainerForHandle(task.getHandleIdentifier()) == null
//				&& TasksUiPlugin.getTaskListManager()
//						.getTaskList()
//						.getQueriesForHandle(task.getHandleIdentifier())
//						.isEmpty()) {
//			return true;
//		}
//		return false;
//	}

	private boolean isDateRangeInteresting(ScheduledTaskContainer container) {
		return TasksUiPlugin.getTaskActivityManager().isWeekDay(container);


	protected boolean isUninteresting(Object parent, AbstractTask task) {
		return !task.isActive()
				&& !hasInterestingSubTasks(parent, task, ITasksCoreConstants.MAX_SUBTASK_DEPTH)
				&& ((task.isCompleted() && !TaskActivityManager.getInstance().isCompletedToday(task) && !hasChanges(
						parent, task)) || (TaskActivityManager.getInstance().isScheduledAfterThisWeek(task))
						&& !hasChanges(parent, task));


	// TODO: make meta-context more explicit
	protected boolean isInteresting(Object parent, AbstractTask task) {
		return shouldAlwaysShow(parent, task, ITasksCoreConstants.MAX_SUBTASK_DEPTH);
	}

	public boolean shouldAlwaysShow(Object parent, AbstractTask task, int depth) {
		return task.isActive() || hasChanges(parent, task)
				|| (TaskActivityManager.getInstance().isCompletedToday(task))
				|| shouldShowInFocusedWorkweekDateContainer(parent, task)
				|| (isInterestingForThisWeek(parent, task) && !task.isCompleted())
				|| (TaskActivityManager.getInstance().isOverdue(task)) || hasInterestingSubTasks(parent, task, depth)
				|| hasInterestingSubTasks(parent, task, checkSubTasks)
				|| LocalRepositoryConnector.DEFAULT_SUMMARY.equals(task.getSummary());
		// || isCurrentlySelectedInEditor(task);
	}

	private boolean hasInterestingSubTasks(Object parent, AbstractTask task, int depth) {
		if (depth > 0) {
			if (!TasksUiPlugin.getDefault().groupSubtasks(task)) {
				return false;
			}
			if (task.getChildren() != null && task.getChildren().size() > 0) {
				for (AbstractTask subTask : task.getChildren()) {
					if (shouldAlwaysShow(parent, subTask, depth - 1)) {
						return true;
					}
					return true;
				}
			}
		}





import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.TaskArchive;
import org.eclipse.mylyn.internal.tasks.core.UnfiledCategory;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskKeyComparator;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter;


	@Override
	public int compare(Viewer compareViewer, Object o1, Object o2) {

//		OrphanedTasksContainer localArchive = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
//				LocalRepositoryConnector.REPOSITORY_URL);
//		if (o1 == localArchive && o2 instanceof AbstractTaskContainer) {
//			return -1;
//		} else if (o1 instanceof AbstractTaskContainer && o2 == localArchive) {
//			return 1;
//		}

		if (o1 instanceof AbstractTaskContainer && o2 instanceof OrphanedTasksContainer) {
			return -1;
		} else if (o2 instanceof AbstractTaskContainer && o1 instanceof OrphanedTasksContainer) {
			return 1;
		}


	}

	private int compareKeys(AbstractTaskContainer element1, AbstractTaskContainer element2) {
		return taskKeyComparator.compare(TaskListTableSorter.getSortableFromElement(element1),
				TaskListTableSorter.getSortableFromElement(element2));
	}

	private int comparePriorities(AbstractTaskContainer element1, AbstractTaskContainer element2) {

Added Link Here

(-).refactorings/2007/12/50/refactorings.index (+1 lines)
1	1197477772828 Extract constant 'MAX_SUBTASK_DEPTH'

Added Link Here

(-).refactorings/2007/12/50/refactorings.history (+4 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<session version="1.0">
3	<refactoring comment="Extract constant 'org.eclipse.mylyn.internal.context.ui.TaskListInterestFilter.MAX_SUBTASK_DEPTH' from expression '10' - Original project: 'org.eclipse.mylyn.context.ui' - Constant name: 'MAX_SUBTASK_DEPTH' - Constant expression: '10' - Declared visibility: 'private'" description="Extract constant 'MAX_SUBTASK_DEPTH'" flags="786432" id="org.eclipse.jdt.ui.extract.constant" input="/src<org.eclipse.mylyn.internal.context.ui{TaskListInterestFilter.java" name="MAX_SUBTASK_DEPTH" qualify="false" replace="false" selection="5089 2" stamp="1197477772828" version="1.0" visibility="2"/>
4	</session>

Lines 83-89 Link Here

(-)src/org/eclipse/mylyn/java/tests/RefactoringTest.java (-1 lines)
83	IInteractionElement oldParentNode = ContextCorePlugin.getContextManager().getElement(	83	IInteractionElement oldParentNode = ContextCorePlugin.getContextManager().getElement(
84	parentNode.getHandleIdentifier());	84	parentNode.getHandleIdentifier());
85	assertFalse(oldParentNode.getInterest().isInteresting());	85	assertFalse(oldParentNode.getInterest().isInteresting());
86	// XXX: put back?
87	IInteractionElement newParentNode = ContextCorePlugin.getContextManager().getElement(	86	IInteractionElement newParentNode = ContextCorePlugin.getContextManager().getElement(
88	newType.getParent().getHandleIdentifier());	87	newType.getParent().getHandleIdentifier());
89	assertTrue(newParentNode.getInterest().isInteresting());	88	assertTrue(newParentNode.getInterest().isInteresting());





package org.eclipse.mylyn.internal.ide.ui.actions;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.jface.viewers.IBaseLabelProvider;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.mylyn.context.ui.AbstractFocusViewAction;
import org.eclipse.mylyn.internal.ide.ui.MarkerInterestFilter;
import org.eclipse.mylyn.internal.ide.ui.MarkerViewLabelProvider;
import org.eclipse.mylyn.monitor.core.StatusHandler;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.internal.provisional.views.markers.ExtendedMarkersView;
import org.eclipse.ui.internal.provisional.views.markers.MarkersTreeViewer;
import org.eclipse.ui.views.markers.internal.TableViewLabelProvider;

/**

		}
	}

	/**
	 * HACK: changing accessibility
	 */
	@Override
	public final List<StructuredViewer> getViewers() {
		List<StructuredViewer> viewers = new ArrayList<StructuredViewer>();
		if (cachedViewer == null) {
			try {
				IViewPart viewPart = super.getPartForAction();
				if (viewPart != null) {
					// NOTE: following code is Eclipse 3.4 specific
					Class<?> clazz = ExtendedMarkersView.class;
					Field field = clazz.getDeclaredField("viewer");
					field.setAccessible(true);
					cachedViewer = (MarkersTreeViewer)field.get(viewPart);
					if (!cachedViewer.getControl().isDisposed()) {
						updateMarkerViewLabelProvider(cachedViewer);
					}
				}
			} catch (Exception e) {
				StatusHandler.log(e, "couldn't get problems view viewer");
			}
		}
		if (cachedViewer != null) {
			viewers.add(cachedViewer);
		}
		return viewers;
	}
	
	@Override
	public void update() {
		super.update();





package org.eclipse.mylyn.internal.ide.ui.actions;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.mylyn.monitor.core.StatusHandler;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.views.markers.internal.BookmarkView;
import org.eclipse.ui.views.markers.internal.TableView;

/**
 * @author Mik Kersten
 */
public class FocusBookmarkMarkersViewAction extends AbstractFocusMarkerViewAction {

	@Override
	public List<StructuredViewer> getViewers() {
		List<StructuredViewer> viewers = new ArrayList<StructuredViewer>();
		if (cachedViewer == null) {
			try {
				IViewPart viewPart = super.getPartForAction();
				if (viewPart instanceof BookmarkView) {
					Class<?> infoClass = TableView.class;
					Method method = infoClass.getDeclaredMethod("getViewer", new Class[] {});
					method.setAccessible(true);
					cachedViewer = (StructuredViewer) method.invoke(viewPart, new Object[] {});
					updateMarkerViewLabelProvider(cachedViewer);
				}
			} catch (Exception e) {
				StatusHandler.log(e, "couldn't get bookmarks view viewer");
			}
		}
		if (cachedViewer != null)
			viewers.add(cachedViewer);
		return viewers;
	}
	
//	@Override
//	public List<StructuredViewer> getViewers() {
//		List<StructuredViewer> viewers = new ArrayList<StructuredViewer>();
//		if (cachedViewer == null) {
//			try {
//				IViewPart viewPart = super.getPartForAction();
//				System.err.println(">>> " + viewPart.getClass());
//				if (viewPart instanceof  BookmarkView) {
//					Class<?> infoClass = TableView.class;
//					Method method = infoClass.getDeclaredMethod("getViewer", new Class[] {});
//					method.setAccessible(true);
//					cachedViewer = (StructuredViewer) method.invoke(viewPart, new Object[] {});
//					updateMarkerViewLabelProvider(cachedViewer);
//				}
//			} catch (Exception e) {
//				StatusHandler.log(e, "couldn't get bookmarks view viewer");
//			}
//		}
//		if (cachedViewer != null)
//			viewers.add(cachedViewer);
//		return viewers;
//	}
}

Lines 8-16 Link Here

(-)src/org/eclipse/mylyn/internal/ide/ui/actions/FocusProblemsListAction.java (+35 lines)
8		8
9	package org.eclipse.mylyn.internal.ide.ui.actions;	9	package org.eclipse.mylyn.internal.ide.ui.actions;
10		10
		11	import java.lang.reflect.Method;
		12	import java.util.ArrayList;
		13	import java.util.List;
		14
11	import org.eclipse.jface.viewers.StructuredViewer;	15	import org.eclipse.jface.viewers.StructuredViewer;
12	import org.eclipse.jface.viewers.TableViewer;	16	import org.eclipse.jface.viewers.TableViewer;
13	import org.eclipse.mylyn.internal.ide.ui.MarkerViewLabelProvider;	17	import org.eclipse.mylyn.internal.ide.ui.MarkerViewLabelProvider;
		18	import org.eclipse.mylyn.monitor.core.StatusHandler;
		19	import org.eclipse.ui.IViewPart;
		20	import org.eclipse.ui.views.markers.internal.TableView;
14	import org.eclipse.ui.views.markers.internal.TableViewLabelProvider;	21	import org.eclipse.ui.views.markers.internal.TableViewLabelProvider;
15		22
16	/**	23	/**
Lines 18-23 Link Here
18	*/	25	*/
19	public class FocusProblemsListAction extends AbstractFocusMarkerViewAction {	26	public class FocusProblemsListAction extends AbstractFocusMarkerViewAction {
20		27
		28	/**
		29	* HACK: changing accessibility
		30	*/
		31	@Override
		32	public List<StructuredViewer> getViewers() {
		33	List<StructuredViewer> viewers = new ArrayList<StructuredViewer>();
		34	if (cachedViewer == null) {
		35	try {
		36	IViewPart viewPart = super.getPartForAction();
		37	if (viewPart != null) {
		38	Class<?> infoClass = TableView.class;// problemView.getClass();
		39	Method method = infoClass.getDeclaredMethod("getViewer", new Class[] {});
		40	method.setAccessible(true);
		41	cachedViewer = (StructuredViewer) method.invoke(viewPart, new Object[] {});
		42	if (!cachedViewer.getControl().isDisposed()) {
		43	updateMarkerViewLabelProvider(cachedViewer);
		44	}
		45	}
		46	} catch (Exception e) {
		47	StatusHandler.log(e, "couldn't get problems view viewer");
		48	}
		49	}
		50	if (cachedViewer != null) {
		51	viewers.add(cachedViewer);
		52	}
		53	return viewers;
		54	}
		55
21	@Override	56	@Override
22	public void update() {	57	public void update() {
23	super.update();	58	super.update();




package org.eclipse.mylyn.internal.ide.ui;

import org.eclipse.core.resources.IMarker;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.mylyn.context.core.ContextCorePlugin;
import org.eclipse.mylyn.context.ui.InterestFilter;
import org.eclipse.ui.views.markers.internal.ConcreteMarker;
import org.eclipse.ui.views.markers.internal.ProblemMarker;

/**
 * @author Mik Kersten


	@Override
	public boolean select(Viewer viewer, Object parent, Object element) {
		if (!(element instanceof ConcreteMarker)) {
			return true;
				return true;
			} else if (element instanceof MarkerEntry){
				MarkerEntry entry = (MarkerEntry)element;
				return isInteresting(entry.getMarker(), viewer, parent);
			}
		} 
		return false;
//			return true;
			// NOTE: code commented out below did a look-down the children, which may be too expensive
//			if (element instanceof MarkerNode) {
//				MarkerNode markerNode = (MarkerNode) element;

//						return true;
//					}
//				}
//			} 
		} else {
			return isInteresting((ConcreteMarker) element, viewer, parent);
		}
//		}
	}

	private boolean isImplicitlyInteresting(ConcreteMarker marker) {
		return (marker instanceof ProblemMarker) && ((ProblemMarker) marker).getSeverity() == IMarker.SEVERITY_ERROR;
			Object severity = marker.getAttribute(IMarker.SEVERITY);
			return severity != null && severity.equals(IMarker.SEVERITY_ERROR);
		} catch (CoreException e) {
			// ignore
		}
		return false;
	}

	private boolean isInteresting(ConcreteMarker marker, Viewer viewer, Object parent) {
		if (isImplicitlyInteresting(marker)) {
			return true;
		} else {




			TaskListView.openInActivePerspective();
			manager = TasksUiPlugin.getTaskListManager();
			cat1 = new TaskCategory("First Category");
			manager.getTaskList().addCategory(cat1);
			cat1task1 = manager.createNewLocalTask("task 1");
			cat1task1.setPriority(PriorityLevel.P1.toString());
			cat1task1.setCompleted(true);
			manager.getTaskList().moveTask(cat1task1, cat1);

			cat1task1sub1 = manager.createNewLocalTask("sub task 1");
			cat1task1sub1.setPriority(PriorityLevel.P1.toString());

			cat1task2 = manager.createNewLocalTask("task 2");
			cat1task2.setPriority(PriorityLevel.P2.toString());
			cat1task2.addParentContainer(cat1);
			manager.getTaskList().moveTask(cat1task2, cat1);

			cat1task3 = manager.createNewLocalTask("task 3");
			cat1task3.setPriority(PriorityLevel.P3.toString());
			cat1task3.setCompleted(true);
			cat1task3.addParentContainer(cat1);
			manager.getTaskList().moveTask(cat1task3, cat1);

			cat1task4 = manager.createNewLocalTask("task 4");
			cat1task4.setPriority(PriorityLevel.P4.toString());
			cat1task4.addParentContainer(cat1);
			manager.getTaskList().moveTask(cat1task4, cat1);

			cat1task5 = manager.createNewLocalTask("task 5");
			cat1task5.setPriority(PriorityLevel.P5.toString());
			cat1task5.setCompleted(true);
			cat1task5.addParentContainer(cat1);
			manager.getTaskList().moveTask(cat1task5, cat1);

			manager.getTaskList().addCategory(cat1);
			assertEquals(cat1.getChildren().size(), 5);

			cat2 = new TaskCategory("Second Category");

			cat2task1 = manager.createNewLocalTask("task 1");
			cat2task1.setPriority(PriorityLevel.P1.toString());
			cat2task1.addParentContainer(cat2);
			manager.getTaskList().moveTask(cat2task1, cat2);

			cat2task1sub1 = manager.createNewLocalTask("sub task 1");
			cat2task1sub1.setPriority(PriorityLevel.P1.toString());

			cat2task2.setPriority(PriorityLevel.P2.toString());
			cat2task2.setCompleted(true);
			cat2task2.addParentContainer(cat2);
			manager.getTaskList().moveTask(cat2task2, cat2);

			cat2task3 = manager.createNewLocalTask("task 3");
			cat2task3.setPriority(PriorityLevel.P3.toString());
			cat2task3.addParentContainer(cat2);
			manager.getTaskList().moveTask(cat2task3, cat2);

			cat2task4 = manager.createNewLocalTask("task 4");
			cat2task4.setPriority(PriorityLevel.P4.toString());
			cat2task4.setCompleted(true);
			cat2task4.addParentContainer(cat2);
			manager.getTaskList().moveTask(cat2task4, cat2);

			cat2task5 = manager.createNewLocalTask("task 5");
			cat2task5.setPriority(PriorityLevel.P5.toString());
			cat2task5.addParentContainer(cat2);
			manager.getTaskList().moveTask(cat2task5, cat2);

			manager.getTaskList().addCategory(cat2);
			manager.saveTaskList();

		TaskListView view = TaskListView.getFromActivePerspective();
		assertNotNull(view);
		WebTask webTask = new WebTask("1", "1", "", "", "web");
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(webTask);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
		view.getViewer().refresh();
		// Arrays.asList(view.getViewer().getVisibleExpandedElements());
		assertFalse(webTask.isCompleted());

		MoveToCategoryMenuContributor moveToMenuContrib = new MoveToCategoryMenuContributor();
		List<AbstractTaskContainer> selectedElements = new Vector<AbstractTaskContainer>();
		selectedElements.add(cat1task1);
		int numCategories = manager.getTaskList().getCategories().size();
		int numSeparators = 1;
		// adding a separator and the New Category... action
		int expectedNrOfSubMenuEntries = numCategories + numSeparators + 1;
		NewCategoryAction newCatActon = new NewCategoryAction();

		// execute sytem under test

Lines 15-20 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskListTest.java (+1 lines)
15		15
16	/**	16	/**
17	* @author Mik Kersten	17	* @author Mik Kersten
		18	* @author Rob Elves
18	*/	19	*/
19	public class TaskListTest extends TestCase {	20	public class TaskListTest extends TestCase {
20		21

Lines 40-47 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/NewTaskWizardRepositorySelectionTest.java (-3 / +2 lines)
40	TaskListView view = TaskListView.openInActivePerspective();	40	TaskListView view = TaskListView.openInActivePerspective();
41	MockRepositoryTask mockTask = new MockRepositoryTask("mock.task");	41	MockRepositoryTask mockTask = new MockRepositoryTask("mock.task");
42	TasksUiPlugin.getTaskActivityManager().scheduleNewTask(mockTask);	42	TasksUiPlugin.getTaskActivityManager().scheduleNewTask(mockTask);
43	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask,	43	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask);
44	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
45		44
46	view.setFocusedMode(true);	45	view.setFocusedMode(true);
47	view.getViewer().refresh();	46	view.getViewer().refresh();
Lines 80-86 Link Here
80		79
81	SelectRepositoryPage page = (SelectRepositoryPage) wizard.getPages()[0];	80	SelectRepositoryPage page = (SelectRepositoryPage) wizard.getPages()[0];
82	TaskRepository localRepository = TasksUiPlugin.getRepositoryManager().getRepositories(	81	TaskRepository localRepository = TasksUiPlugin.getRepositoryManager().getRepositories(
83	LocalRepositoryConnector.REPOSITORY_KIND).iterator().next();	82	LocalRepositoryConnector.CONNECTOR_KIND).iterator().next();
84	assertEquals(localRepository, ((IStructuredSelection) page.getViewer().getSelection()).getFirstElement());	83	assertEquals(localRepository, ((IStructuredSelection) page.getViewer().getSelection()).getFirstElement());
85		84
86	wizard.dispose();	85	wizard.dispose();





	protected AbstractTask task5 = null;

	private ActivateTaskHistoryDropDownAction previousTaskAction = new ActivateTaskHistoryDropDownAction(
			TasksUiPlugin.getTaskListManager().getTaskActivationHistory(), false);

	@Override
	protected void setUp() throws Exception {
		super.setUp();

		resetHistory();

		task1 = manager.createNewLocalTask("task 1");
		manager.getTaskList().addTask(task1);

		task2 = manager.createNewLocalTask("task 2");
		manager.getTaskList().addTask(task2);

		task3 = manager.createNewLocalTask("task 3");
		manager.getTaskList().addTask(task3);

		task4 = manager.createNewLocalTask("task 4");
		manager.getTaskList().addTask(task4);

		task5 = manager.createNewLocalTask("task 5");
		manager.getTaskList().addTask(task5);

		history = manager.getTaskActivationHistory();
	}

		assertTrue(task3.isActive());
		assertFalse(task2.isActive());
		assertFalse(task1.isActive());

		previousTaskAction.run();
		assertTrue(task2.isActive());






		TaskRepository repository1 = new TaskRepository("bugzilla", "http://repository1/");
		manager.addRepository(repository1, TasksUiPlugin.getDefault().getRepositoriesFilePath());
		assertEquals(1, manager.getAllRepositories().size());
		assertNotNull(manager.getRepository("http://repository1"));
		assertNotNull(manager.getRepository("http://repository1/"));


	}

	public void testQueryDeletion() {
		TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND,
				MockRepositoryConnector.REPOSITORY_URL);
		TasksUiPlugin.getRepositoryManager().addRepository(repository,
				TasksUiPlugin.getDefault().getRepositoriesFilePath());

		MockRepositoryTask task = new MockRepositoryTask("1");
		task.setLastReadTimeStamp("now");
		MockRepositoryQuery query = new MockRepositoryQuery("Test");

Lines 69-75 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskDataExportTest.java (-1 / +1 lines)
69		69
70	// Create a task and context with an interaction event to be saved	70	// Create a task and context with an interaction event to be saved
71	task1 = manager.createNewLocalTask("Export Test Task");	71	task1 = manager.createNewLocalTask("Export Test Task");
72	manager.getTaskList().moveToContainer(task1, manager.getTaskList().getDefaultCategory());	72	manager.getTaskList().addTask(task1);
73	mockContext = ContextCorePlugin.getContextManager().loadContext(task1.getHandleIdentifier());	73	mockContext = ContextCorePlugin.getContextManager().loadContext(task1.getHandleIdentifier());
74	InteractionEvent event = new InteractionEvent(InteractionEvent.Kind.EDIT, "structureKind", "handle", "originId");	74	InteractionEvent event = new InteractionEvent(InteractionEvent.Kind.EDIT, "structureKind", "handle", "originId");
75	mockContext.parseEvent(event);	75	mockContext.parseEvent(event);




 */
public class MockRepositoryQuery extends AbstractRepositoryQuery {

	public String MOCK_QUERY_URL = MockRepositoryConnector.REPOSITORY_URL + ".query";

	public MockRepositoryQuery(String description) {
		super(description);
		super.setUrl(MOCK_QUERY_URL);
		super.setRepositoryUrl(MockRepositoryConnector.REPOSITORY_URL);
	}

	public MockRepositoryQuery(String description, String url) {




/*******************************************************************************
 * Copyright (c) 2004, 2007 Mylyn project committers and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/

package org.eclipse.mylyn.tasks.tests;

import java.util.Set;

import junit.framework.TestCase;

import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.core.LocalTask;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.TaskList;
import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryConnector;
import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryQuery;
import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryTask;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;

/**
 * @author Rob Elves
 */
public class OrphanedTasksTest extends TestCase {

	private TaskList taskList;

	protected void setUp() throws Exception {
		super.setUp();
		TasksUiPlugin.getTaskListManager().resetTaskList();
		taskList = TasksUiPlugin.getTaskListManager().getTaskList();
		assertTrue(taskList.getDefaultCategory().isEmpty());
	}

	protected void tearDown() throws Exception {
		super.tearDown();
	}

	/**
	 * y New local tasks should automatically be created in the Local orphaned folder
	 */
	public void testAddLocalTask() {
		Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getRepositoryTasks(
				LocalRepositoryConnector.REPOSITORY_URL);
		assertTrue(tasks.isEmpty());
		AbstractTask localTask = TasksUiPlugin.getTaskListManager().createNewLocalTask("Task 1");
		assertNotNull(localTask);
		assertEquals(1, localTask.getParentContainers().size());
	}

	/**
	 * When a local tasks is removed from a category it should be placed in the Uncategorized folder
	 */
	public void testRemoveLocalTask() {
		TaskCategory category = new TaskCategory("taskCategoryHandle");
		taskList.addCategory(category);
		LocalTask newTask = new LocalTask("" + taskList.getNextLocalTaskId(), "new local task");
		taskList.addTask(newTask, category);
		//assertEquals(1, taskList.getOrphanContainers().size());
		assertEquals(2, taskList.getCategories().size());
		taskList.removeFromCategory(category, newTask);
		//assertEquals(taskList.getOrphanContainers().size(), 1);
		assertFalse(category.contains(newTask.getHandleIdentifier()));
		assertTrue(taskList.getDefaultCategory().contains(newTask.getHandleIdentifier()));
		assertEquals(1, newTask.getParentContainers().size());
		assertEquals(taskList.getDefaultCategory().getHandleIdentifier(), newTask.getParentContainers()
				.iterator()
				.next()
				.getHandleIdentifier());
	}

	/**
	 * Local tasks in a removed category should be orphaned.
	 */
	public void testLocalTaskOrphanedInDeletedTaskCategory() {
		assertTrue(taskList.getDefaultCategory().isEmpty());
		TaskCategory category = new TaskCategory("taskCategoryHandle");
		taskList.addCategory(category);
		LocalTask newTask = new LocalTask("" + taskList.getNextLocalTaskId(), "new local task");
		taskList.addTask(newTask, category);
		assertTrue(taskList.getDefaultCategory().isEmpty());
		taskList.deleteCategory(category);
		assertTrue(taskList.getDefaultCategory().contains(newTask.getHandleIdentifier()));

	}

	/**
	 * Query removed with task in category, just query removed task remains.
	 */
	public void testTaskRemovedFromQuery() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		mockTask.setLastReadTimeStamp("now");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		taskList.addQuery(mockQuery);
		taskList.addTask(mockTask, mockQuery);

		taskList.removeFromQuery(mockQuery, mockTask);

		assertFalse(mockQuery.contains(mockTask.getHandleIdentifier()));
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));
	}

	/**
	 * Query removed with task in category, just query removed task remains.
	 */
	public void testTaskRemovedFromQueryButInCategory() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		mockTask.setLastReadTimeStamp("now");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		taskList.addQuery(mockQuery);
		taskList.addTask(mockTask, mockQuery);

		TaskCategory category = new TaskCategory("taskCategoryHandle");
		taskList.addCategory(category);
		taskList.addTask(mockTask, category);
		assertTrue(category.contains(mockTask.getHandleIdentifier()));
		taskList.removeFromQuery(mockQuery, mockTask);

		assertFalse(mockQuery.contains(mockTask.getHandleIdentifier()));
		assertEquals(2, taskList.getCategories().size());
		assertTrue(category.contains(mockTask.getHandleIdentifier()));

		//* Repository tasks within a removed category that are not in a query should be orphaned.

		taskList.removeFromCategory(category, mockTask);
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));
	}

	/**
	 * Repository tasks that exists in a query are not orphaned.
	 */
	public void testRepositoryTaskInDeletedCategory() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		taskList.addQuery(mockQuery);
		taskList.addTask(mockTask, mockQuery);
		assertEquals(1, taskList.getCategories().size());
		TaskCategory category = new TaskCategory("taskCategoryHandle");
		taskList.addCategory(category);
		taskList.addTask(mockTask, category);
		assertEquals(2, taskList.getCategories().size());
		assertTrue(taskList.getDefaultCategory().isEmpty());
		taskList.deleteCategory(category);
		assert (taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).isEmpty());
		assertEquals(1, taskList.getCategories().size());
	}

	/**
	 * Repository tasks that exist in another query are not orphaned
	 */
	public void testRemovalOfTaskInTwoQueries() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query 1");
		MockRepositoryQuery mockQuery2 = new MockRepositoryQuery("mock query 2");
		taskList.addQuery(mockQuery);
		taskList.addQuery(mockQuery2);
		taskList.addTask(mockTask, mockQuery);
		taskList.addTask(mockTask, mockQuery2);

		taskList.removeFromQuery(mockQuery2, mockTask);
		assertTrue(mockQuery2.isEmpty());
		assertFalse(mockQuery.isEmpty());
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).isEmpty());
	}

	/**
	 * Moving an orphan to a Category should result in the task only being present in the target Category
	 */
	public void testMoveLocalTask() {
		TaskCategory category = new TaskCategory("taskCategoryHandle");
		taskList.addCategory(category);
		LocalTask newTask = new LocalTask("" + taskList.getNextLocalTaskId(), "new local task");
		taskList.addTask(newTask, null);
		assertTrue(taskList.getDefaultCategory().contains(newTask.getHandleIdentifier()));
		taskList.moveTask(newTask, category);
		assertFalse(taskList.getDefaultCategory().contains(newTask.getHandleIdentifier()));
	}

	public void testAddRepositoryTask() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);
		Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getRepositoryTasks(
				MockRepositoryConnector.REPOSITORY_URL);
		assertFalse(tasks.isEmpty());
		AbstractRepositoryQuery query = TasksUiPlugin.getTaskListManager().getTaskList().getQueryForHandle(
				mockTask.getHandleIdentifier());
		assertEquals(mockQuery, query);
		assertFalse(query.isEmpty());
		assertTrue(TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
				MockRepositoryConnector.REPOSITORY_URL).isEmpty());
	}

	public void testMoveRepositoryTask() {
		TaskList tasklist = TasksUiPlugin.getTaskListManager().getTaskList();
		assertTrue(tasklist.getAllTasks().isEmpty());

		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);

		TaskCategory category = new TaskCategory("taskCategoryHandle");
		taskList.addCategory(category);

		taskList.moveTask(mockTask, category);
		assertTrue(taskList.getDefaultCategory().isEmpty());
		assertTrue(category.contains(mockTask.getHandleIdentifier()));
		assertTrue(mockQuery.contains(mockTask.getHandleIdentifier()));

	}

	public void testRefactorOrphanedHandle() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		mockTask.setLastReadTimeStamp("now");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		taskList.addQuery(mockQuery);
		taskList.addTask(mockTask, mockQuery);

		taskList.removeFromQuery(mockQuery, mockTask);

		assertFalse(mockQuery.contains(mockTask.getHandleIdentifier()));
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));

		taskList.refactorRepositoryUrl(MockRepositoryConnector.REPOSITORY_URL, MockRepositoryConnector.REPOSITORY_URL
				+ "new");
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL + "new").contains(
				mockTask.getHandleIdentifier()));
	}

	public void testOrphanedSubtasks() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		MockRepositoryTask mockTask2 = new MockRepositoryTask("2");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask2, mockTask);

		assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));
		assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask2.getHandleIdentifier()));

		assertNotNull(taskList.getTask(mockTask.getHandleIdentifier()));
		assertNotNull(taskList.getTask(mockTask2.getHandleIdentifier()));
		assertNotNull(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL));
		taskList.removeFromQuery(mockQuery, mockTask);
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask2.getHandleIdentifier()));
		taskList.deleteTask(mockTask);
		assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));
		// mockTask2 should be orphaned when the parent task is deleted
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask2.getHandleIdentifier()));
	}

	/**
	 * If a task with subtasks falls out of a query, if its subtasks are subtasks of another task that is still around,
	 * they shouldn't be in the archive.
	 */
	public void testOrphanedSubtaskWithOtherParent() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		MockRepositoryTask mockTask2 = new MockRepositoryTask("2");
		MockRepositoryTask mockTask3 = new MockRepositoryTask("3");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask2, mockTask);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask3, mockQuery);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask2, mockTask3);
		assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));
		assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask2.getHandleIdentifier()));
		assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask3.getHandleIdentifier()));

		taskList.removeFromQuery(mockQuery, mockTask);
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));
		assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask2.getHandleIdentifier()));

		taskList.removeFromQuery(mockQuery, mockTask3);
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask3.getHandleIdentifier()));
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask2.getHandleIdentifier()));

	}
}




import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
import org.eclipse.mylyn.internal.context.core.InteractionContextManager;
import org.eclipse.mylyn.internal.monitor.usage.UiUsageMonitorPlugin;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.monitor.core.InteractionEvent;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.ui.TaskListManager;

	public void testTaskMove() {
		AbstractTask task = manager.createNewLocalTask("label");
		String handle = task.getHandleIdentifier();
		manager.getTaskList().moveTask(task,
				manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL));

		AbstractTask readTaskBeforeMove = manager.getTaskList().getTask(handle);
		TasksUiPlugin.getTaskListManager().copyDataDirContentsTo(newDataDir);

	}

	private void addBugzillaTask(BugzillaTask newTask) {
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(newTask);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
	}
}




		taskCompleted = new LocalTask("1", "completed");
		taskCompleted.setCompleted(true);
		taskCompleted.setCompletionDate(TaskActivityUtil.snapForwardNumDays(Calendar.getInstance(), -1).getTime());
		manager.getTaskList().addTask(taskCompleted);

		taskIncomplete = new LocalTask("2", "t-incomplete");
		manager.getTaskList().addTask(taskIncomplete);

		taskOverdue = new LocalTask("3", "t-overdue");
		taskOverdue.setScheduledForDate(TaskActivityUtil.snapForwardNumDays(Calendar.getInstance(), -1).getTime());
		manager.getTaskList().addTask(taskOverdue);

		taskDueToday = new LocalTask("4", "t-today");
		taskDueToday.setScheduledForDate(TaskActivityUtil.snapEndOfWorkDay(Calendar.getInstance()).getTime());
		manager.getTaskList().addTask(taskDueToday);

		taskCompletedToday = new LocalTask("5", "t-donetoday");
		taskCompletedToday.setScheduledForDate(TaskActivityUtil.snapEndOfWorkDay(Calendar.getInstance()).getTime());
		taskCompletedToday.setCompleted(true);
		manager.getTaskList().addTask(taskCompletedToday);
	}

	@Override

Return to bug 181388

Lines 27-32 Link Here

(-)src/org/eclipse/mylyn/internal/sandbox/bridge/bugs/BugzillaMylynSearchOperation.java (-2 / +5 lines)
27	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaCorePlugin;	27	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaCorePlugin;
28	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;	28	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
29	import org.eclipse.mylyn.internal.bugzilla.ui.tasklist.StackTrace;	29	import org.eclipse.mylyn.internal.bugzilla.ui.tasklist.StackTrace;
		30	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
30	import org.eclipse.mylyn.internal.tasks.ui.search.AbstractRepositorySearchQuery;	31	import org.eclipse.mylyn.internal.tasks.ui.search.AbstractRepositorySearchQuery;
31	import org.eclipse.mylyn.monitor.core.StatusHandler;	32	import org.eclipse.mylyn.monitor.core.StatusHandler;
32	import org.eclipse.mylyn.tasks.core.AbstractTask;	33	import org.eclipse.mylyn.tasks.core.AbstractTask;
Lines 149-155 Link Here
149	collector.setProgressMonitor(monitor);	150	collector.setProgressMonitor(monitor);
150		151
151	// get all of the root tasks and start the search	152	// get all of the root tasks and start the search
152	Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory().getChildren();	153	Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
		154	LocalRepositoryConnector.REPOSITORY_URL).getChildren();
153	searchLocal(tasks, collector, elementName, monitor);	155	searchLocal(tasks, collector, elementName, monitor);
154	for (AbstractTaskContainer cat : TasksUiPlugin.getTaskListManager().getTaskList().getTaskContainers()) {	156	for (AbstractTaskContainer cat : TasksUiPlugin.getTaskListManager().getTaskList().getTaskContainers()) {
155	searchLocal(cat.getChildren(), collector, elementName, monitor);	157	searchLocal(cat.getChildren(), collector, elementName, monitor);
Lines 179-185 Link Here
179	collector.setProgressMonitor(monitor);	181	collector.setProgressMonitor(monitor);
180		182
181	// get all of the root tasks and start the search	183	// get all of the root tasks and start the search
182	Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory().getChildren();	184	Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
		185	LocalRepositoryConnector.REPOSITORY_URL).getChildren();
183	searchLocal(tasks, collector, elementName, monitor);	186	searchLocal(tasks, collector, elementName, monitor);
184	for (AbstractTaskContainer cat : TasksUiPlugin.getTaskListManager().getTaskList().getTaskContainers()) {	187	for (AbstractTaskContainer cat : TasksUiPlugin.getTaskListManager().getTaskList().getTaskContainers()) {
185	searchLocal(cat.getChildren(), collector, elementName, monitor);	188	searchLocal(cat.getChildren(), collector, elementName, monitor);

Lines 17-29 Link Here

(-)src/org/eclipse/mylyn/bugzilla/tests/TaskReportGeneratorTest.java (-13 / +23 lines)
17	import junit.framework.TestCase;	17	import junit.framework.TestCase;
18		18
19	import org.eclipse.core.runtime.NullProgressMonitor;	19	import org.eclipse.core.runtime.NullProgressMonitor;
		20	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaCorePlugin;
20	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaRepositoryQuery;	21	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaRepositoryQuery;
21	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;	22	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
		23	import org.eclipse.mylyn.internal.bugzilla.core.IBugzillaConstants;
22	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;	24	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
23	import org.eclipse.mylyn.internal.tasks.ui.planner.CompletedTaskCollector;	25	import org.eclipse.mylyn.internal.tasks.ui.planner.CompletedTaskCollector;
24	import org.eclipse.mylyn.internal.tasks.ui.planner.TaskReportGenerator;	26	import org.eclipse.mylyn.internal.tasks.ui.planner.TaskReportGenerator;
25	import org.eclipse.mylyn.tasks.core.AbstractTask;	27	import org.eclipse.mylyn.tasks.core.AbstractTask;
26	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;	28	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
		29	import org.eclipse.mylyn.tasks.core.TaskRepository;
27	import org.eclipse.mylyn.tasks.ui.TaskListManager;	30	import org.eclipse.mylyn.tasks.ui.TaskListManager;
28	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;	31	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
29		32
Lines 54-60 Link Here
54		57
55	public void testCompletedTasksRetrieved() throws InvocationTargetException, InterruptedException {	58	public void testCompletedTasksRetrieved() throws InvocationTargetException, InterruptedException {
56	AbstractTask task1 = manager.createNewLocalTask("task 1");	59	AbstractTask task1 = manager.createNewLocalTask("task 1");
57	manager.getTaskList().moveToContainer(task1, manager.getTaskList().getDefaultCategory());	60	manager.getTaskList().addTask(task1);
58		61
59	CompletedTaskCollector collector = new CompletedTaskCollector(new Date(0), new Date());	62	CompletedTaskCollector collector = new CompletedTaskCollector(new Date(0), new Date());
60	TaskReportGenerator generator = new TaskReportGenerator(manager.getTaskList());	63	TaskReportGenerator generator = new TaskReportGenerator(manager.getTaskList());
Lines 73-79 Link Here
73		76
74	public void testCompletedTasksDateBoundsRetrieved() throws InvocationTargetException, InterruptedException {	77	public void testCompletedTasksDateBoundsRetrieved() throws InvocationTargetException, InterruptedException {
75	AbstractTask task1 = manager.createNewLocalTask("task 1");	78	AbstractTask task1 = manager.createNewLocalTask("task 1");
76	manager.getTaskList().moveToContainer(task1, manager.getTaskList().getDefaultCategory());	79	manager.getTaskList().addTask(task1);
77	task1.setCompleted(true);	80	task1.setCompleted(true);
78	Thread.sleep(1000);	81	Thread.sleep(1000);
79	long now = new Date().getTime();	82	long now = new Date().getTime();
Lines 93-102 Link Here
93	}	96	}
94		97
95	public void testCompletedBugzillaTasksRetrieved() throws InvocationTargetException, InterruptedException {	98	public void testCompletedBugzillaTasksRetrieved() throws InvocationTargetException, InterruptedException {
96	BugzillaTask task1 = new BugzillaTask("repo", "1", "bugzillatask 1");	99	TaskRepository repository = new TaskRepository(BugzillaCorePlugin.REPOSITORY_KIND,
97	manager.getTaskList().moveToContainer(task1, manager.getTaskList().getDefaultCategory());	100	IBugzillaConstants.ECLIPSE_BUGZILLA_URL);
98		101	TasksUiPlugin.getRepositoryManager().addRepository(repository,
99	CompletedTaskCollector collector = new CompletedTaskCollector(new Date(0), new Date());	102	TasksUiPlugin.getDefault().getRepositoriesFilePath());
		103	BugzillaTask task1 = new BugzillaTask(IBugzillaConstants.ECLIPSE_BUGZILLA_URL, "1", "bugzillatask 1");
		104	manager.getTaskList().addTask(task1);
		105
		106	Calendar cal = Calendar.getInstance();
		107	cal.add(Calendar.MINUTE, 5);
		108	CompletedTaskCollector collector = new CompletedTaskCollector(new Date(0), cal.getTime());
100	TaskReportGenerator generator = new TaskReportGenerator(manager.getTaskList());	109	TaskReportGenerator generator = new TaskReportGenerator(manager.getTaskList());
101	generator.addCollector(collector);	110	generator.addCollector(collector);
102	generator.run(new NullProgressMonitor());	111	generator.run(new NullProgressMonitor());
Lines 106-116 Link Here
106	generator.run(new NullProgressMonitor());	115	generator.run(new NullProgressMonitor());
107	assertEquals(1, generator.getAllCollectedTasks().size());	116	assertEquals(1, generator.getAllCollectedTasks().size());
108	assertEquals(task1, generator.getAllCollectedTasks().get(0));	117	assertEquals(task1, generator.getAllCollectedTasks().get(0));
		118	TasksUiPlugin.getRepositoryManager().removeRepository(repository,
		119	TasksUiPlugin.getDefault().getRepositoriesFilePath());
		120	manager.resetTaskList();
109	}	121	}
110		122
111	public void testCompletedTasksInCategoryRetrieved() throws InvocationTargetException, InterruptedException {	123	public void testCompletedTasksInCategoryRetrieved() throws InvocationTargetException, InterruptedException {
112	AbstractTask task1 = manager.createNewLocalTask("task 1");	124	AbstractTask task1 = manager.createNewLocalTask("task 1");
113	manager.getTaskList().moveToContainer(task1, manager.getTaskList().getDefaultCategory());	125	manager.getTaskList().addTask(task1);
114	task1.setCompleted(true);	126	task1.setCompleted(true);
115	TaskCategory cat1 = new TaskCategory("TaskReportGeneratorTest Category");	127	TaskCategory cat1 = new TaskCategory("TaskReportGeneratorTest Category");
116	manager.getTaskList().addCategory(cat1);	128	manager.getTaskList().addCategory(cat1);
Lines 124-130 Link Here
124	generator.run(new NullProgressMonitor());	136	generator.run(new NullProgressMonitor());
125	assertEquals(0, generator.getAllCollectedTasks().size());	137	assertEquals(0, generator.getAllCollectedTasks().size());
126		138
127	manager.getTaskList().moveToContainer(task1, cat1);	139	manager.getTaskList().moveTask(task1, cat1);
128		140
129	generator.run(new NullProgressMonitor());	141	generator.run(new NullProgressMonitor());
130	assertEquals(1, generator.getAllCollectedTasks().size());	142	assertEquals(1, generator.getAllCollectedTasks().size());
Lines 133-140 Link Here
133		145
134	public void testCompletedBugzillaTasksInCategoryRetrieved() throws InvocationTargetException, InterruptedException {	146	public void testCompletedBugzillaTasksInCategoryRetrieved() throws InvocationTargetException, InterruptedException {
135	BugzillaTask task1 = new BugzillaTask("repo", "1", "task 1");	147	BugzillaTask task1 = new BugzillaTask("repo", "1", "task 1");
136	manager.getTaskList().moveToContainer(task1,	148	manager.getTaskList().addTask(task1);
137	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
138	task1.setCompleted(true);	149	task1.setCompleted(true);
139	TaskCategory cat1 = new TaskCategory("TaskReportGeneratorTest Category");	150	TaskCategory cat1 = new TaskCategory("TaskReportGeneratorTest Category");
140	manager.getTaskList().addCategory(cat1);	151	manager.getTaskList().addCategory(cat1);
Lines 148-154 Link Here
148	generator.run(new NullProgressMonitor());	159	generator.run(new NullProgressMonitor());
149	assertEquals(0, generator.getAllCollectedTasks().size());	160	assertEquals(0, generator.getAllCollectedTasks().size());
150		161
151	manager.getTaskList().moveToContainer(task1, cat1);	162	manager.getTaskList().moveTask(task1, cat1);
152		163
153	generator.run(new NullProgressMonitor());	164	generator.run(new NullProgressMonitor());
154	assertEquals(1, generator.getAllCollectedTasks().size());	165	assertEquals(1, generator.getAllCollectedTasks().size());
Lines 157-164 Link Here
157		168
158	public void testCompletedBugzillaTasksInQueryRetrieved() throws InvocationTargetException, InterruptedException {	169	public void testCompletedBugzillaTasksInQueryRetrieved() throws InvocationTargetException, InterruptedException {
159	BugzillaTask task1 = new BugzillaTask("repo", "1", "task 1");	170	BugzillaTask task1 = new BugzillaTask("repo", "1", "task 1");
160	manager.getTaskList().moveToContainer(task1,	171	manager.getTaskList().addTask(task1);
161	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
162	task1.setCompleted(false);	172	task1.setCompleted(false);
163		173
164	BugzillaRepositoryQuery bugQuery = new BugzillaRepositoryQuery("repositoryUrl", "queryUrl",	174	BugzillaRepositoryQuery bugQuery = new BugzillaRepositoryQuery("repositoryUrl", "queryUrl",

Lines 56-62 Link Here

(-)src/org/eclipse/mylyn/bugzilla/tests/TaskListStandaloneTest.java (-3 / +3 lines)
56	AbstractTask task = new LocalTask("1", "task 1");	56	AbstractTask task = new LocalTask("1", "task 1");
57	Date dueDate = new Date();	57	Date dueDate = new Date();
58	task.setDueDate(dueDate);	58	task.setDueDate(dueDate);
59	manager.getTaskList().moveToContainer(task, manager.getTaskList().getDefaultCategory());	59	manager.getTaskList().addTask(task);
60	assertEquals(1, manager.getTaskList().getAllTasks().size());	60	assertEquals(1, manager.getTaskList().getAllTasks().size());
61		61
62	manager.saveTaskList();	62	manager.saveTaskList();
Lines 88-94 Link Here
88	Date creation = new Date();	88	Date creation = new Date();
89	AbstractTask task = new LocalTask("1", "task 1");	89	AbstractTask task = new LocalTask("1", "task 1");
90		90
91	manager.getTaskList().moveToContainer(task, manager.getTaskList().getDefaultCategory());	91	manager.getTaskList().addTask(task);
92	assertDatesCloseEnough(task.getCreationDate(), start);	92	assertDatesCloseEnough(task.getCreationDate(), start);
93		93
94	task.setCompleted(true);	94	task.setCompleted(true);
Lines 97-103 Link Here
97	task.setScheduledForDate(start);	97	task.setScheduledForDate(start);
98	assertDatesCloseEnough(task.getScheduledForDate(), start);	98	assertDatesCloseEnough(task.getScheduledForDate(), start);
99		99
100	assertEquals(2, manager.getTaskList().getRootElements().size());	100	assertEquals(1, manager.getTaskList().getRootElements().size());
101	manager.saveTaskList();	101	manager.saveTaskList();
102		102
103	assertNotNull(manager.getTaskList());	103	assertNotNull(manager.getTaskList());

Lines 57-64 Link Here

(-)src/org/eclipse/mylyn/bugzilla/tests/BugzillaRepositoryConnectorTest.java (-7 / +4 lines)
57	task.getTaskId());	57	task.getTaskId());
58	assertNotNull(taskData);	58	assertNotNull(taskData);
59		59
60	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task,	60	TasksUiPlugin.getTaskListManager().getTaskList().addTask(task);
61	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
62		61
63	String newCommentText = "BugzillaRepositoryClientTest.testMidAirCollision(): test " + (new Date()).toString();	62	String newCommentText = "BugzillaRepositoryClientTest.testMidAirCollision(): test " + (new Date()).toString();
64	taskData.setNewComment(newCommentText);	63	taskData.setNewComment(newCommentText);
Lines 132-139 Link Here
132	task.getTaskId());	131	task.getTaskId());
133	assertNotNull(taskData);	132	assertNotNull(taskData);
134		133
135	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task,	134	TasksUiPlugin.getTaskListManager().getTaskList().addTask(task);
136	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
137		135
138	assertEquals("rob.elves@eclipse.org", taskData.getAssignedTo());	136	assertEquals("rob.elves@eclipse.org", taskData.getAssignedTo());
139	// Modify it (reassign to tests2@mylyn.eclipse.org)	137	// Modify it (reassign to tests2@mylyn.eclipse.org)
Lines 182-188 Link Here
182	task.getTaskId());	180	task.getTaskId());
183	assertNotNull(taskData);	181	assertNotNull(taskData);
184		182
185	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task,	183	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(task,
186	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());	184	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
187		185
188	assertEquals(defaultAssignee, taskData.getAssignedTo());	186	assertEquals(defaultAssignee, taskData.getAssignedTo());
Lines 386-393 Link Here
386	task.getTaskId());	384	task.getTaskId());
387	assertNotNull(taskData);	385	assertNotNull(taskData);
388		386
389	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task,	387	TasksUiPlugin.getTaskListManager().getTaskList().addTask(task);
390	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
391	int numComments = taskData.getComments().size();	388	int numComments = taskData.getComments().size();
392		389
393	// Modify it	390	// Modify it

Added Link Here

(-)src/org/eclipse/mylyn/internal/tasks/core/OrphanedTasksContainer.java (+76 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004, 2007 Mylyn project committers and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/
8
9	package org.eclipse.mylyn.internal.tasks.core;
10
11	import org.eclipse.mylyn.tasks.core.AbstractTask;
12	import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;
13	import org.eclipse.mylyn.tasks.core.AbstractTask.PriorityLevel;
14
15	/**
16	* Holds orphaned or uncategorized tasks for a given repository
17	*
18	* @author Rob Elves
19	*/
20	public class OrphanedTasksContainer extends AbstractTaskCategory {
21
22	public static final String LABEL = "Uncategorized";
23
24	public static final String HANDLE = "orphans";
25
26	private String repositoryUrl;
27
28	private String connectorKind;
29
30	public OrphanedTasksContainer(String connectorKind, String repositoryUrl) {
31	super(repositoryUrl + "-" + HANDLE);
32	this.repositoryUrl = repositoryUrl;
33	this.connectorKind = connectorKind;
34	}
35
36	@Override
37	public String getPriority() {
38	return PriorityLevel.P1.toString();
39	}
40
41	@Override
42	public String getSummary() {
43	return "Archive: " + getRepositoryUrl();
44	}
45
46	@Override
47	public boolean isUserDefined() {
48	return false;
49	}
50
51	public String getRepositoryUrl() {
52	return repositoryUrl;
53	}
54
55	public String getConnectorKind() {
56	return connectorKind;
57	}
58
59	/**
60	* setting will also refactor handle
61	*/
62	public void setRepositoryUrl(String repositoryUrl) {
63	this.repositoryUrl = repositoryUrl;
64	this.setHandleIdentifier(repositoryUrl + "-" + HANDLE);
65	}
66
67	@Override
68	public boolean contains(String handle) {
69	for (AbstractTask child : getChildrenInternal()) {
70	if (child.getHandleIdentifier().equals(handle)) {
71	return true;
72	}
73	}
74	return false;
75	}
76	}

Lines 46-51 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/TaskListView.java (-7 / +10 lines)
46	import org.eclipse.jface.viewers.TreeExpansionEvent;	46	import org.eclipse.jface.viewers.TreeExpansionEvent;
47	import org.eclipse.jface.viewers.TreeViewer;	47	import org.eclipse.jface.viewers.TreeViewer;
48	import org.eclipse.jface.window.Window;	48	import org.eclipse.jface.window.Window;
		49	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
49	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;	50	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
50	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;	51	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;
51	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;	52	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
Lines 458-465 Link Here
458	refreshJob.refresh();	459	refreshJob.refresh();
459	break;	460	break;
460	default:	461	default:
461	if (taskContainerDelta.getContainer().equals(	462	if (taskContainerDelta.getContainer() == null) {
462	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory())) {
463	refreshJob.refresh();	463	refreshJob.refresh();
464	} else {	464	} else {
465	refreshJob.refreshTask(taskContainerDelta.getContainer());	465	refreshJob.refreshTask(taskContainerDelta.getContainer());
Lines 1135-1141 Link Here
1135	subMenu = new MenuManager("New", ID_MENU_NEW);	1135	subMenu = new MenuManager("New", ID_MENU_NEW);
1136	manager.add(subMenu);	1136	manager.add(subMenu);
1137	}	1137	}
1138		1138
1139	subMenu.add(new Separator(ID_SEPARATOR_NEW_REPOSITORY));	1139	subMenu.add(new Separator(ID_SEPARATOR_NEW_REPOSITORY));
1140	subMenu.add(action);	1140	subMenu.add(action);
1141	subMenu.add(new Separator(ID_SEPARATOR_NEW_LOCAL));	1141	subMenu.add(new Separator(ID_SEPARATOR_NEW_LOCAL));
Lines 1178-1183 Link Here
1178		1178
1179	addAction(copyDetailsAction, manager, element);	1179	addAction(copyDetailsAction, manager, element);
1180	if (task != null && !task.isLocal()) {	1180	if (task != null && !task.isLocal()) {
		1181	// TODO: if selection parent is an Orphan container don't add this action
1181	// addAction(cloneThisBugAction, manager, element);	1182	// addAction(cloneThisBugAction, manager, element);
1182	addAction(removeFromCategoryAction, manager, element);	1183	addAction(removeFromCategoryAction, manager, element);
1183	}	1184	}
Lines 1276-1282 Link Here
1276	} else if (action instanceof MarkTaskIncompleteAction) {	1277	} else if (action instanceof MarkTaskIncompleteAction) {
1277	action.setEnabled(false);	1278	action.setEnabled(false);
1278	} else if (action instanceof DeleteAction) {	1279	} else if (action instanceof DeleteAction) {
1279	if (element instanceof TaskArchive \|\| element instanceof UnfiledCategory)	1280	if (element instanceof TaskArchive \|\| element instanceof UnfiledCategory
		1281	\|\| element instanceof OrphanedTasksContainer)
1280	action.setEnabled(false);	1282	action.setEnabled(false);
1281	else	1283	else
1282	action.setEnabled(true);	1284	action.setEnabled(true);
Lines 1407-1413 Link Here
1407	refreshJob.forceRefresh();	1409	refreshJob.forceRefresh();
1408	}	1410	}
1409	}	1411	}
1410		1412
1411	public void refresh() {	1413	public void refresh() {
1412	refreshJob.forceRefresh();	1414	refreshJob.forceRefresh();
1413	// if (expand) {	1415	// if (expand) {
Lines 1698-1705 Link Here
1698	Set<AbstractTaskContainer> containers = new HashSet<AbstractTaskContainer>(	1700	Set<AbstractTaskContainer> containers = new HashSet<AbstractTaskContainer>(
1699	TasksUiPlugin.getTaskListManager().getTaskList().getQueriesForHandle(task.getHandleIdentifier()));	1701	TasksUiPlugin.getTaskListManager().getTaskList().getQueriesForHandle(task.getHandleIdentifier()));
1700	containers.addAll(task.getParentContainers());	1702	containers.addAll(task.getParentContainers());
1701	containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getArchiveContainer());	1703	containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(task.getRepositoryUrl()));
1702	containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());	1704	// containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getArchiveContainer());
		1705	// containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
1703	for (AbstractTaskContainer container : containers) {	1706	for (AbstractTaskContainer container : containers) {
1704	refreshJob.refreshTask(container);	1707	refreshJob.refreshTask(container);
1705	}	1708	}

Lines 14-19 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/TaskElementLabelProvider.java (-1 / +21 lines)
14	import org.eclipse.jface.viewers.IColorProvider;	14	import org.eclipse.jface.viewers.IColorProvider;
15	import org.eclipse.jface.viewers.IFontProvider;	15	import org.eclipse.jface.viewers.IFontProvider;
16	import org.eclipse.jface.viewers.LabelProvider;	16	import org.eclipse.jface.viewers.LabelProvider;
		17	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
17	import org.eclipse.mylyn.internal.tasks.core.Person;	18	import org.eclipse.mylyn.internal.tasks.core.Person;
18	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;	19	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
19	import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;	20	import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;
Lines 87-93 Link Here
87		88
88	private CompositeImageDescriptor getImageDescriptor(Object object) {	89	private CompositeImageDescriptor getImageDescriptor(Object object) {
89	CompositeImageDescriptor compositeDescriptor = new CompositeImageDescriptor();	90	CompositeImageDescriptor compositeDescriptor = new CompositeImageDescriptor();
90	if (object instanceof TaskArchive \|\| object instanceof UnfiledCategory) {	91	if (object instanceof TaskArchive \|\| object instanceof OrphanedTasksContainer) {
91	compositeDescriptor.icon = TasksUiImages.CATEGORY_ARCHIVE;	92	compositeDescriptor.icon = TasksUiImages.CATEGORY_ARCHIVE;
92	return compositeDescriptor;	93	return compositeDescriptor;
93	} else if (object instanceof TaskCategory \|\| object instanceof UnfiledCategory) {	94	} else if (object instanceof TaskCategory \|\| object instanceof UnfiledCategory) {
Lines 223-228 Link Here
223	} else if (object instanceof TaskGroup) {	224	} else if (object instanceof TaskGroup) {
224	TaskGroup element = (TaskGroup) object;	225	TaskGroup element = (TaskGroup) object;
225	return element.getSummary();// + " / " + element.getChildren().size();	226	return element.getSummary();// + " / " + element.getChildren().size();
		227	} else if (object instanceof OrphanedTasksContainer) {
		228
		229	OrphanedTasksContainer container = (OrphanedTasksContainer) object;
		230
		231	// OrphanedTasksContainer localArchive = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
		232	// LocalRepositoryConnector.REPOSITORY_URL);
		233	// if (container == localArchive) {
		234	// return "Local Tasks";
		235	// }
		236
		237	String result = container.getSummary();
		238	TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(
		239	container.getConnectorKind(), container.getRepositoryUrl());
		240	if (repository != null) {
		241	result = "Archive: " + repository.getRepositoryLabel();
		242	}
		243
		244	return result;
		245
226	} else if (object instanceof AbstractTaskContainer) {	246	} else if (object instanceof AbstractTaskContainer) {
227	AbstractTaskContainer element = (AbstractTaskContainer) object;	247	AbstractTaskContainer element = (AbstractTaskContainer) object;
228	return element.getSummary();	248	return element.getSummary();

Lines 102-110 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/TaskListContentProvider.java (-5 lines)
102	}	102	}
103		103
104	private boolean taskHasUnfilteredChildren(AbstractTask parent) {	104	private boolean taskHasUnfilteredChildren(AbstractTask parent) {
105	boolean groupSubtasks = !TasksUiPlugin.getDefault().groupSubtasks(parent);
106	if (groupSubtasks)
107	return false;
108	Set<AbstractTask> children = parent.getChildren();	105	Set<AbstractTask> children = parent.getChildren();
109	if (children != null) {	106	if (children != null) {
110	for (AbstractTask task : children) {	107	for (AbstractTask task : children) {
Lines 210-218 Link Here
210	// get all children	207	// get all children
211	for (AbstractTask element : parentTasks) {	208	for (AbstractTask element : parentTasks) {
212	for (AbstractTask abstractTask : element.getChildren()) {	209	for (AbstractTask abstractTask : element.getChildren()) {
213	//if (!filter(element, abstractTask)) {
214	children.add(abstractTask);	210	children.add(abstractTask);
215	//}
216	}	211	}
217	}	212	}
218	for (AbstractTask task : parentTasks) {	213	for (AbstractTask task : parentTasks) {

Lines 34-49 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/actions/MarkTaskUnreadAction.java (-8 / +8 lines)
34	setId(ID);	34	setId(ID);
35	setActionDefinitionId(DEFINITION_ID);	35	setActionDefinitionId(DEFINITION_ID);
36	setImageDescriptor(TasksUiImages.OVERLAY_INCOMMING);	36	setImageDescriptor(TasksUiImages.OVERLAY_INCOMMING);
37	if (containsArchiveContainer(selectedElements)) {	37	// if (containsArchiveContainer(selectedElements)) {
38	setEnabled(false);	38	// setEnabled(false);
		39	// } else {
		40	if (selectedElements.size() == 1 && (selectedElements.get(0) instanceof AbstractTask)) {
		41	AbstractTask task = (AbstractTask) selectedElements.get(0);
		42	setEnabled(!task.isLocal());
39	} else {	43	} else {
40	if (selectedElements.size() == 1 && (selectedElements.get(0) instanceof AbstractTask)) {	44	setEnabled(true);
41	AbstractTask task = (AbstractTask) selectedElements.get(0);
42	setEnabled(!task.isLocal());
43	} else {
44	setEnabled(true);
45	}
46	}	45	}
		46	// }
47	}	47	}
48		48
49	@Override	49	@Override

Lines 442-447 Link Here

(-)src/org/eclipse/mylyn/tasks/ui/TasksUiPlugin.java (-6 / +6 lines)
442	// initialized	442	// initialized
443	taskListManager.init();	443	taskListManager.init();
444	taskListManager.addActivityListener(CONTEXT_TASK_ACTIVITY_LISTENER);	444	taskListManager.addActivityListener(CONTEXT_TASK_ACTIVITY_LISTENER);
		445	// readExistingOrCreateNewList() must be called after repositories have been read in
445	taskListManager.readExistingOrCreateNewList();	446	taskListManager.readExistingOrCreateNewList();
446	initialized = true;	447	initialized = true;
447		448
Lines 482-488 Link Here
482		483
483	// Add standard local task repository	484	// Add standard local task repository
484	if (taskRepositoryManager.getRepository(LocalRepositoryConnector.REPOSITORY_URL) == null) {	485	if (taskRepositoryManager.getRepository(LocalRepositoryConnector.REPOSITORY_URL) == null) {
485	TaskRepository localRepository = new TaskRepository(LocalRepositoryConnector.REPOSITORY_KIND,	486	TaskRepository localRepository = new TaskRepository(LocalRepositoryConnector.CONNECTOR_KIND,
486	LocalRepositoryConnector.REPOSITORY_URL, LocalRepositoryConnector.REPOSITORY_VERSION);	487	LocalRepositoryConnector.REPOSITORY_URL, LocalRepositoryConnector.REPOSITORY_VERSION);
487	localRepository.setRepositoryLabel(LocalRepositoryConnector.REPOSITORY_LABEL);	488	localRepository.setRepositoryLabel(LocalRepositoryConnector.REPOSITORY_LABEL);
488	localRepository.setAnonymous(true);	489	localRepository.setAnonymous(true);
Lines 640-652 Link Here
640	* @param withProgress	641	* @param withProgress
641	*/	642	*/
642	public void reloadDataDirectory(boolean withProgress) {	643	public void reloadDataDirectory(boolean withProgress) {
643	getTaskListManager().resetTaskList();
644	getTaskListManager().getTaskActivationHistory().clear();	644	getTaskListManager().getTaskActivationHistory().clear();
645	getRepositoryManager().readRepositories(getRepositoriesFilePath());	645	getRepositoryManager().readRepositories(getRepositoriesFilePath());
646	loadTemplateRepositories();	646	loadTemplateRepositories();
647	ContextCorePlugin.getContextManager().loadActivityMetaContext();	647	getTaskListManager().resetTaskList();
648	getTaskListManager().setTaskListFile(	648	getTaskListManager().setTaskListFile(
649	new File(getDataDirectory() + File.separator + ITasksUiConstants.DEFAULT_TASK_LIST_FILE));	649	new File(getDataDirectory() + File.separator + ITasksUiConstants.DEFAULT_TASK_LIST_FILE));
		650	ContextCorePlugin.getContextManager().loadActivityMetaContext();
650	getTaskListManager().readExistingOrCreateNewList();	651	getTaskListManager().readExistingOrCreateNewList();
651	getTaskListManager().initActivityHistory();	652	getTaskListManager().initActivityHistory();
652	checkForCredentials();	653	checkForCredentials();
Lines 957-964 Link Here
957	*	958	*
958	* @Deprecated	959	* @Deprecated
959	*/	960	*/
960	public TaskListNotification getIncommingNotification(AbstractRepositoryConnector connector,	961	public TaskListNotification getIncommingNotification(AbstractRepositoryConnector connector, AbstractTask task) {
961	AbstractTask task) {
962		962
963	TaskListNotification notification = new TaskListNotification(task);	963	TaskListNotification notification = new TaskListNotification(task);
964	RepositoryTaskData newTaskData = getTaskDataManager().getNewTaskData(task.getRepositoryUrl(), task.getTaskId());	964	RepositoryTaskData newTaskData = getTaskDataManager().getNewTaskData(task.getRepositoryUrl(), task.getTaskId());
Lines 981-987 Link Here
981	if (!"".equals(chnagedAttributes)) {	981	if (!"".equals(chnagedAttributes)) {
982	description.append(chnagedAttributes);	982	description.append(chnagedAttributes);
983	}	983	}
984		984
985	notification.setDescription(description.toString());	985	notification.setDescription(description.toString());
986		986
987	if (connector != null) {	987	if (connector != null) {

Lines 15-20 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/MoveToCategoryMenuContributor.java (-2 / +3 lines)
15	import org.eclipse.jface.action.Action;	15	import org.eclipse.jface.action.Action;
16	import org.eclipse.jface.action.MenuManager;	16	import org.eclipse.jface.action.MenuManager;
17	import org.eclipse.jface.action.Separator;	17	import org.eclipse.jface.action.Separator;
		18	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
18	import org.eclipse.mylyn.internal.tasks.ui.actions.NewCategoryAction;	19	import org.eclipse.mylyn.internal.tasks.ui.actions.NewCategoryAction;
19	import org.eclipse.mylyn.tasks.core.AbstractTask;	20	import org.eclipse.mylyn.tasks.core.AbstractTask;
20	import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;	21	import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;
Lines 41-47 Link Here
41	.getCategories());	42	.getCategories());
42	Collections.sort(categories);	43	Collections.sort(categories);
43	for (final AbstractTaskCategory category : categories) {	44	for (final AbstractTaskCategory category : categories) {
44	if (!category.equals(TasksUiPlugin.getTaskListManager().getTaskList().getArchiveContainer())) {	45	if (!(category instanceof OrphanedTasksContainer)) {
45	Action action = new Action() {	46	Action action = new Action() {
46	@Override	47	@Override
47	public void run() {	48	public void run() {
Lines 99-105 Link Here
99	private void moveToCategory(final List<AbstractTaskContainer> selectedElements, AbstractTaskCategory category) {	100	private void moveToCategory(final List<AbstractTaskContainer> selectedElements, AbstractTaskCategory category) {
100	for (AbstractTaskContainer element : selectedElements) {	101	for (AbstractTaskContainer element : selectedElements) {
101	if (element instanceof AbstractTask) {	102	if (element instanceof AbstractTask) {
102	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer((AbstractTask) element, category);	103	TasksUiPlugin.getTaskListManager().getTaskList().moveTask((AbstractTask) element, category);
103	}	104	}
104	}	105	}
105	}	106	}

Lines 27-35 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/wizards/TaskDataImportWizard.java (-16 / +13 lines)
27	import org.eclipse.mylyn.internal.monitor.core.util.ZipFileUtil;	27	import org.eclipse.mylyn.internal.monitor.core.util.ZipFileUtil;
28	import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;	28	import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;
29	import org.eclipse.mylyn.monitor.core.StatusHandler;	29	import org.eclipse.mylyn.monitor.core.StatusHandler;
30	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
31	import org.eclipse.mylyn.tasks.core.AbstractTask;
32	import org.eclipse.mylyn.tasks.core.TaskList;
33	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;	30	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
34	import org.eclipse.ui.IImportWizard;	31	import org.eclipse.ui.IImportWizard;
35	import org.eclipse.ui.IWorkbench;	32	import org.eclipse.ui.IWorkbench;
Lines 215-233 Link Here
215	}	212	}
216	}	213	}
217		214
218	/** Returns all tasks in the task list root or a category in the task list */	215	// /** Returns all tasks in the task list root or a category in the task list */
219	protected List<AbstractTask> getAllTasks() {	216	// protected List<AbstractTask> getAllTasks() {
220	List<AbstractTask> allTasks = new ArrayList<AbstractTask>();	217	// List<AbstractTask> allTasks = new ArrayList<AbstractTask>();
221	TaskList taskList = TasksUiPlugin.getTaskListManager().getTaskList();	218	// TaskList taskList = TasksUiPlugin.getTaskListManager().getTaskList();
222		219	//
223	allTasks.addAll(taskList.getDefaultCategory().getChildren());	220	// allTasks.addAll(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).getChildren());
224		221	//
225	for (AbstractTaskContainer category : taskList.getCategories()) {	222	// for (AbstractTaskContainer category : taskList.getCategories()) {
226	allTasks.addAll(category.getChildren());	223	// allTasks.addAll(category.getChildren());
227	}	224	// }
228		225	//
229	return allTasks;	226	// return allTasks;
230	}	227	// }
231		228
232	private void readTaskListData() {	229	private void readTaskListData() {
233	PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {	230	PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {

Lines 11-20 Link Here

(-)src/org/eclipse/mylyn/internal/context/ui/TaskListInterestFilter.java (-43 / +41 lines)
11	import java.util.Calendar;	11	import java.util.Calendar;
12	import java.util.Set;	12	import java.util.Set;
13		13
		14	import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;
14	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;	15	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
15	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;	16	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
16	import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;	17	import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;
17	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;
18	import org.eclipse.mylyn.internal.tasks.ui.AbstractTaskListFilter;	18	import org.eclipse.mylyn.internal.tasks.ui.AbstractTaskListFilter;
19	import org.eclipse.mylyn.monitor.core.StatusHandler;	19	import org.eclipse.mylyn.monitor.core.StatusHandler;
20	import org.eclipse.mylyn.tasks.core.AbstractTask;	20	import org.eclipse.mylyn.tasks.core.AbstractTask;
Lines 47-70 Link Here
47	if (isUninteresting(parent, task)) {	47	if (isUninteresting(parent, task)) {
48	return false;	48	return false;
49	} else if (isInteresting(parent, task)) {	49	} else if (isInteresting(parent, task)) {
50	if (parent instanceof TaskArchive) {	50	// if (parent instanceof TaskArchive) {
51	return (shouldAlwaysShow(child, task, TasksUiPlugin.getDefault().groupSubtasks(task)) && revealInArchive(task));	51	// return (shouldAlwaysShow(child, task, TasksUiPlugin.getDefault().groupSubtasks(task)) && revealInArchive(task));
52	}	52	// }
53	return true;	53	return true;
54	}	54	}
55	}	55	}
56	} else if (child instanceof TaskArchive) {	56	} /*else if (child instanceof TaskArchive) {
57	// Display Archive if contains otherwise non-visible tasks that should always show	57	// Display Archive if contains otherwise non-visible tasks that should always show
58	boolean hasTasksToReveal = false;	58	boolean hasTasksToReveal = false;
59	for (AbstractTask task : ((TaskArchive) child).getChildren()) {	59	for (AbstractTask task : ((TaskArchive) child).getChildren()) {
60	if (shouldAlwaysShow(child, task, TasksUiPlugin.getDefault().groupSubtasks(task))	60	if (shouldAlwaysShow(child, task, TasksUiPlugin.getDefault().groupSubtasks(task))
61	&& revealInArchive(task)) {	61	&& revealInArchive(task)) {
62	hasTasksToReveal = true;	62	hasTasksToReveal = true;
63	break;	63	break;
64	}	64	}
65	}	65	}
66	return hasTasksToReveal;	66	return hasTasksToReveal;
67	} else if (child instanceof AbstractTaskContainer) {	67	}*/else if (child instanceof AbstractTaskContainer) {
68	Set<AbstractTask> children = ((AbstractTaskContainer) child).getChildren();	68	Set<AbstractTask> children = ((AbstractTaskContainer) child).getChildren();
69	// Always display empty containers	69	// Always display empty containers
70	if (children.size() == 0) {	70	if (children.size() == 0) {
Lines 72-78 Link Here
72	}	72	}
73		73
74	for (AbstractTask task : children) {	74	for (AbstractTask task : children) {
75	if (shouldAlwaysShow(child, task, TasksUiPlugin.getDefault().groupSubtasks(task))) {	75	if (shouldAlwaysShow(child, task, ITasksCoreConstants.MAX_SUBTASK_DEPTH)) {
76	return true;	76	return true;
77	}	77	}
78	}	78	}
Lines 84-99 Link Here
84	return false;	84	return false;
85	}	85	}
86		86
87	private boolean revealInArchive(AbstractTask task) {	87	// private boolean revealInArchive(AbstractTask task) {
88	if (TasksUiPlugin.getTaskListManager().getTaskList().getContainerForHandle(task.getHandleIdentifier()) == null	88	// if (TasksUiPlugin.getTaskListManager().getTaskList().getContainerForHandle(task.getHandleIdentifier()) == null
89	&& TasksUiPlugin.getTaskListManager()	89	// && TasksUiPlugin.getTaskListManager()
90	.getTaskList()	90	// .getTaskList()
91	.getQueriesForHandle(task.getHandleIdentifier())	91	// .getQueriesForHandle(task.getHandleIdentifier())
92	.isEmpty()) {	92	// .isEmpty()) {
93	return true;	93	// return true;
94	}	94	// }
95	return false;	95	// return false;
96	}	96	// }
97		97
98	private boolean isDateRangeInteresting(ScheduledTaskContainer container) {	98	private boolean isDateRangeInteresting(ScheduledTaskContainer container) {
99	return TasksUiPlugin.getTaskActivityManager().isWeekDay(container);	99	return TasksUiPlugin.getTaskActivityManager().isWeekDay(container);
Lines 102-108 Link Here
102		102
103	protected boolean isUninteresting(Object parent, AbstractTask task) {	103	protected boolean isUninteresting(Object parent, AbstractTask task) {
104	return !task.isActive()	104	return !task.isActive()
105	&& !hasInterestingSubTasks(parent, task, true)	105	&& !hasInterestingSubTasks(parent, task, ITasksCoreConstants.MAX_SUBTASK_DEPTH)
106	&& ((task.isCompleted() && !TaskActivityManager.getInstance().isCompletedToday(task) && !hasChanges(	106	&& ((task.isCompleted() && !TaskActivityManager.getInstance().isCompletedToday(task) && !hasChanges(
107	parent, task)) \|\| (TaskActivityManager.getInstance().isScheduledAfterThisWeek(task))	107	parent, task)) \|\| (TaskActivityManager.getInstance().isScheduledAfterThisWeek(task))
108	&& !hasChanges(parent, task));	108	&& !hasChanges(parent, task));
Lines 110-140 Link Here
110		110
111	// TODO: make meta-context more explicit	111	// TODO: make meta-context more explicit
112	protected boolean isInteresting(Object parent, AbstractTask task) {	112	protected boolean isInteresting(Object parent, AbstractTask task) {
113	return shouldAlwaysShow(parent, task, TasksUiPlugin.getDefault().groupSubtasks(task));	113	return shouldAlwaysShow(parent, task, ITasksCoreConstants.MAX_SUBTASK_DEPTH);
114	}	114	}
115		115
116	public boolean shouldAlwaysShow(Object parent, AbstractTask task, boolean checkSubTasks) {	116	public boolean shouldAlwaysShow(Object parent, AbstractTask task, int depth) {
117	return task.isActive() \|\| hasChanges(parent, task)	117	return task.isActive() \|\| hasChanges(parent, task)
118	\|\| (TaskActivityManager.getInstance().isCompletedToday(task))	118	\|\| (TaskActivityManager.getInstance().isCompletedToday(task))
119	\|\| shouldShowInFocusedWorkweekDateContainer(parent, task)	119	\|\| shouldShowInFocusedWorkweekDateContainer(parent, task)
120	\|\| (isInterestingForThisWeek(parent, task) && !task.isCompleted())	120	\|\| (isInterestingForThisWeek(parent, task) && !task.isCompleted())
121	\|\| (TaskActivityManager.getInstance().isOverdue(task))	121	\|\| (TaskActivityManager.getInstance().isOverdue(task)) \|\| hasInterestingSubTasks(parent, task, depth)
122	\|\| hasInterestingSubTasks(parent, task, checkSubTasks)
123	\|\| LocalRepositoryConnector.DEFAULT_SUMMARY.equals(task.getSummary());	122	\|\| LocalRepositoryConnector.DEFAULT_SUMMARY.equals(task.getSummary());
124	// \|\| isCurrentlySelectedInEditor(task);	123	// \|\| isCurrentlySelectedInEditor(task);
125	}	124	}
126		125
127	private boolean hasInterestingSubTasks(Object parent, AbstractTask task, boolean checkSubTasks) {	126	private boolean hasInterestingSubTasks(Object parent, AbstractTask task, int depth) {
128	if (!checkSubTasks) {	127	if (depth > 0) {
129	return false;	128	if (!TasksUiPlugin.getDefault().groupSubtasks(task)) {
130	}	129	return false;
131	if (!TasksUiPlugin.getDefault().groupSubtasks(task)) {	130	}
132	return false;	131	if (task.getChildren() != null && task.getChildren().size() > 0) {
133	}	132	for (AbstractTask subTask : task.getChildren()) {
134	if (task.getChildren() != null && task.getChildren().size() > 0) {	133	if (shouldAlwaysShow(parent, subTask, depth - 1)) {
135	for (AbstractTask subTask : task.getChildren()) {	134	return true;
136	if (shouldAlwaysShow(parent, subTask, false)) {	135	}
137	return true;
138	}	136	}
139	}	137	}
140	}	138	}

Lines 86-96 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskListUiTest.java (-16 / +14 lines)
86	TaskListView.openInActivePerspective();	86	TaskListView.openInActivePerspective();
87	manager = TasksUiPlugin.getTaskListManager();	87	manager = TasksUiPlugin.getTaskListManager();
88	cat1 = new TaskCategory("First Category");	88	cat1 = new TaskCategory("First Category");
89		89	manager.getTaskList().addCategory(cat1);
90	cat1task1 = manager.createNewLocalTask("task 1");	90	cat1task1 = manager.createNewLocalTask("task 1");
91	cat1task1.setPriority(PriorityLevel.P1.toString());	91	cat1task1.setPriority(PriorityLevel.P1.toString());
92	cat1task1.setCompleted(true);	92	cat1task1.setCompleted(true);
93	manager.getTaskList().moveToContainer(cat1task1, cat1);	93	manager.getTaskList().moveTask(cat1task1, cat1);
94		94
95	cat1task1sub1 = manager.createNewLocalTask("sub task 1");	95	cat1task1sub1 = manager.createNewLocalTask("sub task 1");
96	cat1task1sub1.setPriority(PriorityLevel.P1.toString());	96	cat1task1sub1.setPriority(PriorityLevel.P1.toString());
Lines 100-125 Link Here
100	cat1task2 = manager.createNewLocalTask("task 2");	100	cat1task2 = manager.createNewLocalTask("task 2");
101	cat1task2.setPriority(PriorityLevel.P2.toString());	101	cat1task2.setPriority(PriorityLevel.P2.toString());
102	cat1task2.addParentContainer(cat1);	102	cat1task2.addParentContainer(cat1);
103	manager.getTaskList().moveToContainer(cat1task2, cat1);	103	manager.getTaskList().moveTask(cat1task2, cat1);
104		104
105	cat1task3 = manager.createNewLocalTask("task 3");	105	cat1task3 = manager.createNewLocalTask("task 3");
106	cat1task3.setPriority(PriorityLevel.P3.toString());	106	cat1task3.setPriority(PriorityLevel.P3.toString());
107	cat1task3.setCompleted(true);	107	cat1task3.setCompleted(true);
108	cat1task3.addParentContainer(cat1);	108	cat1task3.addParentContainer(cat1);
109	manager.getTaskList().moveToContainer(cat1task3, cat1);	109	manager.getTaskList().moveTask(cat1task3, cat1);
110		110
111	cat1task4 = manager.createNewLocalTask("task 4");	111	cat1task4 = manager.createNewLocalTask("task 4");
112	cat1task4.setPriority(PriorityLevel.P4.toString());	112	cat1task4.setPriority(PriorityLevel.P4.toString());
113	cat1task4.addParentContainer(cat1);	113	cat1task4.addParentContainer(cat1);
114	manager.getTaskList().moveToContainer(cat1task4, cat1);	114	manager.getTaskList().moveTask(cat1task4, cat1);
115		115
116	cat1task5 = manager.createNewLocalTask("task 5");	116	cat1task5 = manager.createNewLocalTask("task 5");
117	cat1task5.setPriority(PriorityLevel.P5.toString());	117	cat1task5.setPriority(PriorityLevel.P5.toString());
118	cat1task5.setCompleted(true);	118	cat1task5.setCompleted(true);
119	cat1task5.addParentContainer(cat1);	119	cat1task5.addParentContainer(cat1);
120	manager.getTaskList().moveToContainer(cat1task5, cat1);	120	manager.getTaskList().moveTask(cat1task5, cat1);
121		121
122	manager.getTaskList().addCategory(cat1);
123	assertEquals(cat1.getChildren().size(), 5);	122	assertEquals(cat1.getChildren().size(), 5);
124		123
125	cat2 = new TaskCategory("Second Category");	124	cat2 = new TaskCategory("Second Category");
Lines 127-133 Link Here
127	cat2task1 = manager.createNewLocalTask("task 1");	126	cat2task1 = manager.createNewLocalTask("task 1");
128	cat2task1.setPriority(PriorityLevel.P1.toString());	127	cat2task1.setPriority(PriorityLevel.P1.toString());
129	cat2task1.addParentContainer(cat2);	128	cat2task1.addParentContainer(cat2);
130	manager.getTaskList().moveToContainer(cat2task1, cat2);	129	manager.getTaskList().moveTask(cat2task1, cat2);
131		130
132	cat2task1sub1 = manager.createNewLocalTask("sub task 1");	131	cat2task1sub1 = manager.createNewLocalTask("sub task 1");
133	cat2task1sub1.setPriority(PriorityLevel.P1.toString());	132	cat2task1sub1.setPriority(PriorityLevel.P1.toString());
Lines 137-159 Link Here
137	cat2task2.setPriority(PriorityLevel.P2.toString());	136	cat2task2.setPriority(PriorityLevel.P2.toString());
138	cat2task2.setCompleted(true);	137	cat2task2.setCompleted(true);
139	cat2task2.addParentContainer(cat2);	138	cat2task2.addParentContainer(cat2);
140	manager.getTaskList().moveToContainer(cat2task2, cat2);	139	manager.getTaskList().moveTask(cat2task2, cat2);
141		140
142	cat2task3 = manager.createNewLocalTask("task 3");	141	cat2task3 = manager.createNewLocalTask("task 3");
143	cat2task3.setPriority(PriorityLevel.P3.toString());	142	cat2task3.setPriority(PriorityLevel.P3.toString());
144	cat2task3.addParentContainer(cat2);	143	cat2task3.addParentContainer(cat2);
145	manager.getTaskList().moveToContainer(cat2task3, cat2);	144	manager.getTaskList().moveTask(cat2task3, cat2);
146		145
147	cat2task4 = manager.createNewLocalTask("task 4");	146	cat2task4 = manager.createNewLocalTask("task 4");
148	cat2task4.setPriority(PriorityLevel.P4.toString());	147	cat2task4.setPriority(PriorityLevel.P4.toString());
149	cat2task4.setCompleted(true);	148	cat2task4.setCompleted(true);
150	cat2task4.addParentContainer(cat2);	149	cat2task4.addParentContainer(cat2);
151	manager.getTaskList().moveToContainer(cat2task4, cat2);	150	manager.getTaskList().moveTask(cat2task4, cat2);
152		151
153	cat2task5 = manager.createNewLocalTask("task 5");	152	cat2task5 = manager.createNewLocalTask("task 5");
154	cat2task5.setPriority(PriorityLevel.P5.toString());	153	cat2task5.setPriority(PriorityLevel.P5.toString());
155	cat2task5.addParentContainer(cat2);	154	cat2task5.addParentContainer(cat2);
156	manager.getTaskList().moveToContainer(cat2task5, cat2);	155	manager.getTaskList().moveTask(cat2task5, cat2);
157		156
158	manager.getTaskList().addCategory(cat2);	157	manager.getTaskList().addCategory(cat2);
159	manager.saveTaskList();	158	manager.saveTaskList();
Lines 171-178 Link Here
171	TaskListView view = TaskListView.getFromActivePerspective();	170	TaskListView view = TaskListView.getFromActivePerspective();
172	assertNotNull(view);	171	assertNotNull(view);
173	WebTask webTask = new WebTask("1", "1", "", "", "web");	172	WebTask webTask = new WebTask("1", "1", "", "", "web");
174	TasksUiPlugin.getTaskListManager().getTaskList().addTask(webTask,	173	TasksUiPlugin.getTaskListManager().getTaskList().addTask(webTask);
175	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
176	view.getViewer().refresh();	174	view.getViewer().refresh();
177	// Arrays.asList(view.getViewer().getVisibleExpandedElements());	175	// Arrays.asList(view.getViewer().getVisibleExpandedElements());
178	assertFalse(webTask.isCompleted());	176	assertFalse(webTask.isCompleted());
Lines 251-260 Link Here
251	MoveToCategoryMenuContributor moveToMenuContrib = new MoveToCategoryMenuContributor();	249	MoveToCategoryMenuContributor moveToMenuContrib = new MoveToCategoryMenuContributor();
252	List<AbstractTaskContainer> selectedElements = new Vector<AbstractTaskContainer>();	250	List<AbstractTaskContainer> selectedElements = new Vector<AbstractTaskContainer>();
253	selectedElements.add(cat1task1);	251	selectedElements.add(cat1task1);
254	int numCategoriesMinusArchiveContainer = manager.getTaskList().getCategories().size() - 1;	252	int numCategories = manager.getTaskList().getCategories().size();
255	int numSeparators = 1;	253	int numSeparators = 1;
256	// adding a separator and the New Category... action	254	// adding a separator and the New Category... action
257	int expectedNrOfSubMenuEntries = numCategoriesMinusArchiveContainer + numSeparators + 1;	255	int expectedNrOfSubMenuEntries = numCategories + numSeparators + 1;
258	NewCategoryAction newCatActon = new NewCategoryAction();	256	NewCategoryAction newCatActon = new NewCategoryAction();
259		257
260	// execute sytem under test	258	// execute sytem under test

Lines 45-53 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskHistoryTest.java (-9 / +9 lines)
45		45
46	protected AbstractTask task5 = null;	46	protected AbstractTask task5 = null;
47		47
48	private ActivateTaskHistoryDropDownAction previousTaskAction = new ActivateTaskHistoryDropDownAction(TasksUiPlugin.getTaskListManager()	48	private ActivateTaskHistoryDropDownAction previousTaskAction = new ActivateTaskHistoryDropDownAction(
49	.getTaskActivationHistory(), false);	49	TasksUiPlugin.getTaskListManager().getTaskActivationHistory(), false);
50		50
51	@Override	51	@Override
52	protected void setUp() throws Exception {	52	protected void setUp() throws Exception {
53	super.setUp();	53	super.setUp();
Lines 57-75 Link Here
57	resetHistory();	57	resetHistory();
58		58
59	task1 = manager.createNewLocalTask("task 1");	59	task1 = manager.createNewLocalTask("task 1");
60	manager.getTaskList().moveToContainer(task1, manager.getTaskList().getDefaultCategory());	60	manager.getTaskList().addTask(task1);
61		61
62	task2 = manager.createNewLocalTask("task 2");	62	task2 = manager.createNewLocalTask("task 2");
63	manager.getTaskList().moveToContainer(task2, manager.getTaskList().getDefaultCategory());	63	manager.getTaskList().addTask(task2);
64		64
65	task3 = manager.createNewLocalTask("task 3");	65	task3 = manager.createNewLocalTask("task 3");
66	manager.getTaskList().moveToContainer(task3, manager.getTaskList().getDefaultCategory());	66	manager.getTaskList().addTask(task3);
67		67
68	task4 = manager.createNewLocalTask("task 4");	68	task4 = manager.createNewLocalTask("task 4");
69	manager.getTaskList().moveToContainer(task4, manager.getTaskList().getDefaultCategory());	69	manager.getTaskList().addTask(task4);
70		70
71	task5 = manager.createNewLocalTask("task 5");	71	task5 = manager.createNewLocalTask("task 5");
72	manager.getTaskList().moveToContainer(task5, manager.getTaskList().getDefaultCategory());	72	manager.getTaskList().addTask(task5);
73		73
74	history = manager.getTaskActivationHistory();	74	history = manager.getTaskActivationHistory();
75	}	75	}
Lines 95-101 Link Here
95	assertTrue(task3.isActive());	95	assertTrue(task3.isActive());
96	assertFalse(task2.isActive());	96	assertFalse(task2.isActive());
97	assertFalse(task1.isActive());	97	assertFalse(task1.isActive());
98		98
99	previousTaskAction.run();	99	previousTaskAction.run();
100	assertTrue(task2.isActive());	100	assertTrue(task2.isActive());
101		101

Lines 37-43 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/AllTasksTests.java (-1 / +2 lines)
37	suite.addTestSuite(TaskRepositoryManagerTest.class);	37	suite.addTestSuite(TaskRepositoryManagerTest.class);
38	suite.addTestSuite(TaskRepositoriesExternalizerTest.class);	38	suite.addTestSuite(TaskRepositoriesExternalizerTest.class);
39	suite.addTestSuite(TaskListContentProviderTest.class);	39	suite.addTestSuite(TaskListContentProviderTest.class);
40	suite.addTestSuite(TaskListBackupManagerTest.class);	40	//suite.addTestSuite(TaskListBackupManagerTest.class);
41	suite.addTestSuite(TableSorterTest.class);	41	suite.addTestSuite(TableSorterTest.class);
42	suite.addTestSuite(TaskKeyComparatorTest.class);	42	suite.addTestSuite(TaskKeyComparatorTest.class);
43	suite.addTestSuite(TaskTest.class);	43	suite.addTestSuite(TaskTest.class);
Lines 60-65 Link Here
60	suite.addTestSuite(PersonProposalProviderTest.class);	60	suite.addTestSuite(PersonProposalProviderTest.class);
61	suite.addTestSuite(TaskRepositoryLocationTest.class);	61	suite.addTestSuite(TaskRepositoryLocationTest.class);
62	suite.addTestSuite(AbstractTaskDataHandlerTest.class);	62	suite.addTestSuite(AbstractTaskDataHandlerTest.class);
		63	suite.addTestSuite(OrphanedTasksTest.class);
63	// $JUnit-END$	64	// $JUnit-END$
64		65
65	// suite.addTestSuite(BackgroundSaveTest.class);	66	// suite.addTestSuite(BackgroundSaveTest.class);

Lines 59-65 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskRepositoryManagerTest.java (-1 / +5 lines)
59		59
60	TaskRepository repository1 = new TaskRepository("bugzilla", "http://repository1/");	60	TaskRepository repository1 = new TaskRepository("bugzilla", "http://repository1/");
61	manager.addRepository(repository1, TasksUiPlugin.getDefault().getRepositoriesFilePath());	61	manager.addRepository(repository1, TasksUiPlugin.getDefault().getRepositoriesFilePath());
62	assertEquals(1, manager.getAllRepositories().size());
63	assertNotNull(manager.getRepository("http://repository1"));	62	assertNotNull(manager.getRepository("http://repository1"));
64	assertNotNull(manager.getRepository("http://repository1/"));	63	assertNotNull(manager.getRepository("http://repository1/"));
65		64
Lines 69-74 Link Here
69	}	68	}
70		69
71	public void testQueryDeletion() {	70	public void testQueryDeletion() {
		71	TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND,
		72	MockRepositoryConnector.REPOSITORY_URL);
		73	TasksUiPlugin.getRepositoryManager().addRepository(repository,
		74	TasksUiPlugin.getDefault().getRepositoriesFilePath());
		75
72	MockRepositoryTask task = new MockRepositoryTask("1");	76	MockRepositoryTask task = new MockRepositoryTask("1");
73	task.setLastReadTimeStamp("now");	77	task.setLastReadTimeStamp("now");
74	MockRepositoryQuery query = new MockRepositoryQuery("Test");	78	MockRepositoryQuery query = new MockRepositoryQuery("Test");

Lines 15-25 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/connector/MockRepositoryQuery.java (-2 / +3 lines)
15	*/	15	*/
16	public class MockRepositoryQuery extends AbstractRepositoryQuery {	16	public class MockRepositoryQuery extends AbstractRepositoryQuery {
17		17
18	public String MOCK_URL = "http://mock.repository";	18	public String MOCK_QUERY_URL = MockRepositoryConnector.REPOSITORY_URL + ".query";
19		19
20	public MockRepositoryQuery(String description) {	20	public MockRepositoryQuery(String description) {
21	super(description);	21	super(description);
22	super.setUrl(MOCK_URL);	22	super.setUrl(MOCK_QUERY_URL);
		23	super.setRepositoryUrl(MockRepositoryConnector.REPOSITORY_URL);
23	}	24	}
24		25
25	public MockRepositoryQuery(String description, String url) {	26	public MockRepositoryQuery(String description, String url) {

Added Link Here

(-)src/org/eclipse/mylyn/tasks/tests/OrphanedTasksTest.java (+303 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004, 2007 Mylyn project committers and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/
8
9	package org.eclipse.mylyn.tasks.tests;
10
11	import java.util.Set;
12
13	import junit.framework.TestCase;
14
15	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
16	import org.eclipse.mylyn.internal.tasks.core.LocalTask;
17	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
18	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
19	import org.eclipse.mylyn.tasks.core.AbstractTask;
20	import org.eclipse.mylyn.tasks.core.TaskList;
21	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryConnector;
22	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryQuery;
23	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryTask;
24	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
25
26	/**
27	* @author Rob Elves
28	*/
29	public class OrphanedTasksTest extends TestCase {
30
31	private TaskList taskList;
32
33	protected void setUp() throws Exception {
34	super.setUp();
35	TasksUiPlugin.getTaskListManager().resetTaskList();
36	taskList = TasksUiPlugin.getTaskListManager().getTaskList();
37	assertTrue(taskList.getDefaultCategory().isEmpty());
38	}
39
40	protected void tearDown() throws Exception {
41	super.tearDown();
42	}
43
44	/**
45	* y New local tasks should automatically be created in the Local orphaned folder
46	*/
47	public void testAddLocalTask() {
48	Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getRepositoryTasks(
49	LocalRepositoryConnector.REPOSITORY_URL);
50	assertTrue(tasks.isEmpty());
51	AbstractTask localTask = TasksUiPlugin.getTaskListManager().createNewLocalTask("Task 1");
52	assertNotNull(localTask);
53	assertEquals(1, localTask.getParentContainers().size());
54	}
55
56	/**
57	* When a local tasks is removed from a category it should be placed in the Uncategorized folder
58	*/
59	public void testRemoveLocalTask() {
60	TaskCategory category = new TaskCategory("taskCategoryHandle");
61	taskList.addCategory(category);
62	LocalTask newTask = new LocalTask("" + taskList.getNextLocalTaskId(), "new local task");
63	taskList.addTask(newTask, category);
64	//assertEquals(1, taskList.getOrphanContainers().size());
65	assertEquals(2, taskList.getCategories().size());
66	taskList.removeFromCategory(category, newTask);
67	//assertEquals(taskList.getOrphanContainers().size(), 1);
68	assertFalse(category.contains(newTask.getHandleIdentifier()));
69	assertTrue(taskList.getDefaultCategory().contains(newTask.getHandleIdentifier()));
70	assertEquals(1, newTask.getParentContainers().size());
71	assertEquals(taskList.getDefaultCategory().getHandleIdentifier(), newTask.getParentContainers()
72	.iterator()
73	.next()
74	.getHandleIdentifier());
75	}
76
77	/**
78	* Local tasks in a removed category should be orphaned.
79	*/
80	public void testLocalTaskOrphanedInDeletedTaskCategory() {
81	assertTrue(taskList.getDefaultCategory().isEmpty());
82	TaskCategory category = new TaskCategory("taskCategoryHandle");
83	taskList.addCategory(category);
84	LocalTask newTask = new LocalTask("" + taskList.getNextLocalTaskId(), "new local task");
85	taskList.addTask(newTask, category);
86	assertTrue(taskList.getDefaultCategory().isEmpty());
87	taskList.deleteCategory(category);
88	assertTrue(taskList.getDefaultCategory().contains(newTask.getHandleIdentifier()));
89
90	}
91
92	/**
93	* Query removed with task in category, just query removed task remains.
94	*/
95	public void testTaskRemovedFromQuery() {
96	MockRepositoryTask mockTask = new MockRepositoryTask("1");
97	mockTask.setLastReadTimeStamp("now");
98	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
99	taskList.addQuery(mockQuery);
100	taskList.addTask(mockTask, mockQuery);
101
102	taskList.removeFromQuery(mockQuery, mockTask);
103
104	assertFalse(mockQuery.contains(mockTask.getHandleIdentifier()));
105	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
106	mockTask.getHandleIdentifier()));
107	}
108
109	/**
110	* Query removed with task in category, just query removed task remains.
111	*/
112	public void testTaskRemovedFromQueryButInCategory() {
113	MockRepositoryTask mockTask = new MockRepositoryTask("1");
114	mockTask.setLastReadTimeStamp("now");
115	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
116	taskList.addQuery(mockQuery);
117	taskList.addTask(mockTask, mockQuery);
118
119	TaskCategory category = new TaskCategory("taskCategoryHandle");
120	taskList.addCategory(category);
121	taskList.addTask(mockTask, category);
122	assertTrue(category.contains(mockTask.getHandleIdentifier()));
123	taskList.removeFromQuery(mockQuery, mockTask);
124
125	assertFalse(mockQuery.contains(mockTask.getHandleIdentifier()));
126	assertEquals(2, taskList.getCategories().size());
127	assertTrue(category.contains(mockTask.getHandleIdentifier()));
128
129	//* Repository tasks within a removed category that are not in a query should be orphaned.
130
131	taskList.removeFromCategory(category, mockTask);
132	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
133	mockTask.getHandleIdentifier()));
134	}
135
136	/**
137	* Repository tasks that exists in a query are not orphaned.
138	*/
139	public void testRepositoryTaskInDeletedCategory() {
140	MockRepositoryTask mockTask = new MockRepositoryTask("1");
141	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
142	taskList.addQuery(mockQuery);
143	taskList.addTask(mockTask, mockQuery);
144	assertEquals(1, taskList.getCategories().size());
145	TaskCategory category = new TaskCategory("taskCategoryHandle");
146	taskList.addCategory(category);
147	taskList.addTask(mockTask, category);
148	assertEquals(2, taskList.getCategories().size());
149	assertTrue(taskList.getDefaultCategory().isEmpty());
150	taskList.deleteCategory(category);
151	assert (taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).isEmpty());
152	assertEquals(1, taskList.getCategories().size());
153	}
154
155	/**
156	* Repository tasks that exist in another query are not orphaned
157	*/
158	public void testRemovalOfTaskInTwoQueries() {
159	MockRepositoryTask mockTask = new MockRepositoryTask("1");
160	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query 1");
161	MockRepositoryQuery mockQuery2 = new MockRepositoryQuery("mock query 2");
162	taskList.addQuery(mockQuery);
163	taskList.addQuery(mockQuery2);
164	taskList.addTask(mockTask, mockQuery);
165	taskList.addTask(mockTask, mockQuery2);
166
167	taskList.removeFromQuery(mockQuery2, mockTask);
168	assertTrue(mockQuery2.isEmpty());
169	assertFalse(mockQuery.isEmpty());
170	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).isEmpty());
171	}
172
173	/**
174	* Moving an orphan to a Category should result in the task only being present in the target Category
175	*/
176	public void testMoveLocalTask() {
177	TaskCategory category = new TaskCategory("taskCategoryHandle");
178	taskList.addCategory(category);
179	LocalTask newTask = new LocalTask("" + taskList.getNextLocalTaskId(), "new local task");
180	taskList.addTask(newTask, null);
181	assertTrue(taskList.getDefaultCategory().contains(newTask.getHandleIdentifier()));
182	taskList.moveTask(newTask, category);
183	assertFalse(taskList.getDefaultCategory().contains(newTask.getHandleIdentifier()));
184	}
185
186	public void testAddRepositoryTask() {
187	MockRepositoryTask mockTask = new MockRepositoryTask("1");
188	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
189	TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
190	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);
191	Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getRepositoryTasks(
192	MockRepositoryConnector.REPOSITORY_URL);
193	assertFalse(tasks.isEmpty());
194	AbstractRepositoryQuery query = TasksUiPlugin.getTaskListManager().getTaskList().getQueryForHandle(
195	mockTask.getHandleIdentifier());
196	assertEquals(mockQuery, query);
197	assertFalse(query.isEmpty());
198	assertTrue(TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
199	MockRepositoryConnector.REPOSITORY_URL).isEmpty());
200	}
201
202	public void testMoveRepositoryTask() {
203	TaskList tasklist = TasksUiPlugin.getTaskListManager().getTaskList();
204	assertTrue(tasklist.getAllTasks().isEmpty());
205
206	MockRepositoryTask mockTask = new MockRepositoryTask("1");
207	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
208	TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
209	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);
210
211	TaskCategory category = new TaskCategory("taskCategoryHandle");
212	taskList.addCategory(category);
213
214	taskList.moveTask(mockTask, category);
215	assertTrue(taskList.getDefaultCategory().isEmpty());
216	assertTrue(category.contains(mockTask.getHandleIdentifier()));
217	assertTrue(mockQuery.contains(mockTask.getHandleIdentifier()));
218
219	}
220
221	public void testRefactorOrphanedHandle() {
222	MockRepositoryTask mockTask = new MockRepositoryTask("1");
223	mockTask.setLastReadTimeStamp("now");
224	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
225	taskList.addQuery(mockQuery);
226	taskList.addTask(mockTask, mockQuery);
227
228	taskList.removeFromQuery(mockQuery, mockTask);
229
230	assertFalse(mockQuery.contains(mockTask.getHandleIdentifier()));
231	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
232	mockTask.getHandleIdentifier()));
233
234	taskList.refactorRepositoryUrl(MockRepositoryConnector.REPOSITORY_URL, MockRepositoryConnector.REPOSITORY_URL
235	+ "new");
236	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL + "new").contains(
237	mockTask.getHandleIdentifier()));
238	}
239
240	public void testOrphanedSubtasks() {
241	MockRepositoryTask mockTask = new MockRepositoryTask("1");
242	MockRepositoryTask mockTask2 = new MockRepositoryTask("2");
243	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
244	TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
245	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);
246	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask2, mockTask);
247
248	assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
249	mockTask.getHandleIdentifier()));
250	assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
251	mockTask2.getHandleIdentifier()));
252
253	assertNotNull(taskList.getTask(mockTask.getHandleIdentifier()));
254	assertNotNull(taskList.getTask(mockTask2.getHandleIdentifier()));
255	assertNotNull(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL));
256	taskList.removeFromQuery(mockQuery, mockTask);
257	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
258	mockTask.getHandleIdentifier()));
259	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
260	mockTask2.getHandleIdentifier()));
261	taskList.deleteTask(mockTask);
262	assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
263	mockTask.getHandleIdentifier()));
264	// mockTask2 should be orphaned when the parent task is deleted
265	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
266	mockTask2.getHandleIdentifier()));
267	}
268
269	/**
270	* If a task with subtasks falls out of a query, if its subtasks are subtasks of another task that is still around,
271	* they shouldn't be in the archive.
272	*/
273	public void testOrphanedSubtaskWithOtherParent() {
274	MockRepositoryTask mockTask = new MockRepositoryTask("1");
275	MockRepositoryTask mockTask2 = new MockRepositoryTask("2");
276	MockRepositoryTask mockTask3 = new MockRepositoryTask("3");
277	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
278	TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
279	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);
280	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask2, mockTask);
281	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask3, mockQuery);
282	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask2, mockTask3);
283	assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
284	mockTask.getHandleIdentifier()));
285	assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
286	mockTask2.getHandleIdentifier()));
287	assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
288	mockTask3.getHandleIdentifier()));
289
290	taskList.removeFromQuery(mockQuery, mockTask);
291	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
292	mockTask.getHandleIdentifier()));
293	assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
294	mockTask2.getHandleIdentifier()));
295
296	taskList.removeFromQuery(mockQuery, mockTask3);
297	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
298	mockTask3.getHandleIdentifier()));
299	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
300	mockTask2.getHandleIdentifier()));
301
302	}
303	}

Lines 18-23 Link Here

(-)src/org/eclipse/mylyn/tests/integration/ChangeDataDirTest.java (-3 / +4 lines)
18	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;	18	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
19	import org.eclipse.mylyn.internal.context.core.InteractionContextManager;	19	import org.eclipse.mylyn.internal.context.core.InteractionContextManager;
20	import org.eclipse.mylyn.internal.monitor.usage.UiUsageMonitorPlugin;	20	import org.eclipse.mylyn.internal.monitor.usage.UiUsageMonitorPlugin;
		21	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
21	import org.eclipse.mylyn.monitor.core.InteractionEvent;	22	import org.eclipse.mylyn.monitor.core.InteractionEvent;
22	import org.eclipse.mylyn.tasks.core.AbstractTask;	23	import org.eclipse.mylyn.tasks.core.AbstractTask;
23	import org.eclipse.mylyn.tasks.ui.TaskListManager;	24	import org.eclipse.mylyn.tasks.ui.TaskListManager;
Lines 95-101 Link Here
95	public void testTaskMove() {	96	public void testTaskMove() {
96	AbstractTask task = manager.createNewLocalTask("label");	97	AbstractTask task = manager.createNewLocalTask("label");
97	String handle = task.getHandleIdentifier();	98	String handle = task.getHandleIdentifier();
98	manager.getTaskList().moveToContainer(task, manager.getTaskList().getDefaultCategory());	99	manager.getTaskList().moveTask(task,
		100	manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL));
99		101
100	AbstractTask readTaskBeforeMove = manager.getTaskList().getTask(handle);	102	AbstractTask readTaskBeforeMove = manager.getTaskList().getTask(handle);
101	TasksUiPlugin.getTaskListManager().copyDataDirContentsTo(newDataDir);	103	TasksUiPlugin.getTaskListManager().copyDataDirContentsTo(newDataDir);
Lines 127-133 Link Here
127	}	129	}
128		130
129	private void addBugzillaTask(BugzillaTask newTask) {	131	private void addBugzillaTask(BugzillaTask newTask) {
130	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(newTask,	132	TasksUiPlugin.getTaskListManager().getTaskList().addTask(newTask);
131	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
132	}	133	}
133	}	134	}

Lines 59-81 Link Here

(-)src/org/eclipse/mylyn/tests/integration/TaskListFilterTest.java (-5 / +5 lines)
59	taskCompleted = new LocalTask("1", "completed");	59	taskCompleted = new LocalTask("1", "completed");
60	taskCompleted.setCompleted(true);	60	taskCompleted.setCompleted(true);
61	taskCompleted.setCompletionDate(TaskActivityUtil.snapForwardNumDays(Calendar.getInstance(), -1).getTime());	61	taskCompleted.setCompletionDate(TaskActivityUtil.snapForwardNumDays(Calendar.getInstance(), -1).getTime());
62	manager.getTaskList().addTask(taskCompleted, manager.getTaskList().getDefaultCategory());	62	manager.getTaskList().addTask(taskCompleted);
63		63
64	taskIncomplete = new LocalTask("2", "t-incomplete");	64	taskIncomplete = new LocalTask("2", "t-incomplete");
65	manager.getTaskList().addTask(taskIncomplete, manager.getTaskList().getDefaultCategory());	65	manager.getTaskList().addTask(taskIncomplete);
66		66
67	taskOverdue = new LocalTask("3", "t-overdue");	67	taskOverdue = new LocalTask("3", "t-overdue");
68	taskOverdue.setScheduledForDate(TaskActivityUtil.snapForwardNumDays(Calendar.getInstance(), -1).getTime());	68	taskOverdue.setScheduledForDate(TaskActivityUtil.snapForwardNumDays(Calendar.getInstance(), -1).getTime());
69	manager.getTaskList().addTask(taskOverdue, manager.getTaskList().getDefaultCategory());	69	manager.getTaskList().addTask(taskOverdue);
70		70
71	taskDueToday = new LocalTask("4", "t-today");	71	taskDueToday = new LocalTask("4", "t-today");
72	taskDueToday.setScheduledForDate(TaskActivityUtil.snapEndOfWorkDay(Calendar.getInstance()).getTime());	72	taskDueToday.setScheduledForDate(TaskActivityUtil.snapEndOfWorkDay(Calendar.getInstance()).getTime());
73	manager.getTaskList().addTask(taskDueToday, manager.getTaskList().getDefaultCategory());	73	manager.getTaskList().addTask(taskDueToday);
74		74
75	taskCompletedToday = new LocalTask("5", "t-donetoday");	75	taskCompletedToday = new LocalTask("5", "t-donetoday");
76	taskCompletedToday.setScheduledForDate(TaskActivityUtil.snapEndOfWorkDay(Calendar.getInstance()).getTime());	76	taskCompletedToday.setScheduledForDate(TaskActivityUtil.snapEndOfWorkDay(Calendar.getInstance()).getTime());
77	taskCompletedToday.setCompleted(true);	77	taskCompletedToday.setCompleted(true);
78	manager.getTaskList().addTask(taskCompletedToday, manager.getTaskList().getDefaultCategory());	78	manager.getTaskList().addTask(taskCompletedToday);
79	}	79	}
80		80
81	@Override	81	@Override