Attachment #154288 for bug #226618

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




/*******************************************************************************
 * Copyright (c) 2009 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.core;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

public class ContextUtil {

	public static String encodeHandle(String handleIdentifier) {
		try {
			return URLEncoder.encode(handleIdentifier, InteractionContextManager.CONTEXT_FILENAME_ENCODING);
		} catch (UnsupportedEncodingException e) {
			throw new IllegalArgumentException("Invalid handle: " + handleIdentifier); //$NON-NLS-1$
		}
	}

}





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 {

	static final String MEMENTO_EDITORS = "org.eclipse.mylyn.context.ui.editors"; //$NON-NLS-1$

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

	/**
	 * HACK: will fail to restore different parts with same name
	 */
	@SuppressWarnings("unchecked")
	private void restoreEditors(WorkbenchPage page, IMemento memento, boolean isActiveWindow) {
		EditorManager editorManager = page.getEditorManager();
		final ArrayList<?> visibleEditors = new ArrayList<Object>(5);
		final IEditorReference activeEditor[] = new IEditorReference[1];
		final MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK, "", null); //$NON-NLS-1$


		}
	}

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

}




/*******************************************************************************
 * 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 dirty;

	private final IInteractionContext context;

	private String contextHandle;

	private final XMLMemento memento;

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

	void setContextHandle(String contextHandle) {
		this.contextHandle = contextHandle;
	}

	// XXX equals and hashcode should probably use the handle to determine equality
	@Override
	public boolean equals(Object obj) {
		if (!(obj instanceof ContextMemento)) {
			return false;
		}
		return context.equals(((ContextMemento) obj).context);
	}

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

	public String getContextHandle() {
		return contextHandle;
	}

	public IInteractionContext getContext() {
		return context;
	}

	XMLMemento getMemento() {
		return memento;
	}

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

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

	public boolean isDirty() {
		return dirty;
	}

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

	public void setDirty(boolean dirty) {
		this.dirty = dirty;
	}

}




/*******************************************************************************
 * 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(String contextHandle, boolean isActiveContext);

	public abstract void restoreState(ContextMemento memento);

	public abstract void saveState(ContextMemento memento);

}




/*******************************************************************************
 * 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.ContextChangeEvent;
import org.eclipse.mylyn.context.core.IInteractionContext;
import org.eclipse.mylyn.context.core.IInteractionContextManager;
import org.eclipse.mylyn.internal.context.core.ContextUtil;
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 contextChanged(ContextChangeEvent event) {
			switch (event.getEventKind()) {
			case ACTIVATED:
				restoreState(event.getContext());
				break;
			case DEACTIVATED:
				saveState(event.getContext());
				break;
			case CLEARED:
				// use the handle since the context is null when it is cleared
				// bug 255588
				clearState(event.getContextHandle(), event.isActiveContext());
				break;
			}
		}
	}

	/**
	 * Delays writing of mementos to avoid blocking UI thread.
	 */
	private class FlushJob extends Job {

		public FlushJob() {
			super("Flush context mementos"); //$NON-NLS-1$
			setSystem(true);
			setPriority(Job.SHORT);
		}

		@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 static final String EXTENSION = ".xml"; //$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(final String contextHandle, final boolean isActiveContext) {
		final ContextMemento memento = createMemento(null, contextHandle);
		for (final ContextMementoListener listener : listeners) {
			SafeRunner.run(new SafeRunnable() {
				public void run() throws Exception {
					listener.clearState(contextHandle, isActiveContext);
				}

				@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);
				}
			});
		}
		delete(memento);
	}

	public void saveState(IInteractionContext context) {
		final ContextMemento memento = createMemento(context, context.getHandleIdentifier());
		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.isDirty()) {
			writeLater(memento);
		}
	}

	ContextMemento createMemento(IInteractionContext context, String contextHandle) {
		return new ContextMemento(context, contextHandle, 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);
		synchronized (this) {
			if (flushJob != null) {
				flushJob.cancel();
				flushJob = null;
			}
		}
		flushPending();
	}

	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.isDirty()) {
				IStatus result = write(memento);
				status.add(result);
			}
		}
		pending.clear();
		if (!status.isOK()) {
			StatusHandler.log(status);
		}
	}

	/**
	 * Public for testing.
	 */
	public ContextMemento read(IInteractionContext context) {
		ContextMemento memento = read(context.getHandleIdentifier(), context);
		if (memento == null) {
			memento = createMemento(context, context.getHandleIdentifier());
		}
		return memento;
	}

	private ContextMemento read(String contextHandle, IInteractionContext context) {
		synchronized (this) {
			ContextMemento memento = pending.get(contextHandle);
			if (memento != null) {
				return memento;
			}
		}

		File file = getFile(contextHandle);
		if (file.exists()) {
			try {
				BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file), CHARSET));
				XMLMemento memento = XMLMemento.createReadRoot(reader);
				return new ContextMemento(context, contextHandle, 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 null;
	}

	IStatus write(ContextMemento memento) {
		File file = getFile(memento.getContextHandle());
		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(String contextHandle) {
		return new File(location, ContextUtil.encodeHandle(contextHandle) + EXTENSION);
	}

	public synchronized void delete(ContextMemento memento) {
		String contextHandle = memento.getContextHandle();
		pending.remove(contextHandle);
		File file = getFile(contextHandle);
		if (file != null && file.exists()) {
			boolean succeeded = file.delete();
			if (!succeeded) {
				StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, NLS.bind(
						"Unable to remove the editor memento \"{0}\"", file.getAbsolutePath()))); //$NON-NLS-1$
			}
		}
	}

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

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

	public void copy(String sourceHandle, String targetHandle) {
		Assert.isNotNull(sourceHandle);
		Assert.isNotNull(targetHandle);
		ContextMemento memento = read(sourceHandle, null);
		if (memento != null) {
			memento.setContextHandle(targetHandle);
			write(memento);
		}
	}
}




import java.util.Set;

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.ui.IMemento;
import org.eclipse.mylyn.tasks.core.ITaskActivationListener;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IPerspectiveListener4;
import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.internal.registry.IActionSetDescriptor;

/**
 * Saves the active perspective on context deactivation and restores it on activation.
 * 
 * @author Mik Kersten
 * @author Shawn Minto
 * @author Steffen Pingel
 */
public class ContextPerspectiveManager implements IPerspectiveListener4 {

	static final String KEY_ACTIVE_ID = "activeId"; //$NON-NLS-1$

	static final String MEMENTO_PERSPECTIVE = "org.eclipse.mylyn.context.ui.perspectives"; //$NON-NLS-1$

	private class MementoListener extends ContextMementoListener {

		@Override
		public void clearState(String contextHandle, boolean isActiveContext) {
			// ignore
		}

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

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

	}

	private final Set<String> managedPerspectiveIds;



	private final IPreferenceStore preferenceStore;

	private final MementoListener mementoListener;

	public ContextPerspectiveManager(IPreferenceStore preferenceStore) {
		this.preferenceStore = preferenceStore;
		this.mementoListener = new MementoListener();
		this.managedPerspectiveIds = new HashSet<String>();
		this.actionSetsToSuppress = new HashSet<String>();
		actionSetsToSuppress.add("org.eclipse.ui.edit.text.actionSet.annotationNavigation"); //$NON-NLS-1$

		managedPerspectiveIds.remove(id);
	}

	public void restoreState(ContextMemento state) {
		if (PlatformUI.isWorkbenchRunning() && isEnabled()) {
			IWorkbenchWindow launchingWindow = getWorkbenchWindow();
			if (launchingWindow != null) {
				// save current perspective
				IPerspectiveDescriptor descriptor = launchingWindow.getActivePage().getPerspective();
				setDefaultPerspective(descriptor.getId());

				// restore perspective
				IMemento memento = state.getMemento(MEMENTO_PERSPECTIVE);
				if (memento != null) {
					String perspectiveId = memento.getString(KEY_ACTIVE_ID);
					showPerspective(perspectiveId);
				}
			}
		} catch (Exception e) {
			// ignore, perspective may not have been saved, e.g. due to crash
		}
	}

	public void saveState(ContextMemento state) {
		if (PlatformUI.isWorkbenchRunning() && isEnabled()) {
			IWorkbenchWindow launchingWindow = getWorkbenchWindow();
			if (launchingWindow != null) {
				IPerspectiveDescriptor descriptor = launchingWindow.getActivePage().getPerspective();
				IWorkbenchWindow launchingWindow = getWorkbenchWindow();
				if (launchingWindow != null) {
					IPerspectiveDescriptor descriptor = launchingWindow.getActivePage().getPerspective();
					setPerspectiveIdFor(task, descriptor.getId());

				IMemento memento = state.createMemento(MEMENTO_PERSPECTIVE);
				memento.putString(KEY_ACTIVE_ID, descriptor.getId());

				String previousPerspectiveId = getDefaultPerspective();
				showPerspective(previousPerspectiveId);
			}
		} catch (Exception e) {
			// ignore, perspective may not have been saved, e.g. due to crash
		}
	}

	private boolean isEnabled() {
		return ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(
				IContextUiPreferenceContstants.AUTO_MANAGE_PERSPECTIVES);
	}

	private void showPerspective(String perspectiveId) {
		if (perspectiveId != null && perspectiveId.length() > 0) {
				&& perspectiveId.length() > 0
				&& ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(
						IContextUiPreferenceContstants.AUTO_MANAGE_PERSPECTIVES)) {
			IWorkbenchWindow launchingWindow = getWorkbenchWindow();
			if (launchingWindow != null) {
				try {
					launchingWindow.getShell().setRedraw(false);
					PlatformUI.getWorkbench().showPerspective(perspectiveId, launchingWindow);
				} catch (Exception e) {
					// perspective's preserved id not found, ignore
				} finally {
			} finally {
				if (launchingWindow != null) {
					launchingWindow.getShell().setRedraw(true);
				}
			}
		}
	}

	public IWorkbenchWindow getWorkbenchWindow() {
		IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		if (window == null) {
			IWorkbenchWindow[] windows = PlatformUI.getWorkbench().getWorkbenchWindows();
			if (windows.length > 0) {
				window = windows[0];
			}
		}
		return window;
	}

	public void perspectivePreDeactivate(IWorkbenchPage page, IPerspectiveDescriptor perspective) {
		// ignore
	}

		// ignore
	}

	private String getDefaultPerspective() {
		return preferenceStore.getString(IContextUiPreferenceContstants.PERSPECTIVE_NO_ACTIVE_TASK);
	}

	private void setDefaultPerspective(String perspectiveId) {
		preferenceStore.setValue(IContextUiPreferenceContstants.PERSPECTIVE_NO_ACTIVE_TASK, perspectiveId);
	}

	public void start(ContextMementoManager mementoManager) {
		mementoManager.addMementoListener(mementoListener);
	}

	public void stop(ContextMementoManager mementoManager) {
		mementoManager.removeMementoListener(mementoListener);
			return preferenceStore.getString(IContextUiPreferenceContstants.PREFIX_TASK_TO_PERSPECTIVE
					+ task.getHandleIdentifier());
		} else {
			return preferenceStore.getString(IContextUiPreferenceContstants.PERSPECTIVE_NO_ACTIVE_TASK);
		}
	}

	public IWorkbenchWindow getWorkbenchWindow() {
		IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		if (window == null) {
			IWorkbenchWindow[] windows = PlatformUI.getWorkbench().getWorkbenchWindows();
			if (windows.length > 0) {
				window = windows[0];
			}
					+ task.getHandleIdentifier(), perspectiveId);
		} else {
			preferenceStore.setValue(IContextUiPreferenceContstants.PERSPECTIVE_NO_ACTIVE_TASK, perspectiveId);
		}
		return window;
	}

}

Lines 11-16 Link Here

(-)src/org/eclipse/mylyn/internal/context/ui/ContextUiPlugin.java (-4 / +165 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.IOException;
		16	import java.io.StringReader;
14	import java.util.ArrayList;	17	import java.util.ArrayList;
15	import java.util.Collections;	18	import java.util.Collections;
16	import java.util.HashMap;	19	import java.util.HashMap;
Lines 28-35 Link Here
28	import org.eclipse.core.runtime.IExtensionPoint;	31	import org.eclipse.core.runtime.IExtensionPoint;
29	import org.eclipse.core.runtime.IExtensionRegistry;	32	import org.eclipse.core.runtime.IExtensionRegistry;
30	import org.eclipse.core.runtime.IStatus;	33	import org.eclipse.core.runtime.IStatus;
		34	import org.eclipse.core.runtime.MultiStatus;
31	import org.eclipse.core.runtime.Platform;	35	import org.eclipse.core.runtime.Platform;
32	import org.eclipse.core.runtime.Status;	36	import org.eclipse.core.runtime.Status;
		37	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
		38	import org.eclipse.core.runtime.preferences.InstanceScope;
33	import org.eclipse.jface.preference.IPreferenceStore;	39	import org.eclipse.jface.preference.IPreferenceStore;
34	import org.eclipse.jface.resource.ImageDescriptor;	40	import org.eclipse.jface.resource.ImageDescriptor;
35	import org.eclipse.jface.text.TextSelection;	41	import org.eclipse.jface.text.TextSelection;
Lines 46-51 Link Here
46	import org.eclipse.mylyn.context.core.IInteractionRelation;	52	import org.eclipse.mylyn.context.core.IInteractionRelation;
47	import org.eclipse.mylyn.context.ui.AbstractContextUiBridge;	53	import org.eclipse.mylyn.context.ui.AbstractContextUiBridge;
48	import org.eclipse.mylyn.context.ui.IContextUiStartup;	54	import org.eclipse.mylyn.context.ui.IContextUiStartup;
		55	import org.eclipse.mylyn.internal.context.core.ContextCorePlugin;
		56	import org.eclipse.mylyn.internal.context.core.InteractionContext;
49	import org.eclipse.mylyn.internal.context.ui.wizards.RetrieveLatestContextDialog;	57	import org.eclipse.mylyn.internal.context.ui.wizards.RetrieveLatestContextDialog;
50	import org.eclipse.mylyn.internal.provisional.commons.ui.WorkbenchUtil;	58	import org.eclipse.mylyn.internal.provisional.commons.ui.WorkbenchUtil;
51	import org.eclipse.mylyn.monitor.ui.MonitorUi;	59	import org.eclipse.mylyn.monitor.ui.MonitorUi;
Lines 54-70 Link Here
54	import org.eclipse.mylyn.tasks.core.TaskActivationAdapter;	62	import org.eclipse.mylyn.tasks.core.TaskActivationAdapter;
55	import org.eclipse.mylyn.tasks.ui.ITasksUiConstants;	63	import org.eclipse.mylyn.tasks.ui.ITasksUiConstants;
56	import org.eclipse.mylyn.tasks.ui.TasksUi;	64	import org.eclipse.mylyn.tasks.ui.TasksUi;
		65	import org.eclipse.osgi.util.NLS;
57	import org.eclipse.swt.graphics.Image;	66	import org.eclipse.swt.graphics.Image;
58	import org.eclipse.ui.IEditorInput;	67	import org.eclipse.ui.IEditorInput;
59	import org.eclipse.ui.IEditorPart;	68	import org.eclipse.ui.IEditorPart;
		69	import org.eclipse.ui.IMemento;
60	import org.eclipse.ui.IViewPart;	70	import org.eclipse.ui.IViewPart;
61	import org.eclipse.ui.IViewReference;	71	import org.eclipse.ui.IViewReference;
62	import org.eclipse.ui.IWorkbench;	72	import org.eclipse.ui.IWorkbench;
63	import org.eclipse.ui.IWorkbenchWindow;	73	import org.eclipse.ui.IWorkbenchWindow;
64	import org.eclipse.ui.PlatformUI;	74	import org.eclipse.ui.PlatformUI;
		75	import org.eclipse.ui.WorkbenchException;
		76	import org.eclipse.ui.XMLMemento;
65	import org.eclipse.ui.internal.WorkbenchPlugin;	77	import org.eclipse.ui.internal.WorkbenchPlugin;
66	import org.eclipse.ui.plugin.AbstractUIPlugin;	78	import org.eclipse.ui.plugin.AbstractUIPlugin;
		79	import org.eclipse.ui.preferences.ScopedPreferenceStore;
67	import org.osgi.framework.BundleContext;	80	import org.osgi.framework.BundleContext;
		81	import org.osgi.service.prefs.BackingStoreException;
68		82
69	/**	83	/**
70	* Main entry point for the Context UI.	84	* Main entry point for the Context UI.
Lines 75-80 Link Here
75	*/	89	*/
76	public class ContextUiPlugin extends AbstractUIPlugin {	90	public class ContextUiPlugin extends AbstractUIPlugin {
77		91
		92	/**
		93	* Only intended for tests and migration.
		94	*/
		95	@Deprecated
		96	public static final String PREFIX_TASK_TO_PERSPECTIVE = "org.eclipse.mylyn.ui.perspectives.task."; //$NON-NLS-1$
		97
		98	/**
		99	* Only intended for tests and migration.
		100	*/
		101	@Deprecated
		102	public static final String EDITOR_MEMENTO_PREFS_PREFIX = "editors.task."; //$NON-NLS-1$
		103
78	public static final String ID_PLUGIN = "org.eclipse.mylyn.context.ui"; //$NON-NLS-1$	104	public static final String ID_PLUGIN = "org.eclipse.mylyn.context.ui"; //$NON-NLS-1$
79		105
80	private class ContextActivationListener extends AbstractContextListener {	106	private class ContextActivationListener extends AbstractContextListener {
Lines 206-211 Link Here
206		232
207	private ContextEditorManager editorManager;	233	private ContextEditorManager editorManager;
208		234
		235	private ContextMementoManager mementoManager;
		236
209	public ContextUiPlugin() {	237	public ContextUiPlugin() {
210	INSTANCE = this;	238	INSTANCE = this;
211	}	239	}
Lines 247-257 Link Here
247	ContextCore.getContextManager().addListener(viewerManager);	275	ContextCore.getContextManager().addListener(viewerManager);
248	MonitorUi.addWindowPartListener(contentOutlineManager);	276	MonitorUi.addWindowPartListener(contentOutlineManager);
249	perspectiveManager.addManagedPerspective(ITasksUiConstants.ID_PERSPECTIVE_PLANNING);	277	perspectiveManager.addManagedPerspective(ITasksUiConstants.ID_PERSPECTIVE_PLANNING);
250	TasksUi.getTaskActivityManager().addActivationListener(perspectiveManager);	278
251	MonitorUi.addWindowPerspectiveListener(perspectiveManager);	279	MonitorUi.addWindowPerspectiveListener(perspectiveManager);
252	TasksUi.getTaskActivityManager().addActivationListener(TASK_ACTIVATION_LISTENER);	280	TasksUi.getTaskActivityManager().addActivationListener(TASK_ACTIVATION_LISTENER);
253		281
254	ContextCore.getContextManager().addListener(editorManager);	282	mementoManager = new ContextMementoManager(ContextCore.getContextManager(), getContextMementoPath());
		283	mementoManager.start();
		284
		285	editorManager = new ContextEditorManager();
		286	editorManager.start(ContextCore.getContextManager(), mementoManager);
		287
		288	perspectiveManager.start(mementoManager);
		289
		290	IStatus status = migrateContextMementos();
		291	if (!status.isOK()) {
		292	StatusHandler.log(status);
		293	}
255	} catch (Exception e) {	294	} catch (Exception e) {
256	StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Context UI initialization failed", //$NON-NLS-1$	295	StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Context UI initialization failed", //$NON-NLS-1$
257	e));	296	e));
Lines 283-297 Link Here
283	}	322	}
284	}	323	}
285		324
		325	/**
		326	* Migrates editor mementos and perspective ids from the preferences to a memento based store in the file-system.
		327	* <p>
		328	* <b>Public for testing.</b>
		329	*
		330	* @since 3.4
		331	*/
		332	public IStatus migrateContextMementos() {
		333	MultiStatus status = new MultiStatus(ContextUiPlugin.ID_PLUGIN, 0,
		334	"Errors migrating saved editors and perspective settings", null); //$NON-NLS-1$
		335
		336	ScopedPreferenceStore perspectivePreferenceStore = new ScopedPreferenceStore(new InstanceScope(),
		337	"org.eclipse.mylyn.context.ui"); //$NON-NLS-1$
		338	ScopedPreferenceStore editorPreferenceStore = new ScopedPreferenceStore(new InstanceScope(),
		339	"org.eclipse.mylyn.resources.ui"); //$NON-NLS-1$
		340
		341	// migrate editor mementos first
		342	IEclipsePreferences[] perspectiveNodes = perspectivePreferenceStore.getPreferenceNodes(false);
		343	IEclipsePreferences[] editorNodes = editorPreferenceStore.getPreferenceNodes(false);
		344	if (editorNodes.length > 0) {
		345	String[] keys;
		346	try {
		347	keys = editorNodes[0].keys();
		348	for (String key : keys) {
		349	if (key.startsWith(EDITOR_MEMENTO_PREFS_PREFIX)) {
		350	String contextHandle = key.substring(EDITOR_MEMENTO_PREFS_PREFIX.length());
		351	String mementoString = editorPreferenceStore.getString(key);
		352	if (mementoString != null && !mementoString.trim().equals("")) { //$NON-NLS-1$
		353	try {
		354	IMemento oldMemento = XMLMemento.createReadRoot(new StringReader(mementoString));
		355	InteractionContext context = new InteractionContext(contextHandle,
		356	ContextCore.getCommonContextScaling());
		357	ContextMemento state = mementoManager.createMemento(context, contextHandle);
		358
		359	// migrate editors
		360	IMemento newMemnto = state.createMemento(ContextEditorManager.MEMENTO_EDITORS);
		361	newMemnto.putMemento(oldMemento);
		362
		363	// migrate perspective
		364	String perspectiveId = perspectivePreferenceStore.getString(PREFIX_TASK_TO_PERSPECTIVE
		365	+ contextHandle);
		366	if (perspectiveId != null) {
		367	IMemento perspectiveMemento = state.createMemento(ContextPerspectiveManager.MEMENTO_PERSPECTIVE);
		368	perspectiveMemento.putString(ContextPerspectiveManager.KEY_ACTIVE_ID, perspectiveId);
		369	}
		370
		371	mementoManager.write(state);
		372	} catch (WorkbenchException e) {
		373	status.add(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, NLS.bind(
		374	"Migration of editor memento failed for {0}", contextHandle), e)); //$NON-NLS-1$
		375	}
		376	}
		377	editorNodes[0].remove(key);
		378	if (perspectiveNodes.length > 0) {
		379	perspectiveNodes[0].remove(PREFIX_TASK_TO_PERSPECTIVE + contextHandle);
		380	}
		381	}
		382	}
		383	} catch (BackingStoreException e) {
		384	status.add(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Reading of editor mementos failed", e)); //$NON-NLS-1$
		385	}
		386	}
		387
		388	// migrate remaining perspective mementos
389	if (perspectiveNodes.length > 0) {
390	try {
391	String[] keys = perspectiveNodes[0].keys();
392	for (String key : keys) {
393	if (key.startsWith(PREFIX_TASK_TO_PERSPECTIVE)
394	&& !key.equals(IContextUiPreferenceContstants.PERSPECTIVE_NO_ACTIVE_TASK)) {
395	String contextHandle = key.substring(PREFIX_TASK_TO_PERSPECTIVE.length());
396	String perspectiveId = perspectivePreferenceStore.getString(key);
397	if (perspectiveId != null && perspectiveId.length() > 0) {
398	InteractionContext context = new InteractionContext(contextHandle,
399	ContextCore.getCommonContextScaling());
400	ContextMemento state = mementoManager.createMemento(context, contextHandle);
401
402	// migrate perspective
403	IMemento perspectiveMemento = state.createMemento(ContextPerspectiveManager.MEMENTO_PERSPECTIVE);
404	perspectiveMemento.putString(ContextPerspectiveManager.KEY_ACTIVE_ID, perspectiveId);
405
406	mementoManager.write(state);
407	}
408	perspectiveNodes[0].remove(key);
409	}
410	}
411	} catch (BackingStoreException e) {
412	status.add(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN,
413	"Reading of perspective mementos failed", e)); //$NON-NLS-1$
414	}
415	}
416
417	try {
418	editorPreferenceStore.save();
419	} catch (IOException e) {
420	status.add(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Saving of preference store failed", e)); //$NON-NLS-1$
421	}
422	try {
423	perspectivePreferenceStore.save();
424	} catch (IOException e) {
425	status.add(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Saving of preference store failed", e)); //$NON-NLS-1$
426	}
427
428	return status;
429	}
430
286	private void lazyStop() {	431	private void lazyStop() {
287	if (editorManager != null) {	432	if (editorManager != null) {
288	ContextCore.getContextManager().removeListener(editorManager);	433	editorManager.stop(ContextCore.getContextManager(), mementoManager);
		434	}
		435
		436	if (perspectiveManager != null) {
		437	perspectiveManager.stop(mementoManager);
		438	}
		439
		440	if (mementoManager != null) {
		441	mementoManager.stop();
289	}	442	}
290		443
291	ContextCore.getContextManager().removeListener(viewerManager);	444	ContextCore.getContextManager().removeListener(viewerManager);
292	MonitorUi.removeWindowPartListener(contentOutlineManager);	445	MonitorUi.removeWindowPartListener(contentOutlineManager);
293		446
294	TasksUi.getTaskActivityManager().removeActivationListener(perspectiveManager);
295	MonitorUi.removeWindowPerspectiveListener(perspectiveManager);	447	MonitorUi.removeWindowPerspectiveListener(perspectiveManager);
296	TasksUi.getTaskActivityManager().removeActivationListener(TASK_ACTIVATION_LISTENER);	448	TasksUi.getTaskActivityManager().removeActivationListener(TASK_ACTIVATION_LISTENER);
297	}	449	}
Lines 639-642 Link Here
639	public static ContextPerspectiveManager getPerspectiveManager() {	791	public static ContextPerspectiveManager getPerspectiveManager() {
640	return INSTANCE.perspectiveManager;	792	return INSTANCE.perspectiveManager;
641	}	793	}
		794
		795	public File getContextMementoPath() {
		796	return new File(ContextCorePlugin.getContextStore().getContextDirectory(), "workbench"); //$NON-NLS-1$
		797	}
		798
		799	public ContextMementoManager getMementoManager() {
		800	return mementoManager;
		801	}
		802
642	}	803	}

Lines 30-35 Link Here

(-)src/org/eclipse/mylyn/internal/context/ui/IContextUiPreferenceContstants.java (-2 lines)
30		30
31	public static final String PERSPECTIVE_NO_ACTIVE_TASK = "org.eclipse.mylyn.ui.perspectives.task.none"; //$NON-NLS-1$	31	public static final String PERSPECTIVE_NO_ACTIVE_TASK = "org.eclipse.mylyn.ui.perspectives.task.none"; //$NON-NLS-1$
32		32
33	public static final String PREFIX_TASK_TO_PERSPECTIVE = "org.eclipse.mylyn.ui.perspectives.task."; //$NON-NLS-1$
34
35	}	33	}

Lines 66-72 Link Here

(-)src/org/eclipse/mylyn/internal/context/ui/commands/CopyContextHandler.java (-1 / +1 lines)
66	MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),	66	MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
67	TITLE_DIALOG, Messages.CopyContextHandler_SOURCE_TASK_DOES_HAVE_A_CONTEXT);	67	TITLE_DIALOG, Messages.CopyContextHandler_SOURCE_TASK_DOES_HAVE_A_CONTEXT);
68	} else {	68	} else {
69	ContextUiPlugin.getEditorManager().copyEditorMemento(sourceTask.getHandleIdentifier(),	69	ContextUiPlugin.getDefault().getMementoManager().copy(sourceTask.getHandleIdentifier(),
70	targetTask.getHandleIdentifier());	70	targetTask.getHandleIdentifier());
71	TasksUiInternal.activateTaskThroughCommand(targetTask);	71	TasksUiInternal.activateTaskThroughCommand(targetTask);
72	}	72	}

Lines 33-38 Link Here

(-)src/org/eclipse/mylyn/internal/monitor/ui/ActivityContextManager.java (-2 / +3 lines)
33	import org.eclipse.mylyn.monitor.ui.AbstractUserActivityMonitor;	33	import org.eclipse.mylyn.monitor.ui.AbstractUserActivityMonitor;
34	import org.eclipse.mylyn.monitor.ui.IActivityContextManager;	34	import org.eclipse.mylyn.monitor.ui.IActivityContextManager;
35	import org.eclipse.mylyn.monitor.ui.IUserAttentionListener;	35	import org.eclipse.mylyn.monitor.ui.IUserAttentionListener;
		36	import org.eclipse.osgi.util.NLS;
36	import org.eclipse.ui.IWorkbenchPage;	37	import org.eclipse.ui.IWorkbenchPage;
37	import org.eclipse.ui.IWorkbenchWindow;	38	import org.eclipse.ui.IWorkbenchWindow;
38	import org.eclipse.ui.IWorkingSet;	39	import org.eclipse.ui.IWorkingSet;
Lines 244-251 Link Here
244	}	245	}
245		246
246	private void disableFailedMonitor(AbstractUserActivityMonitor monitor, Throwable e) {	247	private void disableFailedMonitor(AbstractUserActivityMonitor monitor, Throwable e) {
247	StatusHandler.log(new Status(IStatus.WARNING, ContextCorePlugin.ID_PLUGIN,	248	StatusHandler.log(new Status(IStatus.WARNING, ContextCorePlugin.ID_PLUGIN, NLS.bind(
248	"Activity monitor ''{0}'' was disabled due to a failure")); //$NON-NLS-1$	249	"Activity monitor ''{0}'' was disabled due to a failure", monitor.getClass().getName()), e)); //$NON-NLS-1$
249	activityMonitors.remove(monitor);	250	activityMonitors.remove(monitor);
250	}	251	}
251		252

Lines 100-105 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskDataExportTest.java (+4 lines)
100	CommonTestUtil.deleteFolder(destinationDir);	100	CommonTestUtil.deleteFolder(destinationDir);
101	createDirectory(destinationDir.getParentFile(), destinationDir.getName());	101	createDirectory(destinationDir.getParentFile(), destinationDir.getName());
102		102
		103	// clean up contexts and offline data
		104	CommonTestUtil.deleteFolder(new File(mylynFolder, "contexts"));
		105	CommonTestUtil.deleteFolder(new File(mylynFolder, "tasks"));
		106
103	// Create folder/file structure	107	// Create folder/file structure
104	createFile(mylynFolder, "tasks.xml.zip");	108	createFile(mylynFolder, "tasks.xml.zip");
105	createFile(mylynFolder, "tasklist.xml.zip");	109	createFile(mylynFolder, "tasklist.xml.zip");

Lines 234-240 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskRepositoryManagerTest.java (-1 / +1 lines)
234	//manager.readRepositories(TasksUiPlugin.getDefault().getRepositoriesFilePath());	234	//manager.readRepositories(TasksUiPlugin.getDefault().getRepositoriesFilePath());
235		235
236	if (manager.getRepositoryConnector("bugzilla") != null) {	236	if (manager.getRepositoryConnector("bugzilla") != null) {
237	assertTrue(manager.getAllRepositories().contains(repository2));	237	assertTrue(manager.getAllRepositories().contains(repository1));
238	}	238	}
239	if (manager.getRepositoryConnector("jira") != null) {	239	if (manager.getRepositoryConnector("jira") != null) {
240	assertTrue(manager.getAllRepositories().contains(repository2));	240	assertTrue(manager.getAllRepositories().contains(repository2));

Lines 11-24 Link Here

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




import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.mylyn.commons.core.StatusHandler;
import org.eclipse.mylyn.internal.context.core.ContextCorePlugin;
import org.eclipse.mylyn.internal.context.core.ContextUtil;
import org.eclipse.mylyn.internal.context.core.InteractionContext;
import org.eclipse.mylyn.internal.context.core.InteractionContextManager;
import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;

import org.eclipse.mylyn.internal.tasks.core.data.TaskDataManager;
import org.eclipse.mylyn.monitor.core.InteractionEvent;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.osgi.util.NLS;

/**
 * @author Rob Elves

	@Override
	protected void operations(IProgressMonitor monitor) throws CoreException, InvocationTargetException,
			InterruptedException {
		List<IStatus> result = new ArrayList<IStatus>();
		try {
			//TasksUiPlugin.getTaskListManager().deactivateAllTasks();
			monitor.beginTask(Messages.RefactorRepositoryUrlOperation_Repository_URL_update, IProgressMonitor.UNKNOWN);

			//TasksUiPlugin.getTaskListManager().deactivateAllTasks();
			refactorOfflineHandles(oldUrl, newUrl);
			getTaskList().refactorRepositoryUrl(oldUrl, newUrl);

			refactorMetaContextHandles(oldUrl, newUrl);
			File contextDir = TasksUiPlugin.getDefault().getContextStoreDir();
			refactorContextFileNames(contextDir, ".xml", result); //$NON-NLS-1$
			refactorContextFileNames(new File(contextDir, "workbench"), ".xml", result); //$NON-NLS-1$ //$NON-NLS-2$

			TasksUiPlugin.getTaskActivityMonitor().reloadActivityTime();
		} finally {
			monitor.done();
		}
		if (!result.isEmpty()) {
			StatusHandler.log(new MultiStatus(TasksUiPlugin.ID_PLUGIN, 0, result.toArray(new IStatus[0]), NLS.bind(
					"Problems occured while changing URL from ''{0}'' to ''{1}''", oldUrl, newUrl), null)); //$NON-NLS-1$
		}
	}

	public void refactorContextFileNames(File dataDir, String extension, List<IStatus> result) {
	public void refactorContextFileNames() {

		File dataDir = new File(TasksUiPlugin.getDefault().getDataDirectory(), ITasksCoreConstants.CONTEXTS_DIRECTORY);
		if (dataDir.exists() && dataDir.isDirectory()) {
			File[] files = dataDir.listFiles();
			if (files != null) {
				for (File file : dataDir.listFiles()) {
					refactorContextFile(file, extension, result);
				}
			}
		}
	}

	private void refactorContextFile(File file, String extension, List<IStatus> result) {
		int dotIndex = file.getName().lastIndexOf(extension);
		if (dotIndex != -1) {
			String storedHandle;
			try {
				storedHandle = URLDecoder.decode(file.getName().substring(0, dotIndex),
						InteractionContextManager.CONTEXT_FILENAME_ENCODING);
				int delimIndex = storedHandle.lastIndexOf(RepositoryTaskHandleUtil.HANDLE_DELIM);
				if (delimIndex != -1) {
					String storedUrl = storedHandle.substring(0, delimIndex);
					if (oldUrl.equals(storedUrl)) {
						String id = RepositoryTaskHandleUtil.getTaskId(storedHandle);
						String newHandle = RepositoryTaskHandleUtil.getHandle(newUrl, id);
						File newFile = new File(file.getParentFile(), ContextUtil.encodeHandle(newHandle) + extension);
						file.renameTo(newFile);
					}
				}
			} catch (Exception e) {
				result.add(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,
						"Could not move context file: " + file.getName(), e)); //$NON-NLS-1$
			}
		}
	}

Lines 852-858 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/TasksUiPlugin.java (-1 / +1 lines)
852	}	852	}
853	}	853	}
854		854
855	private File getContextStoreDir() {	855	public File getContextStoreDir() {
856	File storeFile = new File(getDataDirectory(), ITasksCoreConstants.CONTEXTS_DIRECTORY);	856	File storeFile = new File(getDataDirectory(), ITasksCoreConstants.CONTEXTS_DIRECTORY);
857	if (!storeFile.exists()) {	857	if (!storeFile.exists()) {
858	storeFile.mkdirs();	858	storeFile.mkdirs();

Return to bug 226618

Added Link Here

(-)src/org/eclipse/mylyn/internal/context/core/ContextUtil.java (+27 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 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.core;
13
14	import java.io.UnsupportedEncodingException;
15	import java.net.URLEncoder;
16
17	public class ContextUtil {
18
19	public static String encodeHandle(String handleIdentifier) {
20	try {
21	return URLEncoder.encode(handleIdentifier, InteractionContextManager.CONTEXT_FILENAME_ENCODING);
22	} catch (UnsupportedEncodingException e) {
23	throw new IllegalArgumentException("Invalid handle: " + handleIdentifier); //$NON-NLS-1$
24	}
25	}
26
27	}

Added Link Here

(-)src/org/eclipse/mylyn/internal/context/ui/ContextMemento.java (+93 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 org.eclipse.core.runtime.Assert;
15	import org.eclipse.mylyn.context.core.IInteractionContext;
16	import org.eclipse.ui.IMemento;
17	import org.eclipse.ui.XMLMemento;
18
19	/**
20	* Stores workspace specific settings for a context.
21	*
22	* @author Steffen Pingel
23	*/
24	public class ContextMemento {
25
26	private boolean dirty;
27
28	private final IInteractionContext context;
29
30	private String contextHandle;
31
32	private final XMLMemento memento;
33
34	public ContextMemento(IInteractionContext context, String contextHandle, XMLMemento memento) {
35	Assert.isNotNull(memento);
36	Assert.isNotNull(contextHandle);
37	this.context = context;
38	this.contextHandle = contextHandle;
39	this.memento = memento;
40	}
41
42	void setContextHandle(String contextHandle) {
43	this.contextHandle = contextHandle;
44	}
45
46	// XXX equals and hashcode should probably use the handle to determine equality
47	@Override
48	public boolean equals(Object obj) {
49	if (!(obj instanceof ContextMemento)) {
50	return false;
51	}
52	return context.equals(((ContextMemento) obj).context);
53	}
54
55	@Override
56	public int hashCode() {
57	return context.hashCode();
58	}
59
60	public String getContextHandle() {
61	return contextHandle;
62	}
63
64	public IInteractionContext getContext() {
65	return context;
66	}
67
68	XMLMemento getMemento() {
69	return memento;
70	}
71
72	public IMemento getMemento(String type) {
73	return memento.getChild(type);
74	}
75
76	public IMemento createMemento(String type) {
77	dirty = true;
78	return memento.createChild(type);
79	}
80
81	public boolean isDirty() {
82	return dirty;
83	}
84
85	public void removeMemento(String type) {
86	memento.createChild(type);
87	}
88
89	public void setDirty(boolean dirty) {
90	this.dirty = dirty;
91	}
92
93	}

Lines 15-22 Link Here

(-)src/org/eclipse/mylyn/internal/context/ui/ContextPerspectiveManager.java (-71 / +80 lines)
15	import java.util.Set;	15	import java.util.Set;
16		16
17	import org.eclipse.jface.preference.IPreferenceStore;	17	import org.eclipse.jface.preference.IPreferenceStore;
18	import org.eclipse.mylyn.tasks.core.ITask;	18	import org.eclipse.ui.IMemento;
19	import org.eclipse.mylyn.tasks.core.ITaskActivationListener;
20	import org.eclipse.ui.IPerspectiveDescriptor;	19	import org.eclipse.ui.IPerspectiveDescriptor;
21	import org.eclipse.ui.IPerspectiveListener4;	20	import org.eclipse.ui.IPerspectiveListener4;
22	import org.eclipse.ui.IWorkbenchPage;	21	import org.eclipse.ui.IWorkbenchPage;
Lines 28-37 Link Here
28	import org.eclipse.ui.internal.registry.IActionSetDescriptor;	27	import org.eclipse.ui.internal.registry.IActionSetDescriptor;
29		28
30	/**	29	/**
		30	* Saves the active perspective on context deactivation and restores it on activation.
		31	*
31	* @author Mik Kersten	32	* @author Mik Kersten
32	* @author Shawn Minto	33	* @author Shawn Minto
		34	* @author Steffen Pingel
33	*/	35	*/
34	public class ContextPerspectiveManager implements ITaskActivationListener, IPerspectiveListener4 {	36	public class ContextPerspectiveManager implements IPerspectiveListener4 {
		37
		38	static final String KEY_ACTIVE_ID = "activeId"; //$NON-NLS-1$
		39
		40	static final String MEMENTO_PERSPECTIVE = "org.eclipse.mylyn.context.ui.perspectives"; //$NON-NLS-1$
		41
		42	private class MementoListener extends ContextMementoListener {
		43
		44	@Override
		45	public void clearState(String contextHandle, boolean isActiveContext) {
		46	// ignore
		47	}
		48
		49	@Override
		50	public void restoreState(ContextMemento memento) {
		51	ContextPerspectiveManager.this.restoreState(memento);
		52	}
		53
		54	@Override
		55	public void saveState(ContextMemento memento) {
		56	ContextPerspectiveManager.this.saveState(memento);
		57	}
		58
		59	}
35		60
36	private final Set<String> managedPerspectiveIds;	61	private final Set<String> managedPerspectiveIds;
37		62
Lines 39-46 Link Here
39		64
40	private final IPreferenceStore preferenceStore;	65	private final IPreferenceStore preferenceStore;
41		66
		67	private final MementoListener mementoListener;
		68
42	public ContextPerspectiveManager(IPreferenceStore preferenceStore) {	69	public ContextPerspectiveManager(IPreferenceStore preferenceStore) {
43	this.preferenceStore = preferenceStore;	70	this.preferenceStore = preferenceStore;
		71	this.mementoListener = new MementoListener();
44	this.managedPerspectiveIds = new HashSet<String>();	72	this.managedPerspectiveIds = new HashSet<String>();
45	this.actionSetsToSuppress = new HashSet<String>();	73	this.actionSetsToSuppress = new HashSet<String>();
46	actionSetsToSuppress.add("org.eclipse.ui.edit.text.actionSet.annotationNavigation"); //$NON-NLS-1$	74	actionSetsToSuppress.add("org.eclipse.ui.edit.text.actionSet.annotationNavigation"); //$NON-NLS-1$
Lines 56-127 Link Here
56	managedPerspectiveIds.remove(id);	84	managedPerspectiveIds.remove(id);
57	}	85	}
58		86
59	public void taskActivated(ITask task) {	87	public void restoreState(ContextMemento state) {
60	try {	88	if (PlatformUI.isWorkbenchRunning() && isEnabled()) {
61	IWorkbenchWindow launchingWindow = getWorkbenchWindow();	89	IWorkbenchWindow launchingWindow = getWorkbenchWindow();
62	if (launchingWindow != null) {	90	if (launchingWindow != null) {
		91	// save current perspective
63	IPerspectiveDescriptor descriptor = launchingWindow.getActivePage().getPerspective();	92	IPerspectiveDescriptor descriptor = launchingWindow.getActivePage().getPerspective();
64	setPerspectiveIdFor(null, descriptor.getId());	93	setDefaultPerspective(descriptor.getId());
65		94
66	String perspectiveId = getPerspectiveIdFor(task);	95	// restore perspective
67	showPerspective(perspectiveId);	96	IMemento memento = state.getMemento(MEMENTO_PERSPECTIVE);
		97	if (memento != null) {
		98	String perspectiveId = memento.getString(KEY_ACTIVE_ID);
		99	showPerspective(perspectiveId);
		100	}
68	}	101	}
69	} catch (Exception e) {
70	// ignore, perspective may not have been saved, e.g. due to crash
71	}	102	}
72	}	103	}
73		104
74	public void taskDeactivated(ITask task) {	105	public void saveState(ContextMemento state) {
75	try {	106	if (PlatformUI.isWorkbenchRunning() && isEnabled()) {
76	if (PlatformUI.isWorkbenchRunning()	107	IWorkbenchWindow launchingWindow = getWorkbenchWindow();
77	&& ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(	108	if (launchingWindow != null) {
78	IContextUiPreferenceContstants.AUTO_MANAGE_PERSPECTIVES)) {	109	IPerspectiveDescriptor descriptor = launchingWindow.getActivePage().getPerspective();
79	IWorkbenchWindow launchingWindow = getWorkbenchWindow();
80	if (launchingWindow != null) {
81	IPerspectiveDescriptor descriptor = launchingWindow.getActivePage().getPerspective();
82	setPerspectiveIdFor(task, descriptor.getId());
83		110
84	String previousPerspectiveId = getPerspectiveIdFor(null);	111	IMemento memento = state.createMemento(MEMENTO_PERSPECTIVE);
85	showPerspective(previousPerspectiveId);	112	memento.putString(KEY_ACTIVE_ID, descriptor.getId());
86	}	113
		114	String previousPerspectiveId = getDefaultPerspective();
		115	showPerspective(previousPerspectiveId);
87	}	116	}
88	} catch (Exception e) {
89	// ignore, perspective may not have been saved, e.g. due to crash
90	}	117	}
91	}	118	}
92		119
		120	private boolean isEnabled() {
		121	return ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(
		122	IContextUiPreferenceContstants.AUTO_MANAGE_PERSPECTIVES);
		123	}
		124
93	private void showPerspective(String perspectiveId) {	125	private void showPerspective(String perspectiveId) {
94	if (perspectiveId != null	126	if (perspectiveId != null && perspectiveId.length() > 0) {
95	&& perspectiveId.length() > 0
96	&& ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(
97	IContextUiPreferenceContstants.AUTO_MANAGE_PERSPECTIVES)) {
98	IWorkbenchWindow launchingWindow = getWorkbenchWindow();	127	IWorkbenchWindow launchingWindow = getWorkbenchWindow();
99	try {	128	if (launchingWindow != null) {
100	if (launchingWindow != null) {	129	try {
101	launchingWindow.getShell().setRedraw(false);	130	launchingWindow.getShell().setRedraw(false);
102	PlatformUI.getWorkbench().showPerspective(perspectiveId, launchingWindow);	131	PlatformUI.getWorkbench().showPerspective(perspectiveId, launchingWindow);
103	}	132	} catch (Exception e) {
104	} catch (Exception e) {	133	// perspective's preserved id not found, ignore
105	// perspective's preserved id not found, ignore	134	} finally {
106	} finally {
107	if (launchingWindow != null) {
108	launchingWindow.getShell().setRedraw(true);	135	launchingWindow.getShell().setRedraw(true);
109	}	136	}
110	}	137	}
111	}	138	}
112	}	139	}
113		140
114	public IWorkbenchWindow getWorkbenchWindow() {
115	IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
116	if (window == null) {
117	IWorkbenchWindow[] windows = PlatformUI.getWorkbench().getWorkbenchWindows();
118	if (windows.length > 0) {
119	window = windows[0];
120	}
121	}
122	return window;
123	}
124
125	public void perspectivePreDeactivate(IWorkbenchPage page, IPerspectiveDescriptor perspective) {	141	public void perspectivePreDeactivate(IWorkbenchPage page, IPerspectiveDescriptor perspective) {
126	// ignore	142	// ignore
127	}	143	}
Lines 173-210 Link Here
173	// ignore	189	// ignore
174	}	190	}
175		191
176	public void preTaskActivated(ITask task) {	192	private String getDefaultPerspective() {
177	// ignore	193	return preferenceStore.getString(IContextUiPreferenceContstants.PERSPECTIVE_NO_ACTIVE_TASK);
178	}	194	}
179		195
180	public void preTaskDeactivated(ITask task) {	196	private void setDefaultPerspective(String perspectiveId) {
181	// ignore	197	preferenceStore.setValue(IContextUiPreferenceContstants.PERSPECTIVE_NO_ACTIVE_TASK, perspectiveId);
182	}	198	}
183		199
184	/**	200	public void start(ContextMementoManager mementoManager) {
185	* @param task	201	mementoManager.addMementoListener(mementoListener);
186	* can be null to indicate no task	202	}
187	*/	203
188	private String getPerspectiveIdFor(ITask task) {	204	public void stop(ContextMementoManager mementoManager) {
189	if (task != null) {	205	mementoManager.removeMementoListener(mementoListener);
190	return preferenceStore.getString(IContextUiPreferenceContstants.PREFIX_TASK_TO_PERSPECTIVE
191	+ task.getHandleIdentifier());
192	} else {
193	return preferenceStore.getString(IContextUiPreferenceContstants.PERSPECTIVE_NO_ACTIVE_TASK);
194	}
195	}	206	}
196		207
197	/**	208	public IWorkbenchWindow getWorkbenchWindow() {
198	* @param task	209	IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
199	* can be null to indicate no task	210	if (window == null) {
200	*/	211	IWorkbenchWindow[] windows = PlatformUI.getWorkbench().getWorkbenchWindows();
201	private void setPerspectiveIdFor(ITask task, String perspectiveId) {	212	if (windows.length > 0) {
202	if (task != null) {	213	window = windows[0];
203	preferenceStore.setValue(IContextUiPreferenceContstants.PREFIX_TASK_TO_PERSPECTIVE	214	}
204	+ task.getHandleIdentifier(), perspectiveId);
205	} else {
206	preferenceStore.setValue(IContextUiPreferenceContstants.PERSPECTIVE_NO_ACTIVE_TASK, perspectiveId);
207	}	215	}
		216	return window;
208	}	217	}
209		218
210	}	219	}