Attachment #123142 for bug #226618

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

Lines 11-16 Link Here

(-)src/org/eclipse/mylyn/internal/context/ui/ContextUiPlugin.java (-2 / +73 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.File;
		15	import java.io.StringReader;
14	import java.util.ArrayList;	16	import java.util.ArrayList;
15	import java.util.Collections;	17	import java.util.Collections;
16	import java.util.HashMap;	18	import java.util.HashMap;
Lines 27-35 Link Here
27	import org.eclipse.core.runtime.IExtension;	29	import org.eclipse.core.runtime.IExtension;
28	import org.eclipse.core.runtime.IExtensionPoint;	30	import org.eclipse.core.runtime.IExtensionPoint;
29	import org.eclipse.core.runtime.IExtensionRegistry;	31	import org.eclipse.core.runtime.IExtensionRegistry;
		32	import org.eclipse.core.runtime.IPath;
30	import org.eclipse.core.runtime.IStatus;	33	import org.eclipse.core.runtime.IStatus;
31	import org.eclipse.core.runtime.Platform;	34	import org.eclipse.core.runtime.Platform;
32	import org.eclipse.core.runtime.Status;	35	import org.eclipse.core.runtime.Status;
		36	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
		37	import org.eclipse.core.runtime.preferences.InstanceScope;
33	import org.eclipse.jface.dialogs.MessageDialog;	38	import org.eclipse.jface.dialogs.MessageDialog;
34	import org.eclipse.jface.preference.IPreferenceStore;	39	import org.eclipse.jface.preference.IPreferenceStore;
35	import org.eclipse.jface.resource.ImageDescriptor;	40	import org.eclipse.jface.resource.ImageDescriptor;
Lines 47-52 Link Here
47	import org.eclipse.mylyn.context.core.IInteractionRelation;	52	import org.eclipse.mylyn.context.core.IInteractionRelation;
48	import org.eclipse.mylyn.context.ui.AbstractContextUiBridge;	53	import org.eclipse.mylyn.context.ui.AbstractContextUiBridge;
49	import org.eclipse.mylyn.context.ui.IContextUiStartup;	54	import org.eclipse.mylyn.context.ui.IContextUiStartup;
		55	import org.eclipse.mylyn.internal.context.core.InteractionContext;
50	import org.eclipse.mylyn.internal.monitor.ui.MonitorUiPlugin;	56	import org.eclipse.mylyn.internal.monitor.ui.MonitorUiPlugin;
51	import org.eclipse.mylyn.monitor.ui.MonitorUi;	57	import org.eclipse.mylyn.monitor.ui.MonitorUi;
52	import org.eclipse.mylyn.tasks.core.ITask;	58	import org.eclipse.mylyn.tasks.core.ITask;
Lines 57-70 Link Here
57	import org.eclipse.swt.graphics.Image;	63	import org.eclipse.swt.graphics.Image;
58	import org.eclipse.ui.IEditorInput;	64	import org.eclipse.ui.IEditorInput;
59	import org.eclipse.ui.IEditorPart;	65	import org.eclipse.ui.IEditorPart;
		66	import org.eclipse.ui.IMemento;
60	import org.eclipse.ui.IViewPart;	67	import org.eclipse.ui.IViewPart;
61	import org.eclipse.ui.IViewReference;	68	import org.eclipse.ui.IViewReference;
62	import org.eclipse.ui.IWorkbench;	69	import org.eclipse.ui.IWorkbench;
63	import org.eclipse.ui.IWorkbenchWindow;	70	import org.eclipse.ui.IWorkbenchWindow;
64	import org.eclipse.ui.PlatformUI;	71	import org.eclipse.ui.PlatformUI;
		72	import org.eclipse.ui.WorkbenchException;
		73	import org.eclipse.ui.XMLMemento;
65	import org.eclipse.ui.internal.WorkbenchPlugin;	74	import org.eclipse.ui.internal.WorkbenchPlugin;
66	import org.eclipse.ui.plugin.AbstractUIPlugin;	75	import org.eclipse.ui.plugin.AbstractUIPlugin;
		76	import org.eclipse.ui.preferences.ScopedPreferenceStore;
67	import org.osgi.framework.BundleContext;	77	import org.osgi.framework.BundleContext;
		78	import org.osgi.service.prefs.BackingStoreException;
68		79
69	/**	80	/**
70	* Main entry point for the Context UI.	81	* Main entry point for the Context UI.
Lines 75-80 Link Here
75	*/	86	*/
76	public class ContextUiPlugin extends AbstractUIPlugin {	87	public class ContextUiPlugin extends AbstractUIPlugin {
77		88
		89	private static final String EDITOR_MEMNTO_PREFS_PREFIX = "editors.task."; //$NON-NLS-1$
		90
78	public static final String ID_PLUGIN = "org.eclipse.mylyn.context.ui"; //$NON-NLS-1$	91	public static final String ID_PLUGIN = "org.eclipse.mylyn.context.ui"; //$NON-NLS-1$
79		92
80	private class ContextActivationListener extends AbstractContextListener {	93	private class ContextActivationListener extends AbstractContextListener {
Lines 208-213 Link Here
208		221
209	private ContextEditorManager editorManager;	222	private ContextEditorManager editorManager;
210		223
		224	private ContextMementoManager mementoManager;
		225
211	public ContextUiPlugin() {	226	public ContextUiPlugin() {
212	INSTANCE = this;	227	INSTANCE = this;
213	}	228	}
Lines 256-263 Link Here
256	MonitorUi.addWindowPerspectiveListener(perspectiveManager);	271	MonitorUi.addWindowPerspectiveListener(perspectiveManager);
257	TasksUi.getTaskActivityManager().addActivationListener(TASK_ACTIVATION_LISTENER);	272	TasksUi.getTaskActivityManager().addActivationListener(TASK_ACTIVATION_LISTENER);
258		273
		274	mementoManager = new ContextMementoManager(ContextCore.getContextManager(), getContextMementoPath());
		275	mementoManager.start();
		276
259	editorManager = new ContextEditorManager();	277	editorManager = new ContextEditorManager();
260	ContextCore.getContextManager().addListener(editorManager);	278	editorManager.start(ContextCore.getContextManager(), mementoManager);
		279
		280	migrateContextMementos(mementoManager);
261	} catch (Exception e) {	281	} catch (Exception e) {
262	StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Context UI initialization failed", //$NON-NLS-1$	282	StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Context UI initialization failed", //$NON-NLS-1$
263	e));	283	e));
Lines 289-297 Link Here
289	}	309	}
290	}	310	}
291		311
		312	private void migrateContextMementos(ContextMementoManager mementoManager) {
		313	ScopedPreferenceStore preferenceStore = new ScopedPreferenceStore(new InstanceScope(),
		314	"org.eclipse.mylyn.resources.ui"); //$NON-NLS-1$
		315
		316	IEclipsePreferences[] nodes = preferenceStore.getPreferenceNodes(false);
		317	if (nodes.length > 0) {
		318	String[] keys;
		319	try {
		320	keys = nodes[0].keys();
		321	for (String key : keys) {
		322	if (key.startsWith(EDITOR_MEMNTO_PREFS_PREFIX)) {
		323	String contextHandle = key.substring(EDITOR_MEMNTO_PREFS_PREFIX.length());
		324	String mementoString = preferenceStore.getString(key);
		325	if (mementoString != null && !mementoString.trim().equals("")) { //$NON-NLS-1$
		326	try {
		327	IMemento oldMemento = XMLMemento.createReadRoot(new StringReader(mementoString));
		328	InteractionContext context = new InteractionContext(contextHandle,
		329	ContextCore.getCommonContextScaling());
		330	ContextMemento state = mementoManager.createMemento(context);
		331	IMemento newMemnto = state.createMemento("editors");
		332	newMemnto.putMemento(oldMemento);
		333	mementoManager.write(state);
		334	} catch (WorkbenchException e) {
		335	StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN,
		336	"Migration of editor memento failed", e)); //$NON-NLS-1$
		337	}
		338	}
		339	}
		340	}
		341	} catch (BackingStoreException e) {
		342	StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN,
		343	"Migration of editor mementos failed", e)); //$NON-NLS-1$
		344	}
		345	}
		346	}
		347
292	private void lazyStop() {	348	private void lazyStop() {
293	if (editorManager != null) {	349	if (editorManager != null) {
294	ContextCore.getContextManager().removeListener(editorManager);	350	editorManager.stop(ContextCore.getContextManager(), mementoManager);
		351	}
		352
		353	if (mementoManager != null) {
		354	mementoManager.stop();
295	}	355	}
296		356
297	ContextCore.getContextManager().removeListener(viewerManager);	357	ContextCore.getContextManager().removeListener(viewerManager);
Lines 645-648 Link Here
645	public static ContextPerspectiveManager getPerspectiveManager() {	705	public static ContextPerspectiveManager getPerspectiveManager() {
646	return INSTANCE.perspectiveManager;	706	return INSTANCE.perspectiveManager;
647	}	707	}
		708
		709	private File getContextMementoPath() {
		710	IPath stateLocation = Platform.getStateLocation(getBundle());
		711	IPath cacheFile = stateLocation.append("workbench"); //$NON-NLS-1$
		712	return cacheFile.toFile();
		713	}
		714
		715	public ContextMementoManager getMementoManager() {
		716	return mementoManager;
		717	}
		718
648	}	719	}





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 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.mylyn.commons.core.StatusHandler;
import org.eclipse.mylyn.context.core.AbstractContextListener;
import org.eclipse.mylyn.context.core.AbstractContextStructureBridge;
import org.eclipse.mylyn.context.core.ContextCore;
import org.eclipse.mylyn.context.core.IInteractionContext;
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.WorkbenchMessages;
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(ContextMemento memento) {
			ContextEditorManager.this.clearState(memento);
		}

		@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 interestChanged(List<IInteractionElement> elements) {
			for (IInteractionElement element : elements) {
				closeEditor(element, false);
			}
		}

		@Override
		public void elementsDeleted(List<IInteractionElement> elements) {
			for (IInteractionElement element : elements) {
				closeEditor(element, true);
			}
		}

	}

	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);
	}

	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)) {

				// TODO change where memento is stored
				IWorkbenchWindow activeWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
				try {
					//mementoString = readEditorMemento(context);
//					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(IInteractionContext context) {
//		return preferenceStore.getString(PREFS_PREFIX + context.getHandleIdentifier());
//	}

	public void saveState(ContextMemento state) {
	public void contextDeactivated(IInteractionContext context) {
		if (!PlatformUI.getWorkbench().isClosing()
				&& ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(
						IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS)) {
			closeAllButActiveTaskEditor(state.getContext().getHandleIdentifier());

			//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.putString(ATTRIBUTE_IS_ACTIVE, (window == activeWindow) ? "true" : "false"); //$NON-NLS-1$ //$NON-NLS-2$
				((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(ContextMemento memento) {
		IInteractionContext context = memento.getContext();
		if (context == null) {
			return;
		}
		closeAllButActiveTaskEditor(context.getHandleIdentifier());
		XMLMemento memento = XMLMemento.createWriteRoot(KEY_CONTEXT_EDITORS);

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

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

		EditorManager editorManager = page.getEditorManager();
		final ArrayList visibleEditors = new ArrayList(5);
		final IEditorReference activeEditor[] = new IEditorReference[1];
		final MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK, "", null); //$NON-NLS-1$
				"", null); //$NON-NLS-1$

		try {
			IMemento[] editorMementos = memento.getChildren(IWorkbenchConstants.TAG_EDITOR);

				}
			}
		} catch (Exception e) {
			StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Could not restore editors", e));
		}
	}


				}
			}
		} catch (Throwable t) {
			StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Could not auto close editor", t));
		}
	}


				}
			}
		} catch (Throwable t) {
			StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Could not auto close editor", t));
		}
	}


		return true;
	}

	@Override
	public void interestChanged(List<IInteractionElement> elements) {
		for (IInteractionElement element : elements) {
			closeEditor(element, false);
		}
	}

	@Override
	public void elementsDeleted(List<IInteractionElement> elements) {
		for (IInteractionElement element : elements) {
			closeEditor(element, true);
		}
	}

	private void closeEditor(IInteractionElement element, boolean force) {
		if (ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(
				IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS)) {




/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies 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
 *
 * Contributors:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

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

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
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.IInteractionContext;
import org.eclipse.mylyn.context.core.IInteractionContextManager;
import org.eclipse.mylyn.internal.provisional.tasks.core.TasksUtil;
import org.eclipse.osgi.util.NLS;
import org.eclipse.ui.WorkbenchException;
import org.eclipse.ui.XMLMemento;

/**
 * @author Steffen Pingel
 */
public class ContextMementoManager {

	private class ContextListener extends AbstractContextListener {

		@Override
		public void contextActivated(IInteractionContext context) {
			restoreState(context);
		}

		@Override
		public void contextDeactivated(IInteractionContext context) {
			saveState(context);
		}

		@Override
		public void contextCleared(IInteractionContext context) {
			clearState(context);
		}

	}

	private class FlushJob extends Job {

		public FlushJob() {
			super("Flush context mementos"); //$NON-NLS-1$
		}

		@Override
		protected IStatus run(IProgressMonitor monitor) {
			ContextMementoManager.this.flushPending();
			return Status.OK_STATUS;
		}

	}

	private static final String TAG_CONTEXT_STATE = "ContextState"; //$NON-NLS-1$

	private static final long FLUSH_DELAY = 500;

	private static final String CHARSET = "UTF-8"; //$NON-NLS-1$

	private final Map<String, ContextMemento> pending;

	private final File location;

	private FlushJob flushJob;

	private boolean scheduled;

	private final IInteractionContextManager contextManager;

	private final ContextListener contextListener;

	private final List<ContextMementoListener> listeners;

	public ContextMementoManager(IInteractionContextManager contextManager, File location) {
		Assert.isNotNull(contextManager);
		Assert.isNotNull(location);
		this.contextManager = contextManager;
		this.location = location;
		this.contextListener = new ContextListener();
		this.pending = new HashMap<String, ContextMemento>();
		this.listeners = new CopyOnWriteArrayList<ContextMementoListener>();
	}

	public void addMementoListener(ContextMementoListener listener) {
		if (listeners.contains(listener)) {
			throw new IllegalStateException("listener already added"); //$NON-NLS-1$
		}
		listeners.add(listener);
	}

	public void removeMementoListener(ContextMementoListener listener) {
		listeners.remove(listener);
	}

	public void clearState(IInteractionContext context) {

	}

	public void saveState(IInteractionContext context) {
		final ContextMemento memento = createMemento(context);
		for (final ContextMementoListener listener : listeners) {
			SafeRunner.run(new SafeRunnable() {
				public void run() throws Exception {
					listener.saveState(memento);
				}

				@Override
				public void handleException(Throwable e) {
					StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN,
							"Unexpected error processing context event", e)); //$NON-NLS-1$
					removeMementoListener(listener);
				}
			});
		}
		if (memento.isChanged()) {
			writeLater(memento);
		}
	}

	ContextMemento createMemento(IInteractionContext context) {
		return new ContextMemento(context, XMLMemento.createWriteRoot(TAG_CONTEXT_STATE));
	}

	public void restoreState(IInteractionContext context) {
		final ContextMemento memento = read(context);
		for (final ContextMementoListener listener : listeners) {
			SafeRunner.run(new SafeRunnable() {
				public void run() throws Exception {
					listener.restoreState(memento);
				}

				@Override
				public void handleException(Throwable e) {
					StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN,
							"Unexpected error processing context event", e)); //$NON-NLS-1$
					removeMementoListener(listener);
				}
			});
		}
	}

	public synchronized void start() {
		contextManager.addListener(contextListener);
	}

	public synchronized void stop() {
		contextManager.removeListener(contextListener);
	}

	public synchronized void flushPending() {
		MultiStatus status = new MultiStatus(ContextUiPlugin.ID_PLUGIN, 0,
				"Failed to save context workbench state", null); //$NON-NLS-1$
		for (ContextMemento memento : pending.values()) {
			if (memento.isChanged()) {
				IStatus result = write(memento);
				status.add(result);
			}
		}
		pending.clear();
		if (!status.isOK()) {
			StatusHandler.log(status);
		}
	}

	private ContextMemento read(IInteractionContext context) {
		File file = getFile(context);
		if (file.exists()) {
			try {
				BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file), CHARSET));
				XMLMemento memento = XMLMemento.createReadRoot(reader);
				return new ContextMemento(context, memento);
			} catch (IOException e) {
				StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, NLS.bind(
						"Failed to read context memento from \"{0}\"", file.getAbsolutePath()), e)); //$NON-NLS-1$
			} catch (WorkbenchException e) {
				StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, NLS.bind(
						"Failed to read context memento from \"{0}\"", file.getAbsolutePath()), e)); //$NON-NLS-1$
			}
		}
		return createMemento(context);
	}

	IStatus write(ContextMemento memento) {
		File file = getFile(memento.getContext());
		if (!file.getParentFile().exists()) {
			file.getParentFile().mkdirs();
		}
		try {
			BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), CHARSET));
			try {
				(memento.getMemento()).save(writer);
			} finally {
				writer.close();
			}
		} catch (IOException e) {
			return new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, NLS.bind(
					"Failed to write context memento to \"{0}\"", file.getAbsolutePath()), e); //$NON-NLS-1$
		}
		return Status.OK_STATUS;
	}

	private File getFile(IInteractionContext context) {
		return new File(location, TasksUtil.encode(context.getHandleIdentifier()));
	}

	public synchronized void writeLater(ContextMemento memento) {
		pending.put(memento.getContext().getHandleIdentifier(), memento);
		schedule();
	}

	private synchronized void schedule() {
		if (!scheduled) {
			if (flushJob == null) {
				flushJob = new FlushJob();
			}
			flushJob.schedule(FLUSH_DELAY);
		}
	}

}




/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies 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
 *
 * Contributors:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

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

import org.eclipse.core.runtime.Assert;
import org.eclipse.mylyn.context.core.IInteractionContext;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.XMLMemento;

/**
 * Stores workspace specific settings for a context.
 * 
 * @author Steffen Pingel
 */
public class ContextMemento {

	private boolean changed;

	private final IInteractionContext context;

	private final XMLMemento memento;

	public ContextMemento(IInteractionContext context, XMLMemento memento) {
		Assert.isNotNull(context);
		Assert.isNotNull(memento);
		this.context = context;
		this.memento = memento;
	}

	@Override
	public boolean equals(Object obj) {
		if (!(obj instanceof ContextMemento)) {
			return false;
		}
		return context.equals(((ContextMemento) obj).context);
	}

	public IInteractionContext getContext() {
		return context;
	}

	XMLMemento getMemento() {
		return memento;
	}

	public IMemento getMemento(String type) {
		return memento.getChild(type);
	}

	public IMemento createMemento(String type) {
		changed = true;
		return memento.createChild(type);
	}

	@Override
	public int hashCode() {
		return context.hashCode();
	}

	public boolean isChanged() {
		return changed;
	}

	public void removeMemento(String type) {
		memento.createChild(type);
	}

}




/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies 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
 *
 * Contributors:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

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

/**
 * @author Steffen Pingel
 */
public abstract class ContextMementoListener {

	public abstract void clearState(ContextMemento memento);

	public abstract void restoreState(ContextMemento memento);

	public abstract void saveState(ContextMemento memento);

}

Return to bug 226618

Added Link Here

(-)src/org/eclipse/mylyn/internal/context/ui/ContextMementoManager.java (+248 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004, 2008 Tasktop Technologies 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	* Contributors:
9	* Tasktop Technologies - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylyn.internal.context.ui;
13
14	import java.io.BufferedReader;
15	import java.io.BufferedWriter;
16	import java.io.File;
17	import java.io.FileInputStream;
18	import java.io.FileOutputStream;
19	import java.io.IOException;
20	import java.io.InputStreamReader;
21	import java.io.OutputStreamWriter;
22	import java.util.HashMap;
23	import java.util.List;
24	import java.util.Map;
25	import java.util.concurrent.CopyOnWriteArrayList;
26
27	import org.eclipse.core.runtime.Assert;
28	import org.eclipse.core.runtime.IProgressMonitor;
29	import org.eclipse.core.runtime.IStatus;
30	import org.eclipse.core.runtime.MultiStatus;
31	import org.eclipse.core.runtime.SafeRunner;
32	import org.eclipse.core.runtime.Status;
33	import org.eclipse.core.runtime.jobs.Job;
34	import org.eclipse.jface.util.SafeRunnable;
35	import org.eclipse.mylyn.commons.core.StatusHandler;
36	import org.eclipse.mylyn.context.core.AbstractContextListener;
37	import org.eclipse.mylyn.context.core.IInteractionContext;
38	import org.eclipse.mylyn.context.core.IInteractionContextManager;
39	import org.eclipse.mylyn.internal.provisional.tasks.core.TasksUtil;
40	import org.eclipse.osgi.util.NLS;
41	import org.eclipse.ui.WorkbenchException;
42	import org.eclipse.ui.XMLMemento;
43
44	/**
45	* @author Steffen Pingel
46	*/
47	public class ContextMementoManager {
48
49	private class ContextListener extends AbstractContextListener {
50
51	@Override
52	public void contextActivated(IInteractionContext context) {
53	restoreState(context);
54	}
55
56	@Override
57	public void contextDeactivated(IInteractionContext context) {
58	saveState(context);
59	}
60
61	@Override
62	public void contextCleared(IInteractionContext context) {
63	clearState(context);
64	}
65
66	}
67
68	private class FlushJob extends Job {
69
70	public FlushJob() {
71	super("Flush context mementos"); //$NON-NLS-1$
72	}
73
74	@Override
75	protected IStatus run(IProgressMonitor monitor) {
76	ContextMementoManager.this.flushPending();
77	return Status.OK_STATUS;
78	}
79
80	}
81
82	private static final String TAG_CONTEXT_STATE = "ContextState"; //$NON-NLS-1$
83
84	private static final long FLUSH_DELAY = 500;
85
86	private static final String CHARSET = "UTF-8"; //$NON-NLS-1$
87
88	private final Map<String, ContextMemento> pending;
89
90	private final File location;
91
92	private FlushJob flushJob;
93
94	private boolean scheduled;
95
96	private final IInteractionContextManager contextManager;
97
98	private final ContextListener contextListener;
99
100	private final List<ContextMementoListener> listeners;
101
102	public ContextMementoManager(IInteractionContextManager contextManager, File location) {
103	Assert.isNotNull(contextManager);
104	Assert.isNotNull(location);
105	this.contextManager = contextManager;
106	this.location = location;
107	this.contextListener = new ContextListener();
108	this.pending = new HashMap<String, ContextMemento>();
109	this.listeners = new CopyOnWriteArrayList<ContextMementoListener>();
110	}
111
112	public void addMementoListener(ContextMementoListener listener) {
113	if (listeners.contains(listener)) {
114	throw new IllegalStateException("listener already added"); //$NON-NLS-1$
115	}
116	listeners.add(listener);
117	}
118
119	public void removeMementoListener(ContextMementoListener listener) {
120	listeners.remove(listener);
121	}
122
123	public void clearState(IInteractionContext context) {
124
125	}
126
127	public void saveState(IInteractionContext context) {
128	final ContextMemento memento = createMemento(context);
129	for (final ContextMementoListener listener : listeners) {
130	SafeRunner.run(new SafeRunnable() {
131	public void run() throws Exception {
132	listener.saveState(memento);
133	}
134
135	@Override
136	public void handleException(Throwable e) {
137	StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN,
138	"Unexpected error processing context event", e)); //$NON-NLS-1$
139	removeMementoListener(listener);
140	}
141	});
142	}
143	if (memento.isChanged()) {
144	writeLater(memento);
145	}
146	}
147
148	ContextMemento createMemento(IInteractionContext context) {
149	return new ContextMemento(context, XMLMemento.createWriteRoot(TAG_CONTEXT_STATE));
150	}
151
152	public void restoreState(IInteractionContext context) {
153	final ContextMemento memento = read(context);
154	for (final ContextMementoListener listener : listeners) {
155	SafeRunner.run(new SafeRunnable() {
156	public void run() throws Exception {
157	listener.restoreState(memento);
158	}
159
160	@Override
161	public void handleException(Throwable e) {
162	StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN,
163	"Unexpected error processing context event", e)); //$NON-NLS-1$
164	removeMementoListener(listener);
165	}
166	});
167	}
168	}
169
170	public synchronized void start() {
171	contextManager.addListener(contextListener);
172	}
173
174	public synchronized void stop() {
175	contextManager.removeListener(contextListener);
176	}
177
178	public synchronized void flushPending() {
179	MultiStatus status = new MultiStatus(ContextUiPlugin.ID_PLUGIN, 0,
180	"Failed to save context workbench state", null); //$NON-NLS-1$
181	for (ContextMemento memento : pending.values()) {
182	if (memento.isChanged()) {
183	IStatus result = write(memento);
184	status.add(result);
185	}
186	}
187	pending.clear();
188	if (!status.isOK()) {
189	StatusHandler.log(status);
190	}
191	}
192
193	private ContextMemento read(IInteractionContext context) {
194	File file = getFile(context);
195	if (file.exists()) {
196	try {
197	BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file), CHARSET));
198	XMLMemento memento = XMLMemento.createReadRoot(reader);
199	return new ContextMemento(context, memento);
200	} catch (IOException e) {
201	StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, NLS.bind(
202	"Failed to read context memento from \"{0}\"", file.getAbsolutePath()), e)); //$NON-NLS-1$
203	} catch (WorkbenchException e) {
204	StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, NLS.bind(
205	"Failed to read context memento from \"{0}\"", file.getAbsolutePath()), e)); //$NON-NLS-1$
206	}
207	}
208	return createMemento(context);
209	}
210
211	IStatus write(ContextMemento memento) {
212	File file = getFile(memento.getContext());
213	if (!file.getParentFile().exists()) {
214	file.getParentFile().mkdirs();
215	}
216	try {
217	BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), CHARSET));
218	try {
219	(memento.getMemento()).save(writer);
220	} finally {
221	writer.close();
222	}
223	} catch (IOException e) {
224	return new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, NLS.bind(
225	"Failed to write context memento to \"{0}\"", file.getAbsolutePath()), e); //$NON-NLS-1$
226	}
227	return Status.OK_STATUS;
228	}
229
230	private File getFile(IInteractionContext context) {
231	return new File(location, TasksUtil.encode(context.getHandleIdentifier()));
232	}
233
234	public synchronized void writeLater(ContextMemento memento) {
235	pending.put(memento.getContext().getHandleIdentifier(), memento);
236	schedule();
237	}
238
239	private synchronized void schedule() {
240	if (!scheduled) {
241	if (flushJob == null) {
242	flushJob = new FlushJob();
243	}
244	flushJob.schedule(FLUSH_DELAY);
245	}
246	}
247
248	}