Attachment #152557 for bug #226618

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





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

import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.util.SafeRunnable;
import org.eclipse.mylyn.commons.core.StatusHandler;
import org.eclipse.mylyn.context.core.AbstractContextListener;
import org.eclipse.mylyn.context.core.AbstractContextStructureBridge;
import org.eclipse.mylyn.context.core.ContextChangeEvent;
import org.eclipse.mylyn.context.core.ContextCore;
import org.eclipse.mylyn.context.core.IInteractionContextManager;
import org.eclipse.mylyn.context.core.IInteractionElement;
import org.eclipse.mylyn.context.ui.AbstractContextUiBridge;
import org.eclipse.mylyn.context.ui.ContextUi;

import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.XMLMemento;
import org.eclipse.ui.internal.EditorManager;
import org.eclipse.ui.internal.IPreferenceConstants;
import org.eclipse.ui.internal.IWorkbenchConstants;
import org.eclipse.ui.internal.Workbench;
import org.eclipse.ui.internal.WorkbenchPage;
import org.eclipse.ui.internal.WorkbenchWindow;
import org.eclipse.ui.preferences.ScopedPreferenceStore;

/**
 * @author Mik Kersten
 * @author Shawn Minto
 */
public class ContextEditorManager {

	private class MementoListener extends ContextMementoListener {

		@Override
		public void clearState(String contextHandle, boolean isActiveContext) {
			ContextEditorManager.this.clearState(contextHandle, isActiveContext);
		};

		@Override
		public void restoreState(ContextMemento memento) {
			ContextEditorManager.this.restoreState(memento);
		}

		@Override
		public void saveState(ContextMemento memento) {
			ContextEditorManager.this.saveState(memento);
		}

	}

	private class ContextListener extends AbstractContextListener {

		@Override
		public void contextChanged(ContextChangeEvent event) {
			switch (event.getEventKind()) {
			case INTEREST_CHANGED:
				for (IInteractionElement element : event.getElements()) {
					closeEditor(element, false);
				}
				break;
			case ELEMENTS_DELETED:
				for (IInteractionElement element : event.getElements()) {
					closeEditor(element, true);
				}
				break;
			}
		}
	}

	private static final String KEY_MONITORED_WINDOW_OPEN_EDITORS = "MonitoredWindowOpenEditors"; //$NON-NLS-1$


	private boolean previousCloseEditorsSetting = Workbench.getInstance().getPreferenceStore().getBoolean(
			IPreferenceConstants.REUSE_EDITORS_BOOLEAN);

	private final MementoListener mementoListener;

	private final ContextListener contextListener;

	//private final IPreferenceStore preferenceStore;

	public ContextEditorManager() {
		//preferenceStore = new ScopedPreferenceStore(new InstanceScope(), "org.eclipse.mylyn.resources.ui"); //$NON-NLS-1$
		this.mementoListener = new MementoListener();
		this.contextListener = new ContextListener();
	}

	public void start(IInteractionContextManager contextManager, ContextMementoManager mementoManager) {
		contextManager.addListener(contextListener);
		mementoManager.addMementoListener(mementoListener);
	}
			openEditorsFromMemento(event.getContext());
			break;
		case DEACTIVATED:
			closeEditorsAndSaveMemento(event.getContext());
			break;
		case INTEREST_CHANGED:
			for (IInteractionElement element : event.getElements()) {
				closeEditor(element, false);
			}
			break;
		case ELEMENTS_DELETED:
			for (IInteractionElement element : event.getElements()) {
				closeEditor(element, true);
			}
			break;
		case CLEARED:
			// use the handle since the context is null when it is cleared
			// bug 255588
			clearEditorMemento(event.getContextHandle(), event.isActiveContext());
			break;

	public void stop(IInteractionContextManager contextManager, ContextMementoManager mementoManager) {
		contextManager.removeListener(contextListener);
		mementoManager.removeMementoListener(mementoListener);
	}

	public void restoreState(ContextMemento state) {
		if (!Workbench.getInstance().isStarting()
				&& ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(
						IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS) && !TaskMigrator.isActive()) {

					ContextCore.getContextManager().setContextCapturePaused(true);
				}
				String mementoString = null;
				// TODO change where memento is stored
				IWorkbenchWindow activeWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
				try {
//					mementoString = readEditorMemento(context.getHandleIdentifier());
//					if (mementoString != null && !mementoString.trim().equals("")) { //$NON-NLS-1$
//						IMemento memento = XMLMemento.createReadRoot(new StringReader(mementoString));
					IMemento memento = state.getMemento("editors");
					if (memento != null) {
						IMemento[] children = memento.getChildren(KEY_MONITORED_WINDOW_OPEN_EDITORS);
						if (children.length > 0) {
							// This code supports restore from multiple windows

							"Could not restore all editors, memento: \"" + mementoString + "\"", e)); //$NON-NLS-1$ //$NON-NLS-2$
				}
				activeWindow.setActivePage(activeWindow.getActivePage());
				IInteractionElement activeNode = state.getContext().getActiveNode();
				if (activeNode != null) {
					ContextUi.getUiBridge(activeNode.getContentType()).open(activeNode);
				}

	}

	private WorkbenchPage getWorkbenchPageForMemento(IMemento memento, IWorkbenchWindow activeWindow) {

		String windowToRestoreClassName = memento.getString(ATTRIBUTE_CLASS);
		if (windowToRestoreClassName == null) {
			windowToRestoreClassName = ""; //$NON-NLS-1$

		return null;
	}

//	private String readEditorMemento(String handleIdentifier) {
//		return preferenceStore.getString(PREFS_PREFIX + handleIdentifier);
//	}

	public void saveState(ContextMemento state) {
		if (!PlatformUI.getWorkbench().isClosing()
				&& ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(
						IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS) && !TaskMigrator.isActive()) {
			closeAllButActiveTaskEditor(state.getContextHandle());

//			XMLMemento rootMemento = XMLMemento.createWriteRoot(KEY_CONTEXT_EDITORS);

			IWorkbenchWindow activeWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
			IWorkbenchWindow launchingWindow = MonitorUi.getLaunchingWorkbenchWindow();
			Set<IWorkbenchWindow> monitoredWindows = MonitorUi.getMonitoredWindows();

			IMemento rootMemento = state.createMemento("editors");
			for (IWorkbenchWindow window : monitoredWindows) {
				IMemento memento = rootMemento.createChild(KEY_MONITORED_WINDOW_OPEN_EDITORS);


				memento.putBoolean(ATTRIBUTE_IS_ACTIVE, window == activeWindow);
				((WorkbenchPage) window.getActivePage()).getEditorManager().saveState(memento);
			}
//			// TODO: avoid storing with preferences due to bloat?
//			StringWriter writer = new StringWriter();
//			try {
//				rootMemento.save(writer);
//				writeEditorMemento(context, writer.getBuffer().toString());
//			} catch (IOException e) {
//				StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Could not store editor state", //$NON-NLS-1$
//						e));
//			}

			Workbench.getInstance().getPreferenceStore().setValue(IPreferenceConstants.REUSE_EDITORS_BOOLEAN,
					previousCloseEditorsSetting);

		}
	}

//	public void writeEditorMemento(IInteractionContext context, String memento) {
//		preferenceStore.setValue(PREFS_PREFIX + context.getHandleIdentifier(), memento);
//	}

	public void clearState(String contextHandle, boolean closeEditors) {

		if (closeEditors) {
			closeAllButActiveTaskEditor(contextHandle);
		}

		XMLMemento memento = XMLMemento.createWriteRoot(KEY_CONTEXT_EDITORS);

		// TODO: avoid storing with preferences due to bloat?
		StringWriter writer = new StringWriter();
		try {
			memento.save(writer);
			writeEditorMemento(contextHandle, writer.getBuffer().toString());
		} catch (IOException e) {
			StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Could not store editor state", e)); //$NON-NLS-1$
		}

		Workbench.getInstance().getPreferenceStore().setValue(IPreferenceConstants.REUSE_EDITORS_BOOLEAN,
				previousCloseEditorsSetting);
		if (closeEditors) {

		}
	}

	public void copyEditorMemento(String sourceHandle, String targetHandle) {
		Assert.isNotNull(sourceHandle);
		Assert.isNotNull(targetHandle);
		String memento = readEditorMemento(sourceHandle);
		if (memento != null) {
			writeEditorMemento(targetHandle, memento);
		}
	}

}




import org.eclipse.jface.window.Window;
import org.eclipse.mylyn.context.core.ContextCore;
import org.eclipse.mylyn.context.core.IInteractionContext;
import org.eclipse.mylyn.internal.context.ui.ContextUiPlugin;
import org.eclipse.mylyn.internal.tasks.ui.actions.TaskSelectionDialog;
import org.eclipse.mylyn.internal.tasks.ui.commands.AbstractTaskHandler;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;

					MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
							TITLE_DIALOG, Messages.CopyContextHandler_SOURCE_TASK_DOES_HAVE_A_CONTEXT);
				} else {
					// FIXME 3.4 re-implemnt memenot copying
//					ContextUiPlugin.getEditorManager().copyEditorMemento(sourceTask.getHandleIdentifier(),
//							targetTask.getHandleIdentifier());
					TasksUiInternal.activateTaskThroughCommand(targetTask);
				}
			}

Lines 13-25 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/ui/ContextPerspectiveManagerTest.java (-18 / +56 lines)
13		13
14	import junit.framework.TestCase;	14	import junit.framework.TestCase;
15		15
		16	import org.eclipse.core.runtime.IStatus;
		17	import org.eclipse.mylyn.context.core.ContextCore;
16	import org.eclipse.mylyn.context.tests.support.ContextTestUtil;	18	import org.eclipse.mylyn.context.tests.support.ContextTestUtil;
		19	import org.eclipse.mylyn.internal.context.core.InteractionContext;
		20	import org.eclipse.mylyn.internal.context.ui.ContextMemento;
17	import org.eclipse.mylyn.internal.context.ui.ContextUiPlugin;	21	import org.eclipse.mylyn.internal.context.ui.ContextUiPlugin;
18	import org.eclipse.mylyn.internal.context.ui.IContextUiPreferenceContstants;	22	import org.eclipse.mylyn.internal.context.ui.IContextUiPreferenceContstants;
19	import org.eclipse.mylyn.internal.tasks.core.TaskTask;	23	import org.eclipse.mylyn.internal.tasks.core.TaskTask;
		24	import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
20	import org.eclipse.mylyn.monitor.ui.MonitorUi;	25	import org.eclipse.mylyn.monitor.ui.MonitorUi;
21	import org.eclipse.mylyn.tasks.tests.TaskTestUtil;	26	import org.eclipse.mylyn.tasks.tests.TaskTestUtil;
22	import org.eclipse.mylyn.tasks.ui.TasksUi;	27	import org.eclipse.mylyn.tasks.ui.TasksUi;
		28	import org.eclipse.ui.IMemento;
23	import org.eclipse.ui.PlatformUI;	29	import org.eclipse.ui.PlatformUI;
24		30
25	/**	31	/**
Lines 51-56 Link Here
51	TaskTestUtil.resetTaskListAndRepositories();	57	TaskTestUtil.resetTaskListAndRepositories();
52	}	58	}
53		59
		60	public void testHasPlanningAndResourcePerspective() throws Exception {
		61	PlatformUI.getWorkbench().showPerspective(ID_RESOURCE_PERSPECTIVE, MonitorUi.getLaunchingWorkbenchWindow());
		62	assertEquals(ID_RESOURCE_PERSPECTIVE, getActivePerspective());
		63	PlatformUI.getWorkbench().showPerspective(ID_PLANNING_PERSPECTIVE, MonitorUi.getLaunchingWorkbenchWindow());
		64	assertEquals(ID_PLANNING_PERSPECTIVE, getActivePerspective());
		65	}
		66
		67	public void testHasActiveWorkbenchWindow() throws Exception {
		68	assertNotNull("No active workbench window. Following tests are likely to fail.", PlatformUI.getWorkbench()
		69	.getActiveWorkbenchWindow());
		70	}
		71
54	public void testRestorePerspective() throws Exception {	72	public void testRestorePerspective() throws Exception {
55	PlatformUI.getWorkbench().showPerspective(ID_RESOURCE_PERSPECTIVE, MonitorUi.getLaunchingWorkbenchWindow());	73	PlatformUI.getWorkbench().showPerspective(ID_RESOURCE_PERSPECTIVE, MonitorUi.getLaunchingWorkbenchWindow());
56	assertEquals(ID_RESOURCE_PERSPECTIVE, getActivePerspective());	74	assertEquals(ID_RESOURCE_PERSPECTIVE, getActivePerspective());
Lines 71-94 Link Here
71	assertEquals(ID_PLANNING_PERSPECTIVE, getActivePerspective());	89	assertEquals(ID_PLANNING_PERSPECTIVE, getActivePerspective());
72	}	90	}
73		91
74	// FIXME 3.4 re-enable test	92	public void testRecreateTask() throws Exception {
75	// public void testRecreateTask() throws Exception {	93	PlatformUI.getWorkbench().showPerspective(ID_RESOURCE_PERSPECTIVE, MonitorUi.getLaunchingWorkbenchWindow());
76	// PlatformUI.getWorkbench().showPerspective(ID_RESOURCE_PERSPECTIVE, MonitorUi.getLaunchingWorkbenchWindow());	94	TaskTask task = TaskTestUtil.createMockTask("1");
77	// TaskTask task = TaskTestUtil.createMockTask("1");	95
78	//	96	// check that deleting task switches back to original perspective
79	// // check that deleting task switches back to original perspective	97	TasksUi.getTaskActivityManager().activateTask(task);
80	// TasksUi.getTaskActivityManager().activateTask(task);	98	PlatformUI.getWorkbench().showPerspective(ID_PLANNING_PERSPECTIVE, MonitorUi.getLaunchingWorkbenchWindow());
81	// PlatformUI.getWorkbench().showPerspective(ID_PLANNING_PERSPECTIVE, MonitorUi.getLaunchingWorkbenchWindow());	99	TasksUiPlugin.getTaskActivityManager().deactivateActiveTask();
82	// TasksUiPlugin.getTaskActivityManager().deactivateActiveTask();	100	TasksUiPlugin.getTaskList().deleteTask(task);
83	// TasksUiPlugin.getTaskList().deleteTask(task);	101	assertEquals(ID_RESOURCE_PERSPECTIVE, getActivePerspective());
84	// assertEquals(ID_RESOURCE_PERSPECTIVE, getActivePerspective());	102
85	//	103	task = TaskTestUtil.createMockTask("1");
86	// task = TaskTestUtil.createMockTask("1");	104
87	//	105	// check that activating new task with the same id does not switch the perspective
88	// // check that activating new task with the same id does not switch the perspective	106	TasksUi.getTaskActivityManager().activateTask(task);
89	// TasksUi.getTaskActivityManager().activateTask(task);	107	assertEquals(ID_RESOURCE_PERSPECTIVE, getActivePerspective());
90	// assertEquals(ID_RESOURCE_PERSPECTIVE, getActivePerspective());	108	}
91	// }	109
		110	public void testMigratePreferences() throws Exception {
		111	PlatformUI.getWorkbench().showPerspective(ID_RESOURCE_PERSPECTIVE, MonitorUi.getLaunchingWorkbenchWindow());
		112
		113	TaskTask task = TaskTestUtil.createMockTask("1");
		114	ContextUiPlugin.getDefault().getPreferenceStore().setValue(
		115	ContextUiPlugin.PREFIX_TASK_TO_PERSPECTIVE + task.getHandleIdentifier(), ID_PLANNING_PERSPECTIVE);
		116
		117	IStatus status = ContextUiPlugin.getDefault().migrateContextMementos();
		118	assertEquals(IStatus.OK, status.getSeverity());
		119
		120	InteractionContext context = new InteractionContext(task.getHandleIdentifier(),
		121	ContextCore.getCommonContextScaling());
		122	ContextMemento state = ContextUiPlugin.getDefault().getMementoManager().read(context);
		123	IMemento memento = state.getMemento("perspective");
		124	assertNotNull(memento);
		125	assertEquals(ID_PLANNING_PERSPECTIVE, memento.getString("activeId"));
		126
		127	assertNull(ContextUiPlugin.getDefault().getPreferenceStore().getString(
		128	ContextUiPlugin.PREFIX_TASK_TO_PERSPECTIVE + task.getHandleIdentifier()));
		129	}
92		130
93	private String getActivePerspective() {	131	private String getActivePerspective() {
94	return MonitorUi.getLaunchingWorkbenchWindow().getActivePage().getPerspective().getId();	132	return MonitorUi.getLaunchingWorkbenchWindow().getActivePage().getPerspective().getId();

Return to bug 226618

Lines 11-39 Link Here

(-)src/org/eclipse/mylyn/internal/context/ui/ContextEditorManager.java (-85 / +80 lines)
11		11
12	package org.eclipse.mylyn.internal.context.ui;	12	package org.eclipse.mylyn.internal.context.ui;
13		13
14	import java.io.IOException;
15	import java.io.StringReader;
16	import java.io.StringWriter;
17	import java.util.ArrayList;	14	import java.util.ArrayList;
18	import java.util.Arrays;	15	import java.util.Arrays;
19	import java.util.HashSet;	16	import java.util.HashSet;
20	import java.util.List;	17	import java.util.List;
21	import java.util.Set;	18	import java.util.Set;
22		19
23	import org.eclipse.core.runtime.Assert;
24	import org.eclipse.core.runtime.ISafeRunnable;	20	import org.eclipse.core.runtime.ISafeRunnable;
25	import org.eclipse.core.runtime.IStatus;	21	import org.eclipse.core.runtime.IStatus;
26	import org.eclipse.core.runtime.MultiStatus;	22	import org.eclipse.core.runtime.MultiStatus;
27	import org.eclipse.core.runtime.Status;	23	import org.eclipse.core.runtime.Status;
28	import org.eclipse.core.runtime.preferences.InstanceScope;
29	import org.eclipse.jface.preference.IPreferenceStore;
30	import org.eclipse.jface.util.SafeRunnable;	24	import org.eclipse.jface.util.SafeRunnable;
31	import org.eclipse.mylyn.commons.core.StatusHandler;	25	import org.eclipse.mylyn.commons.core.StatusHandler;
32	import org.eclipse.mylyn.context.core.AbstractContextListener;	26	import org.eclipse.mylyn.context.core.AbstractContextListener;
33	import org.eclipse.mylyn.context.core.AbstractContextStructureBridge;	27	import org.eclipse.mylyn.context.core.AbstractContextStructureBridge;
34	import org.eclipse.mylyn.context.core.ContextChangeEvent;	28	import org.eclipse.mylyn.context.core.ContextChangeEvent;
35	import org.eclipse.mylyn.context.core.ContextCore;	29	import org.eclipse.mylyn.context.core.ContextCore;
36	import org.eclipse.mylyn.context.core.IInteractionContext;	30	import org.eclipse.mylyn.context.core.IInteractionContextManager;
37	import org.eclipse.mylyn.context.core.IInteractionElement;	31	import org.eclipse.mylyn.context.core.IInteractionElement;
38	import org.eclipse.mylyn.context.ui.AbstractContextUiBridge;	32	import org.eclipse.mylyn.context.ui.AbstractContextUiBridge;
39	import org.eclipse.mylyn.context.ui.ContextUi;	33	import org.eclipse.mylyn.context.ui.ContextUi;
Lines 51-74 Link Here
51	import org.eclipse.ui.IWorkbenchWindow;	45	import org.eclipse.ui.IWorkbenchWindow;
52	import org.eclipse.ui.PartInitException;	46	import org.eclipse.ui.PartInitException;
53	import org.eclipse.ui.PlatformUI;	47	import org.eclipse.ui.PlatformUI;
54	import org.eclipse.ui.XMLMemento;
55	import org.eclipse.ui.internal.EditorManager;	48	import org.eclipse.ui.internal.EditorManager;
56	import org.eclipse.ui.internal.IPreferenceConstants;	49	import org.eclipse.ui.internal.IPreferenceConstants;
57	import org.eclipse.ui.internal.IWorkbenchConstants;	50	import org.eclipse.ui.internal.IWorkbenchConstants;
58	import org.eclipse.ui.internal.Workbench;	51	import org.eclipse.ui.internal.Workbench;
59	import org.eclipse.ui.internal.WorkbenchPage;	52	import org.eclipse.ui.internal.WorkbenchPage;
60	import org.eclipse.ui.internal.WorkbenchWindow;	53	import org.eclipse.ui.internal.WorkbenchWindow;
61	import org.eclipse.ui.preferences.ScopedPreferenceStore;
62		54
63	/**	55	/**
64	* @author Mik Kersten	56	* @author Mik Kersten
65	* @author Shawn Minto	57	* @author Shawn Minto
66	*/	58	*/
67	public class ContextEditorManager extends AbstractContextListener {	59	public class ContextEditorManager {
68		60
69	private static final String PREFS_PREFIX = "editors.task."; //$NON-NLS-1$	61	private class MementoListener extends ContextMementoListener {
70		62
71	private static final String KEY_CONTEXT_EDITORS = "ContextOpenEditors"; //$NON-NLS-1$	63	@Override
		64	public void clearState(String contextHandle, boolean isActiveContext) {
		65	ContextEditorManager.this.clearState(contextHandle, isActiveContext);
		66	};
		67
		68	@Override
		69	public void restoreState(ContextMemento memento) {
		70	ContextEditorManager.this.restoreState(memento);
		71	}
		72
		73	@Override
		74	public void saveState(ContextMemento memento) {
		75	ContextEditorManager.this.saveState(memento);
		76	}
		77
		78	}
		79
		80	private class ContextListener extends AbstractContextListener {
		81
		82	@Override
		83	public void contextChanged(ContextChangeEvent event) {
		84	switch (event.getEventKind()) {
		85	case INTEREST_CHANGED:
		86	for (IInteractionElement element : event.getElements()) {
		87	closeEditor(element, false);
		88	}
		89	break;
		90	case ELEMENTS_DELETED:
		91	for (IInteractionElement element : event.getElements()) {
		92	closeEditor(element, true);
		93	}
		94	break;
		95	}
		96	}
		97	}
72		98
73	private static final String KEY_MONITORED_WINDOW_OPEN_EDITORS = "MonitoredWindowOpenEditors"; //$NON-NLS-1$	99	private static final String KEY_MONITORED_WINDOW_OPEN_EDITORS = "MonitoredWindowOpenEditors"; //$NON-NLS-1$
74		100
Lines 83-123 Link Here
83	private boolean previousCloseEditorsSetting = Workbench.getInstance().getPreferenceStore().getBoolean(	109	private boolean previousCloseEditorsSetting = Workbench.getInstance().getPreferenceStore().getBoolean(
84	IPreferenceConstants.REUSE_EDITORS_BOOLEAN);	110	IPreferenceConstants.REUSE_EDITORS_BOOLEAN);
85		111
86	private final IPreferenceStore preferenceStore;	112	private final MementoListener mementoListener;
		113
		114	private final ContextListener contextListener;
		115
		116	//private final IPreferenceStore preferenceStore;
87		117
88	public ContextEditorManager() {	118	public ContextEditorManager() {
89	preferenceStore = new ScopedPreferenceStore(new InstanceScope(), "org.eclipse.mylyn.resources.ui"); //$NON-NLS-1$	119	//preferenceStore = new ScopedPreferenceStore(new InstanceScope(), "org.eclipse.mylyn.resources.ui"); //$NON-NLS-1$
		120	this.mementoListener = new MementoListener();
		121	this.contextListener = new ContextListener();
90	}	122	}
91		123
92	@Override	124	public void start(IInteractionContextManager contextManager, ContextMementoManager mementoManager) {
93	public void contextChanged(ContextChangeEvent event) {	125	contextManager.addListener(contextListener);
94	switch (event.getEventKind()) {	126	mementoManager.addMementoListener(mementoListener);
95	case ACTIVATED:	127	}
96	openEditorsFromMemento(event.getContext());
97	break;
98	case DEACTIVATED:
99	closeEditorsAndSaveMemento(event.getContext());
100	break;
101	case INTEREST_CHANGED:
102	for (IInteractionElement element : event.getElements()) {
103	closeEditor(element, false);
104	}
105	break;
106	case ELEMENTS_DELETED:
107	for (IInteractionElement element : event.getElements()) {
108	closeEditor(element, true);
109	}
110	break;
111	case CLEARED:
112	// use the handle since the context is null when it is cleared
113	// bug 255588
114	clearEditorMemento(event.getContextHandle(), event.isActiveContext());
115	break;
116		128
117	}	129	public void stop(IInteractionContextManager contextManager, ContextMementoManager mementoManager) {
		130	contextManager.removeListener(contextListener);
		131	mementoManager.removeMementoListener(mementoListener);
118	}	132	}
119		133
120	public void openEditorsFromMemento(IInteractionContext context) {	134	public void restoreState(ContextMemento state) {
121	if (!Workbench.getInstance().isStarting()	135	if (!Workbench.getInstance().isStarting()
122	&& ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(	136	&& ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(
123	IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS) && !TaskMigrator.isActive()) {	137	IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS) && !TaskMigrator.isActive()) {
Lines 131-142 Link Here
131	ContextCore.getContextManager().setContextCapturePaused(true);	145	ContextCore.getContextManager().setContextCapturePaused(true);
132	}	146	}
133	String mementoString = null;	147	String mementoString = null;
134	// TODO change where memento is stored
135	IWorkbenchWindow activeWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();	148	IWorkbenchWindow activeWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
136	try {	149	try {
137	mementoString = readEditorMemento(context.getHandleIdentifier());	150	// mementoString = readEditorMemento(context.getHandleIdentifier());
138	if (mementoString != null && !mementoString.trim().equals("")) { //$NON-NLS-1$	151	// if (mementoString != null && !mementoString.trim().equals("")) { //$NON-NLS-1$
139	IMemento memento = XMLMemento.createReadRoot(new StringReader(mementoString));	152	// IMemento memento = XMLMemento.createReadRoot(new StringReader(mementoString));
		153	IMemento memento = state.getMemento("editors");
		154	if (memento != null) {
140	IMemento[] children = memento.getChildren(KEY_MONITORED_WINDOW_OPEN_EDITORS);	155	IMemento[] children = memento.getChildren(KEY_MONITORED_WINDOW_OPEN_EDITORS);
141	if (children.length > 0) {	156	if (children.length > 0) {
142	// This code supports restore from multiple windows	157	// This code supports restore from multiple windows
Lines 159-165 Link Here
159	"Could not restore all editors, memento: \"" + mementoString + "\"", e)); //$NON-NLS-1$ //$NON-NLS-2$	174	"Could not restore all editors, memento: \"" + mementoString + "\"", e)); //$NON-NLS-1$ //$NON-NLS-2$
160	}	175	}
161	activeWindow.setActivePage(activeWindow.getActivePage());	176	activeWindow.setActivePage(activeWindow.getActivePage());
162	IInteractionElement activeNode = context.getActiveNode();	177	IInteractionElement activeNode = state.getContext().getActiveNode();
163	if (activeNode != null) {	178	if (activeNode != null) {
164	ContextUi.getUiBridge(activeNode.getContentType()).open(activeNode);	179	ContextUi.getUiBridge(activeNode.getContentType()).open(activeNode);
165	}	180	}
Lines 173-179 Link Here
173	}	188	}
174		189
175	private WorkbenchPage getWorkbenchPageForMemento(IMemento memento, IWorkbenchWindow activeWindow) {	190	private WorkbenchPage getWorkbenchPageForMemento(IMemento memento, IWorkbenchWindow activeWindow) {
176
177	String windowToRestoreClassName = memento.getString(ATTRIBUTE_CLASS);	191	String windowToRestoreClassName = memento.getString(ATTRIBUTE_CLASS);
178	if (windowToRestoreClassName == null) {	192	if (windowToRestoreClassName == null) {
179	windowToRestoreClassName = ""; //$NON-NLS-1$	193	windowToRestoreClassName = ""; //$NON-NLS-1$
Lines 226-247 Link Here
226	return null;	240	return null;
227	}	241	}
228		242
229	private String readEditorMemento(String handleIdentifier) {	243	// private String readEditorMemento(String handleIdentifier) {
230	return preferenceStore.getString(PREFS_PREFIX + handleIdentifier);	244	// return preferenceStore.getString(PREFS_PREFIX + handleIdentifier);
231	}	245	// }
232		246
233	public void closeEditorsAndSaveMemento(IInteractionContext context) {	247	public void saveState(ContextMemento state) {
234	if (!PlatformUI.getWorkbench().isClosing()	248	if (!PlatformUI.getWorkbench().isClosing()
235	&& ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(	249	&& ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(
236	IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS) && !TaskMigrator.isActive()) {	250	IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS) && !TaskMigrator.isActive()) {
237	closeAllButActiveTaskEditor(context.getHandleIdentifier());	251	closeAllButActiveTaskEditor(state.getContextHandle());
238		252
239	XMLMemento rootMemento = XMLMemento.createWriteRoot(KEY_CONTEXT_EDITORS);	253	// XMLMemento rootMemento = XMLMemento.createWriteRoot(KEY_CONTEXT_EDITORS);
240		254
241	IWorkbenchWindow activeWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();	255	IWorkbenchWindow activeWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
242	IWorkbenchWindow launchingWindow = MonitorUi.getLaunchingWorkbenchWindow();	256	IWorkbenchWindow launchingWindow = MonitorUi.getLaunchingWorkbenchWindow();
243	Set<IWorkbenchWindow> monitoredWindows = MonitorUi.getMonitoredWindows();	257	Set<IWorkbenchWindow> monitoredWindows = MonitorUi.getMonitoredWindows();
244		258
		259	IMemento rootMemento = state.createMemento("editors");
245	for (IWorkbenchWindow window : monitoredWindows) {	260	for (IWorkbenchWindow window : monitoredWindows) {
246	IMemento memento = rootMemento.createChild(KEY_MONITORED_WINDOW_OPEN_EDITORS);	261	IMemento memento = rootMemento.createChild(KEY_MONITORED_WINDOW_OPEN_EDITORS);
247		262
Lines 255-269 Link Here
255	memento.putBoolean(ATTRIBUTE_IS_ACTIVE, window == activeWindow);	270	memento.putBoolean(ATTRIBUTE_IS_ACTIVE, window == activeWindow);
256	((WorkbenchPage) window.getActivePage()).getEditorManager().saveState(memento);	271	((WorkbenchPage) window.getActivePage()).getEditorManager().saveState(memento);
257	}	272	}
258	// TODO: avoid storing with preferences due to bloat?	273	// // TODO: avoid storing with preferences due to bloat?
259	StringWriter writer = new StringWriter();	274	// StringWriter writer = new StringWriter();
260	try {	275	// try {
261	rootMemento.save(writer);	276	// rootMemento.save(writer);
262	writeEditorMemento(context.getHandleIdentifier(), writer.getBuffer().toString());	277	// writeEditorMemento(context, writer.getBuffer().toString());
263	} catch (IOException e) {	278	// } catch (IOException e) {
264	StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Could not store editor state", //$NON-NLS-1$	279	// StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Could not store editor state", //$NON-NLS-1$
265	e));	280	// e));
266	}	281	// }
267		282
268	Workbench.getInstance().getPreferenceStore().setValue(IPreferenceConstants.REUSE_EDITORS_BOOLEAN,	283	Workbench.getInstance().getPreferenceStore().setValue(IPreferenceConstants.REUSE_EDITORS_BOOLEAN,
269	previousCloseEditorsSetting);	284	previousCloseEditorsSetting);
Lines 271-297 Link Here
271	}	286	}
272	}	287	}
273		288
274	public void writeEditorMemento(String contextHandle, String memento) {	289	// public void writeEditorMemento(IInteractionContext context, String memento) {
275	preferenceStore.setValue(PREFS_PREFIX + contextHandle, memento);	290	// preferenceStore.setValue(PREFS_PREFIX + context.getHandleIdentifier(), memento);
276	}	291	// }
277		292
278	public void clearEditorMemento(String contextHandle, boolean closeEditors) {	293	public void clearState(String contextHandle, boolean closeEditors) {
279		294
280	if (closeEditors) {	295	if (closeEditors) {
281	closeAllButActiveTaskEditor(contextHandle);	296	closeAllButActiveTaskEditor(contextHandle);
282	}	297	}
283		298
284	XMLMemento memento = XMLMemento.createWriteRoot(KEY_CONTEXT_EDITORS);
285
286	// TODO: avoid storing with preferences due to bloat?
287	StringWriter writer = new StringWriter();
288	try {
289	memento.save(writer);
290	writeEditorMemento(contextHandle, writer.getBuffer().toString());
291	} catch (IOException e) {
292	StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Could not store editor state", e)); //$NON-NLS-1$
293	}
294
295	Workbench.getInstance().getPreferenceStore().setValue(IPreferenceConstants.REUSE_EDITORS_BOOLEAN,	299	Workbench.getInstance().getPreferenceStore().setValue(IPreferenceConstants.REUSE_EDITORS_BOOLEAN,
296	previousCloseEditorsSetting);	300	previousCloseEditorsSetting);
297	if (closeEditors) {	301	if (closeEditors) {
Lines 441-453 Link Here
441	}	445	}
442	}	446	}
443		447
444	public void copyEditorMemento(String sourceHandle, String targetHandle) {
445	Assert.isNotNull(sourceHandle);
446	Assert.isNotNull(targetHandle);
447	String memento = readEditorMemento(sourceHandle);
448	if (memento != null) {
449	writeEditorMemento(targetHandle, memento);
450	}
451	}
452
453	}	448	}

Lines 17-23 Link Here

(-)src/org/eclipse/mylyn/internal/context/ui/commands/CopyContextHandler.java (-3 / +3 lines)
17	import org.eclipse.jface.window.Window;	17	import org.eclipse.jface.window.Window;
18	import org.eclipse.mylyn.context.core.ContextCore;	18	import org.eclipse.mylyn.context.core.ContextCore;
19	import org.eclipse.mylyn.context.core.IInteractionContext;	19	import org.eclipse.mylyn.context.core.IInteractionContext;
20	import org.eclipse.mylyn.internal.context.ui.ContextUiPlugin;
21	import org.eclipse.mylyn.internal.tasks.ui.actions.TaskSelectionDialog;	20	import org.eclipse.mylyn.internal.tasks.ui.actions.TaskSelectionDialog;
22	import org.eclipse.mylyn.internal.tasks.ui.commands.AbstractTaskHandler;	21	import org.eclipse.mylyn.internal.tasks.ui.commands.AbstractTaskHandler;
23	import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;	22	import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
Lines 66-73 Link Here
66	MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),	65	MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
67	TITLE_DIALOG, Messages.CopyContextHandler_SOURCE_TASK_DOES_HAVE_A_CONTEXT);	66	TITLE_DIALOG, Messages.CopyContextHandler_SOURCE_TASK_DOES_HAVE_A_CONTEXT);
68	} else {	67	} else {
69	ContextUiPlugin.getEditorManager().copyEditorMemento(sourceTask.getHandleIdentifier(),	68	// FIXME 3.4 re-implemnt memenot copying
70	targetTask.getHandleIdentifier());	69	// ContextUiPlugin.getEditorManager().copyEditorMemento(sourceTask.getHandleIdentifier(),
		70	// targetTask.getHandleIdentifier());
71	TasksUiInternal.activateTaskThroughCommand(targetTask);	71	TasksUiInternal.activateTaskThroughCommand(targetTask);
72	}	72	}
73	}	73	}