Attachment #178366 for bug #321278

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




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.ui.IEditorReference;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
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;


	private static final String ATTRIBUTE_IS_ACTIVE = "isActive"; //$NON-NLS-1$

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

	private final IPreferenceStore preferenceStore;



	public void openEditorsFromMemento(IInteractionContext context) {
		if (!Workbench.getInstance().isStarting()
				&& ContextUiPlugin.getDefault()
						.getPreferenceStore()
						.getBoolean(IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS) && !TaskMigrator.isActive()) {
			Workbench workbench = (Workbench) PlatformUI.getWorkbench();
			previousCloseEditorsSetting = workbench.getPreferenceStore().getBoolean(
					IPreferenceConstants.REUSE_EDITORS_BOOLEAN);


	public void closeEditorsAndSaveMemento(IInteractionContext context) {
		if (!PlatformUI.getWorkbench().isClosing()
				&& ContextUiPlugin.getDefault()
						.getPreferenceStore()
						.getBoolean(IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS) && !TaskMigrator.isActive()) {
			closeAllButActiveTaskEditor(context.getHandleIdentifier());

			XMLMemento rootMemento = XMLMemento.createWriteRoot(KEY_CONTEXT_EDITORS);

				memento.putInteger(ATTRIBUTE_NUMER, number);
				memento.putBoolean(ATTRIBUTE_IS_LAUNCHING, window == launchingWindow);
				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();

						e));
			}

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

			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) {
			closeAllEditors();
		}

	 */
	@SuppressWarnings("unchecked")
	private void restoreEditors(WorkbenchPage page, IMemento memento, boolean isActiveWindow) {
//		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$
//
//		try {
//			IMemento[] editorMementos = memento.getChildren(IWorkbenchConstants.TAG_EDITOR);
//			Set<IMemento> editorMementoSet = new HashSet<IMemento>();
//			editorMementoSet.addAll(Arrays.asList(editorMementos));
//			// HACK: same parts could have different editors
//			Set<String> restoredPartNames = new HashSet<String>();
//			List<IEditorReference> alreadyVisibleEditors = Arrays.asList(editorManager.getEditors());
//			for (IEditorReference editorReference : alreadyVisibleEditors) {
//				restoredPartNames.add(editorReference.getPartName());
//			}
//			for (IMemento editorMemento : editorMementoSet) {
//				String partName = editorMemento.getString(IWorkbenchConstants.TAG_PART_NAME);
//				if (!restoredPartNames.contains(partName)) {
//					editorManager.restoreEditorState(editorMemento, visibleEditors, activeEditor, result);
//				} else {
//					restoredPartNames.add(partName);
//				}
//			}
//
//			for (int i = 0; i < visibleEditors.size(); i++) {
//				editorManager.setVisibleEditor((IEditorReference) visibleEditors.get(i), false);
//			}
//
//			if (activeEditor[0] != null && isActiveWindow) {
//				IWorkbenchPart editor = activeEditor[0].getPart(true);
//				if (editor != null) {
//					page.activate(editor);
//				}
//			}
//		} catch (Exception e) {
//			StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Could not restore editors", e)); //$NON-NLS-1$
//		}
	}

	public void closeAllButActiveTaskEditor(String taskHandle) {

	}

	private void closeEditor(IInteractionElement element, boolean force) {
		if (ContextUiPlugin.getDefault()
				.getPreferenceStore()
				.getBoolean(IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS)) {
			if (force || !element.getInterest().isInteresting()) {
				AbstractContextStructureBridge bridge = ContextCore.getStructureBridge(element.getContentType());
				if (bridge.isDocument(element.getHandleIdentifier())) {




import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.Perspective;
import org.eclipse.ui.internal.WorkbenchPage;
import org.eclipse.ui.internal.registry.IActionSetDescriptor;


	public void taskDeactivated(ITask task) {
		try {
			if (PlatformUI.isWorkbenchRunning()
					&& ContextUiPlugin.getDefault()
							.getPreferenceStore()
							.getBoolean(IContextUiPreferenceContstants.AUTO_MANAGE_PERSPECTIVES)) {
				IWorkbenchWindow launchingWindow = getWorkbenchWindow();
				if (launchingWindow != null) {
					IPerspectiveDescriptor descriptor = launchingWindow.getActivePage().getPerspective();

	private void showPerspective(String perspectiveId) {
		if (perspectiveId != null
				&& perspectiveId.length() > 0
				&& ContextUiPlugin.getDefault()
						.getPreferenceStore()
						.getBoolean(IContextUiPreferenceContstants.AUTO_MANAGE_PERSPECTIVES)) {
			IWorkbenchWindow launchingWindow = getWorkbenchWindow();
			try {
				if (launchingWindow != null) {

	private void cleanActionSets(IWorkbenchPage page, IPerspectiveDescriptor perspectiveDescriptor) {
		if (managedPerspectiveIds.contains(perspectiveDescriptor.getId())) {
			if (page instanceof WorkbenchPage) {
				IPerspectiveDescriptor perspective = ((WorkbenchPage) page).getPerspective();

				Set<IActionSetDescriptor> toRemove = new HashSet<IActionSetDescriptor>();
				IActionSetDescriptor[] actionSetDescriptors = ((WorkbenchPage) page).getActionSets();

						toRemove.add(actionSetDescriptor);
					}
				}
//				perspective.turnOffActionSets(toRemove.toArray(new IActionSetDescriptor[toRemove.size()]));
			}
		}
	}

	 */
	private void setPerspectiveIdFor(ITask task, String perspectiveId) {
		if (task != null) {
			preferenceStore.setValue(
					IContextUiPreferenceContstants.PREFIX_TASK_TO_PERSPECTIVE + task.getHandleIdentifier(),
					perspectiveId);
		} else {
			preferenceStore.setValue(IContextUiPreferenceContstants.PERSPECTIVE_NO_ACTIVE_TASK, perspectiveId);
		}

Lines 32-38 Link Here

(-)src/org/eclipse/mylyn/monitor/tests/AllMonitorTests.java (-1 lines)
32	suite.addTestSuite(MonitorTest.class);	32	suite.addTestSuite(MonitorTest.class);
33	suite.addTestSuite(InteractionEventExternalizationTest.class);	33	suite.addTestSuite(InteractionEventExternalizationTest.class);
34	suite.addTestSuite(MonitorPackagingTest.class);	34	suite.addTestSuite(MonitorPackagingTest.class);
35	suite.addTestSuite(MultiWindowMonitorTest.class);
36	suite.addTestSuite(ActivityContextManagerTest.class);	35	suite.addTestSuite(ActivityContextManagerTest.class);
37	return suite;	36	return suite;
38	}	37	}




///*******************************************************************************
// * Copyright (c) 2004, 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:
// *     Brian de Alwis - initial API and implementation
// *     Tasktop Technologies - improvements
// *******************************************************************************/
//
//package org.eclipse.mylyn.monitor.tests;
//
//import java.io.File;
//import java.io.IOException;
//import java.lang.reflect.Field;
//import java.lang.reflect.Method;
//
//import junit.framework.TestCase;
//
//import org.eclipse.core.runtime.IStatus;
//import org.eclipse.jface.viewers.StructuredSelection;
//import org.eclipse.jface.window.Window;
//import org.eclipse.jface.window.WindowManager;
//import org.eclipse.mylyn.internal.monitor.ui.IMonitoredWindow;
//import org.eclipse.mylyn.internal.monitor.ui.MonitorUiPlugin;
//import org.eclipse.mylyn.internal.monitor.usage.InteractionEventLogger;
//import org.eclipse.mylyn.internal.monitor.usage.UiUsageMonitorPlugin;
//import org.eclipse.ui.IMemento;
//import org.eclipse.ui.IWorkbenchWindow;
//import org.eclipse.ui.PlatformUI;
//import org.eclipse.ui.XMLMemento;
//import org.eclipse.ui.internal.IWorkbenchConstants;
//import org.eclipse.ui.internal.Workbench;
//import org.eclipse.ui.internal.WorkbenchWindow;
//
///**
// * @author Brian de Alwis
// * @author Mik Kersten
// * @author Shawn Minto
// */
//public class MultiWindowMonitorTest extends TestCase {
//
//	private class ContextAwareWorkbenchWindow extends WorkbenchWindow implements IMonitoredWindow {
//
//		private boolean monitored = true;
//
//		public ContextAwareWorkbenchWindow(int number, boolean monitored) {
//			super(number);
//			this.monitored = monitored;
//		}
//
//		public boolean isMonitored() {
//			return monitored;
//		}
//
//		public boolean isPerspectiveManaged() {
//			return false;
//		}
//	}
//
//	private class MockWorkbench {
//		private final Workbench wBench;
//
//		private WindowManager parentManager = null;
//
//		private MockWorkbench() {
//			wBench = Workbench.getInstance();
//
//			Field wManagerField;
//			try {
//				wManagerField = Workbench.class.getDeclaredField("windowManager");
//				wManagerField.setAccessible(true);
//				parentManager = (WindowManager) wManagerField.get(wBench);
//
//			} catch (Exception e) {
//			}
//		}
//
//		private int getNewWindowNumber() {
//			Window[] windows = parentManager.getWindows();
//			int count = windows.length;
//
//			boolean checkArray[] = new boolean[count];
//			for (int nX = 0; nX < count; nX++) {
//				if (windows[nX] instanceof WorkbenchWindow) {
//					WorkbenchWindow ww = (WorkbenchWindow) windows[nX];
//					int index = ww.getNumber() - 1;
//					if (index >= 0 && index < count) {
//						checkArray[index] = true;
//					}
//				}
//			}
//
//			for (int index = 0; index < count; index++) {
//				if (!checkArray[index]) {
//					return index + 1;
//				}
//			}
//			return count + 1;
//		}
//
//		private ContextAwareWorkbenchWindow newWorkbenchWindow(boolean isMonitored) {
//			return new ContextAwareWorkbenchWindow(getNewWindowNumber(), isMonitored);
//		}
//
//		public ContextAwareWorkbenchWindow restoreState(IMemento memento, boolean isMonitored) {
//
//			ContextAwareWorkbenchWindow newWindow = newWorkbenchWindow(isMonitored);
//			newWindow.create();
//
//			parentManager.add(newWindow);
//
//			boolean opened = false;
//
//			try {
//				newWindow.restoreState(memento, null);
//				newWindow.open();
//				opened = true;
//			} finally {
//				if (!opened) {
//					newWindow.close();
//				}
//			}
//
//			return newWindow;
//		}
//	}
//
//	private final InteractionEventLogger logger = UiUsageMonitorPlugin.getDefault().getInteractionLogger();
//
//	private MockSelectionMonitor selectionMonitor;
//
//	private IWorkbenchWindow window1;
//
//	private IWorkbenchWindow window2;
//
//	private IWorkbenchWindow window3;
//
//	private IWorkbenchWindow window4;
//
//	private boolean monitoringWasEnabled;
//
//	@Override
//	protected void setUp() throws Exception {
//		super.setUp();
//		selectionMonitor = new MockSelectionMonitor();
//		monitoringWasEnabled = UiUsageMonitorPlugin.getDefault().isMonitoringEnabled();
//		UiUsageMonitorPlugin.getDefault().stopMonitoring();
//
//		// make sure the MonitorUiPlugin is fully initialized
//		while (PlatformUI.getWorkbench().getDisplay().readAndDispatch()) {
//		}
//
//		window1 = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
//		assertTrue(MonitorUiPlugin.getDefault().getMonitoredWindows().contains(window1));
//		window2 = duplicateWindow(window1);
//		assertNotNull(window2);
//		assertTrue(MonitorUiPlugin.getDefault().getMonitoredWindows().contains(window2));
//		window3 = createContextAwareWindow(true, window1);
//		assertNotNull(window3);
//		assertTrue(MonitorUiPlugin.getDefault().getMonitoredWindows().contains(window3));
//		window4 = createContextAwareWindow(false, window1);
//		assertNotNull(window4);
//		assertFalse(MonitorUiPlugin.getDefault().getMonitoredWindows().contains(window4));
//	}
//
//	@Override
//	protected void tearDown() throws Exception {
//		super.tearDown();
//		window2.close();
//		window3.close();
//		window4.close();
//		if (monitoringWasEnabled) {
//			UiUsageMonitorPlugin.getDefault().startMonitoring();
//		}
//		if (selectionMonitor != null) {
//			selectionMonitor.dispose();
//		}
//	}
//
//	protected void generateSelection(IWorkbenchWindow w) {
//		selectionMonitor.selectionChanged(w.getActivePage().getActivePart(), new StructuredSelection("yo"));
//	}
//
//	public void testMultipleWindows() throws IOException {
//		File monitorFile = UiUsageMonitorPlugin.getDefault().getMonitorLogFile();
//		logger.clearInteractionHistory();
//		assertEquals(0, logger.getHistoryFromFile(monitorFile).size());
//
//		generateSelection(window1);
//		assertEquals(0, logger.getHistoryFromFile(monitorFile).size());
//
//		UiUsageMonitorPlugin.getDefault().startMonitoring();
//		generateSelection(window1);
//		generateSelection(window2);
//		generateSelection(window3);
//		generateSelection(window4);
//		assertEquals(3, logger.getHistoryFromFile(monitorFile).size());
//	}
//
//	protected IWorkbenchWindow duplicateWindow(IWorkbenchWindow window) {
//		WorkbenchWindow w = (WorkbenchWindow) window;
//		XMLMemento memento = XMLMemento.createWriteRoot(IWorkbenchConstants.TAG_WINDOW);
//		IStatus status = w.saveState(memento);
//		if (!status.isOK()) {
//			fail("failed to duplicate window: " + status);
//		}
//		return restoreWorkbenchWindow((Workbench) w.getWorkbench(), memento);
//	}
//
//	private IWorkbenchWindow createContextAwareWindow(boolean monitored, IWorkbenchWindow window) {
//		WorkbenchWindow w = (WorkbenchWindow) window;
//		XMLMemento memento = XMLMemento.createWriteRoot(IWorkbenchConstants.TAG_WINDOW);
//		IStatus status = w.saveState(memento);
//		if (!status.isOK()) {
//			fail("failed to duplicate window: " + status);
//		}
//		return new MockWorkbench().restoreState(memento, monitored);
//	}
//
//	protected IWorkbenchWindow restoreWorkbenchWindow(Workbench workbench, IMemento memento) {
//		return (IWorkbenchWindow) invokeMethod(workbench, "restoreWorkbenchWindow", new Class[] { IMemento.class },
//				new Object[] { memento });
//	}
//
//	protected Object invokeMethod(Object instance, String methodName, Class<?> argTypes[], Object arguments[]) {
//		Class<?> clas = instance.getClass();
//		try {
//			Method method = clas.getDeclaredMethod(methodName, argTypes);
//			method.setAccessible(true);
//			return method.invoke(instance, arguments);
//		} catch (Exception ex) {
//			fail("exception during reflective invocation of " + clas.getName() + "." + methodName + ": " + ex);
//			return null;
//		}
//	}
//
//}




import org.eclipse.mylyn.java.tests.AbstractJavaContextTest;
import org.eclipse.mylyn.java.tests.search.SearchPluginTestHelper;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IViewReference;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.Perspective;
import org.eclipse.ui.internal.WorkbenchPage;

/**

		}
		JavaPlugin.getActivePage().showView("org.eclipse.ui.views.ProblemView");

		IPerspectiveDescriptor perspective = ((WorkbenchPage) JavaPlugin.getActivePage()).getPerspective();
		IViewReference reference = JavaPlugin.getActivePage().findViewReference(ActiveSearchView.ID);
		assertNotNull(reference);
//		assertTrue(perspective.canCloseView(view));
//		assertTrue(perspective.hideView(reference));

		for (AbstractRelationProvider provider : ContextCorePlugin.getDefault().getRelationProviders()) {
			assertFalse(provider.isEnabled());





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

import java.util.ArrayList;

import org.eclipse.mylyn.tasks.ui.ITasksUiConstants;
import org.eclipse.ui.IFolderLayout;
import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.IPerspectiveFactory;
import org.eclipse.ui.internal.PageLayout;

/**
 * @author Mik Kersten

	}

	public static void removeUninterestingActionSets(IPageLayout layout) {
//		ArrayList<?> actionSets = (layout).getActionSets();
//		actionSets.remove("org.eclipse.ui.edit.text.actionSet.annotationNavigation"); //$NON-NLS-1$
//		actionSets.remove("org.eclipse.ui.edit.text.actionSet.convertLineDelimitersTo"); //$NON-NLS-1$
//		actionSets.remove("org.eclipse.ui.externaltools.ExternalToolsSet"); //$NON-NLS-1$
	}
}




import org.eclipse.ui.forms.widgets.ScrolledForm;
import org.eclipse.ui.forms.widgets.Section;
import org.eclipse.ui.forms.widgets.SharedScrolledComposite;
import org.eclipse.ui.internal.EditorAreaHelper;
import org.eclipse.ui.internal.WorkbenchPage;
import org.eclipse.ui.internal.forms.widgets.FormUtil;


		Composite layoutAdvisor = page.getEditorComposite();
		do {
			layoutAdvisor = layoutAdvisor.getParent();
		} while (!(layoutAdvisor instanceof CTabFolder || layoutAdvisor.getClass()
				.getName()
				.equals("org.eclipse.e4.ui.widgets.CTabFolder")));
		return layoutAdvisor.getParent();
	}


		}
		if (widthHint <= 0 && page.getEditor().getEditorSite() != null
				&& page.getEditor().getEditorSite().getPage() != null) {
			Composite editorManager = ((WorkbenchPage) page.getEditor().getEditorSite().getPage()).getClientComposite();
			if (editorManager != null) {
				widthHint = editorManager.getBounds().width - 90;
			}
		}
		if (widthHint <= 0) {




import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.Section;
import org.eclipse.ui.internal.EditorAreaHelper;
import org.eclipse.ui.internal.WorkbenchPage;

/**

		}
		if (widthHint <= 0 && getTaskEditorPage().getEditor().getEditorSite() != null
				&& getTaskEditorPage().getEditor().getEditorSite().getPage() != null) {
			Composite editorManager = (((WorkbenchPage) getTaskEditorPage().getEditor().getEditorSite().getPage())).getClientComposite();
			if (editorManager != null) {
				widthHint = editorManager.getBounds().width - 90;
			}
		}


Return to bug 321278

Lines 23-29 Link Here

(-)src/org/eclipse/mylyn/internal/context/ui/ContextPerspectiveManager.java (-9 / +11 lines)
23	import org.eclipse.ui.IWorkbenchPartReference;	23	import org.eclipse.ui.IWorkbenchPartReference;
24	import org.eclipse.ui.IWorkbenchWindow;	24	import org.eclipse.ui.IWorkbenchWindow;
25	import org.eclipse.ui.PlatformUI;	25	import org.eclipse.ui.PlatformUI;
26	import org.eclipse.ui.internal.Perspective;
27	import org.eclipse.ui.internal.WorkbenchPage;	26	import org.eclipse.ui.internal.WorkbenchPage;
28	import org.eclipse.ui.internal.registry.IActionSetDescriptor;	27	import org.eclipse.ui.internal.registry.IActionSetDescriptor;
29		28
Lines 74-81 Link Here
74	public void taskDeactivated(ITask task) {	73	public void taskDeactivated(ITask task) {
75	try {	74	try {
76	if (PlatformUI.isWorkbenchRunning()	75	if (PlatformUI.isWorkbenchRunning()
77	&& ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(	76	&& ContextUiPlugin.getDefault()
78	IContextUiPreferenceContstants.AUTO_MANAGE_PERSPECTIVES)) {	77	.getPreferenceStore()
		78	.getBoolean(IContextUiPreferenceContstants.AUTO_MANAGE_PERSPECTIVES)) {
79	IWorkbenchWindow launchingWindow = getWorkbenchWindow();	79	IWorkbenchWindow launchingWindow = getWorkbenchWindow();
80	if (launchingWindow != null) {	80	if (launchingWindow != null) {
81	IPerspectiveDescriptor descriptor = launchingWindow.getActivePage().getPerspective();	81	IPerspectiveDescriptor descriptor = launchingWindow.getActivePage().getPerspective();
Lines 93-100 Link Here
93	private void showPerspective(String perspectiveId) {	93	private void showPerspective(String perspectiveId) {
94	if (perspectiveId != null	94	if (perspectiveId != null
95	&& perspectiveId.length() > 0	95	&& perspectiveId.length() > 0
96	&& ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(	96	&& ContextUiPlugin.getDefault()
97	IContextUiPreferenceContstants.AUTO_MANAGE_PERSPECTIVES)) {	97	.getPreferenceStore()
		98	.getBoolean(IContextUiPreferenceContstants.AUTO_MANAGE_PERSPECTIVES)) {
98	IWorkbenchWindow launchingWindow = getWorkbenchWindow();	99	IWorkbenchWindow launchingWindow = getWorkbenchWindow();
99	try {	100	try {
100	if (launchingWindow != null) {	101	if (launchingWindow != null) {
Lines 155-161 Link Here
155	private void cleanActionSets(IWorkbenchPage page, IPerspectiveDescriptor perspectiveDescriptor) {	156	private void cleanActionSets(IWorkbenchPage page, IPerspectiveDescriptor perspectiveDescriptor) {
156	if (managedPerspectiveIds.contains(perspectiveDescriptor.getId())) {	157	if (managedPerspectiveIds.contains(perspectiveDescriptor.getId())) {
157	if (page instanceof WorkbenchPage) {	158	if (page instanceof WorkbenchPage) {
158	Perspective perspective = ((WorkbenchPage) page).getActivePerspective();	159	IPerspectiveDescriptor perspective = ((WorkbenchPage) page).getPerspective();
159		160
160	Set<IActionSetDescriptor> toRemove = new HashSet<IActionSetDescriptor>();	161	Set<IActionSetDescriptor> toRemove = new HashSet<IActionSetDescriptor>();
161	IActionSetDescriptor[] actionSetDescriptors = ((WorkbenchPage) page).getActionSets();	162	IActionSetDescriptor[] actionSetDescriptors = ((WorkbenchPage) page).getActionSets();
Lines 164-170 Link Here
164	toRemove.add(actionSetDescriptor);	165	toRemove.add(actionSetDescriptor);
165	}	166	}
166	}	167	}
167	perspective.turnOffActionSets(toRemove.toArray(new IActionSetDescriptor[toRemove.size()]));	168	// perspective.turnOffActionSets(toRemove.toArray(new IActionSetDescriptor[toRemove.size()]));
168	}	169	}
169	}	170	}
170	}	171	}
Lines 200-207 Link Here
200	*/	201	*/
201	private void setPerspectiveIdFor(ITask task, String perspectiveId) {	202	private void setPerspectiveIdFor(ITask task, String perspectiveId) {
202	if (task != null) {	203	if (task != null) {
203	preferenceStore.setValue(IContextUiPreferenceContstants.PREFIX_TASK_TO_PERSPECTIVE	204	preferenceStore.setValue(
204	+ task.getHandleIdentifier(), perspectiveId);	205	IContextUiPreferenceContstants.PREFIX_TASK_TO_PERSPECTIVE + task.getHandleIdentifier(),
		206	perspectiveId);
205	} else {	207	} else {
206	preferenceStore.setValue(IContextUiPreferenceContstants.PERSPECTIVE_NO_ACTIVE_TASK, perspectiveId);	208	preferenceStore.setValue(IContextUiPreferenceContstants.PERSPECTIVE_NO_ACTIVE_TASK, perspectiveId);
207	}	209	}

Lines 68-74 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/EditorUtil.java (-5 / +6 lines)
68	import org.eclipse.ui.forms.widgets.ScrolledForm;	68	import org.eclipse.ui.forms.widgets.ScrolledForm;
69	import org.eclipse.ui.forms.widgets.Section;	69	import org.eclipse.ui.forms.widgets.Section;
70	import org.eclipse.ui.forms.widgets.SharedScrolledComposite;	70	import org.eclipse.ui.forms.widgets.SharedScrolledComposite;
71	import org.eclipse.ui.internal.EditorAreaHelper;
72	import org.eclipse.ui.internal.WorkbenchPage;	71	import org.eclipse.ui.internal.WorkbenchPage;
73	import org.eclipse.ui.internal.forms.widgets.FormUtil;	72	import org.eclipse.ui.internal.forms.widgets.FormUtil;
74		73
Lines 363-369 Link Here
363	Composite layoutAdvisor = page.getEditorComposite();	362	Composite layoutAdvisor = page.getEditorComposite();
364	do {	363	do {
365	layoutAdvisor = layoutAdvisor.getParent();	364	layoutAdvisor = layoutAdvisor.getParent();
366	} while (!(layoutAdvisor instanceof CTabFolder));	365	} while (!(layoutAdvisor instanceof CTabFolder \|\| layoutAdvisor.getClass()
		366	.getName()
		367	.equals("org.eclipse.e4.ui.widgets.CTabFolder")));
367	return layoutAdvisor.getParent();	368	return layoutAdvisor.getParent();
368	}	369	}
369		370
Lines 488-496 Link Here
488	}	489	}
489	if (widthHint <= 0 && page.getEditor().getEditorSite() != null	490	if (widthHint <= 0 && page.getEditor().getEditorSite() != null
490	&& page.getEditor().getEditorSite().getPage() != null) {	491	&& page.getEditor().getEditorSite().getPage() != null) {
491	EditorAreaHelper editorManager = ((WorkbenchPage) page.getEditor().getEditorSite().getPage()).getEditorPresentation();	492	Composite editorManager = ((WorkbenchPage) page.getEditor().getEditorSite().getPage()).getClientComposite();
492	if (editorManager != null && editorManager.getLayoutPart() != null) {	493	if (editorManager != null) {
493	widthHint = editorManager.getLayoutPart().getControl().getBounds().width - 90;	494	widthHint = editorManager.getBounds().width - 90;
494	}	495	}
495	}	496	}
496	if (widthHint <= 0) {	497	if (widthHint <= 0) {

Lines 25-31 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskEditorNotesPart.java (-4 / +3 lines)
25	import org.eclipse.swt.widgets.Composite;	25	import org.eclipse.swt.widgets.Composite;
26	import org.eclipse.ui.forms.widgets.FormToolkit;	26	import org.eclipse.ui.forms.widgets.FormToolkit;
27	import org.eclipse.ui.forms.widgets.Section;	27	import org.eclipse.ui.forms.widgets.Section;
28	import org.eclipse.ui.internal.EditorAreaHelper;
29	import org.eclipse.ui.internal.WorkbenchPage;	28	import org.eclipse.ui.internal.WorkbenchPage;
30		29
31	/**	30	/**
Lines 108-116 Link Here
108	}	107	}
109	if (widthHint <= 0 && getTaskEditorPage().getEditor().getEditorSite() != null	108	if (widthHint <= 0 && getTaskEditorPage().getEditor().getEditorSite() != null
110	&& getTaskEditorPage().getEditor().getEditorSite().getPage() != null) {	109	&& getTaskEditorPage().getEditor().getEditorSite().getPage() != null) {
111	EditorAreaHelper editorManager = ((WorkbenchPage) getTaskEditorPage().getEditor().getEditorSite().getPage()).getEditorPresentation();	110	Composite editorManager = (((WorkbenchPage) getTaskEditorPage().getEditor().getEditorSite().getPage())).getClientComposite();
112	if (editorManager != null && editorManager.getLayoutPart() != null) {	111	if (editorManager != null) {
113	widthHint = editorManager.getLayoutPart().getControl().getBounds().width - 90;	112	widthHint = editorManager.getBounds().width - 90;
114	}	113	}
115	}	114	}
116		115

Lines 15-29 Link Here

(-)src/org/eclipse/mylyn/internal/context/ui/ContextEditorManager.java (-56 / +56 lines)
15	import java.io.StringReader;	15	import java.io.StringReader;
16	import java.io.StringWriter;	16	import java.io.StringWriter;
17	import java.util.ArrayList;	17	import java.util.ArrayList;
18	import java.util.Arrays;
19	import java.util.HashSet;
20	import java.util.List;	18	import java.util.List;
21	import java.util.Set;	19	import java.util.Set;
22		20
23	import org.eclipse.core.runtime.Assert;	21	import org.eclipse.core.runtime.Assert;
24	import org.eclipse.core.runtime.ISafeRunnable;	22	import org.eclipse.core.runtime.ISafeRunnable;
25	import org.eclipse.core.runtime.IStatus;	23	import org.eclipse.core.runtime.IStatus;
26	import org.eclipse.core.runtime.MultiStatus;
27	import org.eclipse.core.runtime.Status;	24	import org.eclipse.core.runtime.Status;
28	import org.eclipse.core.runtime.preferences.InstanceScope;	25	import org.eclipse.core.runtime.preferences.InstanceScope;
29	import org.eclipse.jface.preference.IPreferenceStore;	26	import org.eclipse.jface.preference.IPreferenceStore;
Lines 47-60 Link Here
47	import org.eclipse.ui.IEditorReference;	44	import org.eclipse.ui.IEditorReference;
48	import org.eclipse.ui.IMemento;	45	import org.eclipse.ui.IMemento;
49	import org.eclipse.ui.IWorkbenchPage;	46	import org.eclipse.ui.IWorkbenchPage;
50	import org.eclipse.ui.IWorkbenchPart;
51	import org.eclipse.ui.IWorkbenchWindow;	47	import org.eclipse.ui.IWorkbenchWindow;
52	import org.eclipse.ui.PartInitException;	48	import org.eclipse.ui.PartInitException;
53	import org.eclipse.ui.PlatformUI;	49	import org.eclipse.ui.PlatformUI;
54	import org.eclipse.ui.XMLMemento;	50	import org.eclipse.ui.XMLMemento;
55	import org.eclipse.ui.internal.EditorManager;
56	import org.eclipse.ui.internal.IPreferenceConstants;	51	import org.eclipse.ui.internal.IPreferenceConstants;
57	import org.eclipse.ui.internal.IWorkbenchConstants;
58	import org.eclipse.ui.internal.Workbench;	52	import org.eclipse.ui.internal.Workbench;
59	import org.eclipse.ui.internal.WorkbenchPage;	53	import org.eclipse.ui.internal.WorkbenchPage;
60	import org.eclipse.ui.internal.WorkbenchWindow;	54	import org.eclipse.ui.internal.WorkbenchWindow;
Lines 80-87 Link Here
80		74
81	private static final String ATTRIBUTE_IS_ACTIVE = "isActive"; //$NON-NLS-1$	75	private static final String ATTRIBUTE_IS_ACTIVE = "isActive"; //$NON-NLS-1$
82		76
83	private boolean previousCloseEditorsSetting = Workbench.getInstance().getPreferenceStore().getBoolean(	77	private boolean previousCloseEditorsSetting = Workbench.getInstance()
84	IPreferenceConstants.REUSE_EDITORS_BOOLEAN);	78	.getPreferenceStore()
		79	.getBoolean(IPreferenceConstants.REUSE_EDITORS_BOOLEAN);
85		80
86	private final IPreferenceStore preferenceStore;	81	private final IPreferenceStore preferenceStore;
87		82
Lines 119-126 Link Here
119		114
120	public void openEditorsFromMemento(IInteractionContext context) {	115	public void openEditorsFromMemento(IInteractionContext context) {
121	if (!Workbench.getInstance().isStarting()	116	if (!Workbench.getInstance().isStarting()
122	&& ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(	117	&& ContextUiPlugin.getDefault()
123	IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS) && !TaskMigrator.isActive()) {	118	.getPreferenceStore()
		119	.getBoolean(IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS) && !TaskMigrator.isActive()) {
124	Workbench workbench = (Workbench) PlatformUI.getWorkbench();	120	Workbench workbench = (Workbench) PlatformUI.getWorkbench();
125	previousCloseEditorsSetting = workbench.getPreferenceStore().getBoolean(	121	previousCloseEditorsSetting = workbench.getPreferenceStore().getBoolean(
126	IPreferenceConstants.REUSE_EDITORS_BOOLEAN);	122	IPreferenceConstants.REUSE_EDITORS_BOOLEAN);
Lines 232-239 Link Here
232		228
233	public void closeEditorsAndSaveMemento(IInteractionContext context) {	229	public void closeEditorsAndSaveMemento(IInteractionContext context) {
234	if (!PlatformUI.getWorkbench().isClosing()	230	if (!PlatformUI.getWorkbench().isClosing()
235	&& ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(	231	&& ContextUiPlugin.getDefault()
236	IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS) && !TaskMigrator.isActive()) {	232	.getPreferenceStore()
		233	.getBoolean(IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS) && !TaskMigrator.isActive()) {
237	closeAllButActiveTaskEditor(context.getHandleIdentifier());	234	closeAllButActiveTaskEditor(context.getHandleIdentifier());
238		235
239	XMLMemento rootMemento = XMLMemento.createWriteRoot(KEY_CONTEXT_EDITORS);	236	XMLMemento rootMemento = XMLMemento.createWriteRoot(KEY_CONTEXT_EDITORS);
Lines 253-259 Link Here
253	memento.putInteger(ATTRIBUTE_NUMER, number);	250	memento.putInteger(ATTRIBUTE_NUMER, number);
254	memento.putBoolean(ATTRIBUTE_IS_LAUNCHING, window == launchingWindow);	251	memento.putBoolean(ATTRIBUTE_IS_LAUNCHING, window == launchingWindow);
255	memento.putBoolean(ATTRIBUTE_IS_ACTIVE, window == activeWindow);	252	memento.putBoolean(ATTRIBUTE_IS_ACTIVE, window == activeWindow);
256	((WorkbenchPage) window.getActivePage()).getEditorManager().saveState(memento);	253	// ((WorkbenchPage) window.getActivePage()).getEditorManager().saveState(memento);
257	}	254	}
258	// TODO: avoid storing with preferences due to bloat?	255	// TODO: avoid storing with preferences due to bloat?
259	StringWriter writer = new StringWriter();	256	StringWriter writer = new StringWriter();
Lines 265-272 Link Here
265	e));	262	e));
266	}	263	}
267		264
268	Workbench.getInstance().getPreferenceStore().setValue(IPreferenceConstants.REUSE_EDITORS_BOOLEAN,	265	Workbench.getInstance()
269	previousCloseEditorsSetting);	266	.getPreferenceStore()
		267	.setValue(IPreferenceConstants.REUSE_EDITORS_BOOLEAN, previousCloseEditorsSetting);
270	closeAllEditors();	268	closeAllEditors();
271	}	269	}
272	}	270	}
Lines 292-299 Link Here
292	StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Could not store editor state", e)); //$NON-NLS-1$	290	StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Could not store editor state", e)); //$NON-NLS-1$
293	}	291	}
294		292
295	Workbench.getInstance().getPreferenceStore().setValue(IPreferenceConstants.REUSE_EDITORS_BOOLEAN,	293	Workbench.getInstance()
296	previousCloseEditorsSetting);	294	.getPreferenceStore()
		295	.setValue(IPreferenceConstants.REUSE_EDITORS_BOOLEAN, previousCloseEditorsSetting);
297	if (closeEditors) {	296	if (closeEditors) {
298	closeAllEditors();	297	closeAllEditors();
299	}	298	}
Lines 304-346 Link Here
304	*/	303	*/
305	@SuppressWarnings("unchecked")	304	@SuppressWarnings("unchecked")
306	private void restoreEditors(WorkbenchPage page, IMemento memento, boolean isActiveWindow) {	305	private void restoreEditors(WorkbenchPage page, IMemento memento, boolean isActiveWindow) {
307	EditorManager editorManager = page.getEditorManager();	306	// EditorManager editorManager = page.getEditorManager();
308	final ArrayList visibleEditors = new ArrayList(5);	307	// final ArrayList visibleEditors = new ArrayList(5);
309	final IEditorReference activeEditor[] = new IEditorReference[1];	308	// final IEditorReference activeEditor[] = new IEditorReference[1];
310	final MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK, "", null); //$NON-NLS-1$	309	// final MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK, "", null); //$NON-NLS-1$
311		310	//
312	try {	311	// try {
313	IMemento[] editorMementos = memento.getChildren(IWorkbenchConstants.TAG_EDITOR);	312	// IMemento[] editorMementos = memento.getChildren(IWorkbenchConstants.TAG_EDITOR);
314	Set<IMemento> editorMementoSet = new HashSet<IMemento>();	313	// Set<IMemento> editorMementoSet = new HashSet<IMemento>();
315	editorMementoSet.addAll(Arrays.asList(editorMementos));	314	// editorMementoSet.addAll(Arrays.asList(editorMementos));
316	// HACK: same parts could have different editors	315	// // HACK: same parts could have different editors
317	Set<String> restoredPartNames = new HashSet<String>();	316	// Set<String> restoredPartNames = new HashSet<String>();
318	List<IEditorReference> alreadyVisibleEditors = Arrays.asList(editorManager.getEditors());	317	// List<IEditorReference> alreadyVisibleEditors = Arrays.asList(editorManager.getEditors());
319	for (IEditorReference editorReference : alreadyVisibleEditors) {	318	// for (IEditorReference editorReference : alreadyVisibleEditors) {
320	restoredPartNames.add(editorReference.getPartName());	319	// restoredPartNames.add(editorReference.getPartName());
321	}	320	// }
322	for (IMemento editorMemento : editorMementoSet) {	321	// for (IMemento editorMemento : editorMementoSet) {
323	String partName = editorMemento.getString(IWorkbenchConstants.TAG_PART_NAME);	322	// String partName = editorMemento.getString(IWorkbenchConstants.TAG_PART_NAME);
324	if (!restoredPartNames.contains(partName)) {	323	// if (!restoredPartNames.contains(partName)) {
325	editorManager.restoreEditorState(editorMemento, visibleEditors, activeEditor, result);	324	// editorManager.restoreEditorState(editorMemento, visibleEditors, activeEditor, result);
326	} else {	325	// } else {
327	restoredPartNames.add(partName);	326	// restoredPartNames.add(partName);
328	}	327	// }
329	}	328	// }
330		329	//
331	for (int i = 0; i < visibleEditors.size(); i++) {	330	// for (int i = 0; i < visibleEditors.size(); i++) {
332	editorManager.setVisibleEditor((IEditorReference) visibleEditors.get(i), false);	331	// editorManager.setVisibleEditor((IEditorReference) visibleEditors.get(i), false);
333	}	332	// }
334		333	//
335	if (activeEditor[0] != null && isActiveWindow) {	334	// if (activeEditor[0] != null && isActiveWindow) {
336	IWorkbenchPart editor = activeEditor[0].getPart(true);	335	// IWorkbenchPart editor = activeEditor[0].getPart(true);
337	if (editor != null) {	336	// if (editor != null) {
338	page.activate(editor);	337	// page.activate(editor);
339	}	338	// }
340	}	339	// }
341	} catch (Exception e) {	340	// } catch (Exception e) {
342	StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Could not restore editors", e)); //$NON-NLS-1$	341	// StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Could not restore editors", e)); //$NON-NLS-1$
343	}	342	// }
344	}	343	}
345		344
346	public void closeAllButActiveTaskEditor(String taskHandle) {	345	public void closeAllButActiveTaskEditor(String taskHandle) {
Lines 429-436 Link Here
429	}	428	}
430		429
431	private void closeEditor(IInteractionElement element, boolean force) {	430	private void closeEditor(IInteractionElement element, boolean force) {
432	if (ContextUiPlugin.getDefault().getPreferenceStore().getBoolean(	431	if (ContextUiPlugin.getDefault()
433	IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS)) {	432	.getPreferenceStore()
		433	.getBoolean(IContextUiPreferenceContstants.AUTO_MANAGE_EDITORS)) {
434	if (force \|\| !element.getInterest().isInteresting()) {	434	if (force \|\| !element.getInterest().isInteresting()) {
435	AbstractContextStructureBridge bridge = ContextCore.getStructureBridge(element.getContentType());	435	AbstractContextStructureBridge bridge = ContextCore.getStructureBridge(element.getContentType());
436	if (bridge.isDocument(element.getHandleIdentifier())) {	436	if (bridge.isDocument(element.getHandleIdentifier())) {

Lines 1-240 Link Here

(-)src/org/eclipse/mylyn/monitor/tests/MultiWindowMonitorTest.java (-240 / +240 lines)
1	/*******************************************************************************	1	///*******************************************************************************
2	* Copyright (c) 2004, 2009 Tasktop Technologies and others.	2	// * Copyright (c) 2004, 2009 Tasktop Technologies and others.
3	* All rights reserved. This program and the accompanying materials	3	// * All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	// * are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	// * which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	// * http://www.eclipse.org/legal/epl-v10.html
7	*	7	// *
8	* Contributors:	8	// * Contributors:
9	* Brian de Alwis - initial API and implementation	9	// * Brian de Alwis - initial API and implementation
10	* Tasktop Technologies - improvements	10	// * Tasktop Technologies - improvements
11	*******************************************************************************/	11	// *******************************************************************************/
12		12	//
13	package org.eclipse.mylyn.monitor.tests;	13	//package org.eclipse.mylyn.monitor.tests;
14		14	//
15	import java.io.File;	15	//import java.io.File;
16	import java.io.IOException;	16	//import java.io.IOException;
17	import java.lang.reflect.Field;	17	//import java.lang.reflect.Field;
18	import java.lang.reflect.Method;	18	//import java.lang.reflect.Method;
19		19	//
20	import junit.framework.TestCase;	20	//import junit.framework.TestCase;
21		21	//
22	import org.eclipse.core.runtime.IStatus;	22	//import org.eclipse.core.runtime.IStatus;
23	import org.eclipse.jface.viewers.StructuredSelection;	23	//import org.eclipse.jface.viewers.StructuredSelection;
24	import org.eclipse.jface.window.Window;	24	//import org.eclipse.jface.window.Window;
25	import org.eclipse.jface.window.WindowManager;	25	//import org.eclipse.jface.window.WindowManager;
26	import org.eclipse.mylyn.internal.monitor.ui.IMonitoredWindow;	26	//import org.eclipse.mylyn.internal.monitor.ui.IMonitoredWindow;
27	import org.eclipse.mylyn.internal.monitor.ui.MonitorUiPlugin;	27	//import org.eclipse.mylyn.internal.monitor.ui.MonitorUiPlugin;
28	import org.eclipse.mylyn.internal.monitor.usage.InteractionEventLogger;	28	//import org.eclipse.mylyn.internal.monitor.usage.InteractionEventLogger;
29	import org.eclipse.mylyn.internal.monitor.usage.UiUsageMonitorPlugin;	29	//import org.eclipse.mylyn.internal.monitor.usage.UiUsageMonitorPlugin;
30	import org.eclipse.ui.IMemento;	30	//import org.eclipse.ui.IMemento;
31	import org.eclipse.ui.IWorkbenchWindow;	31	//import org.eclipse.ui.IWorkbenchWindow;
32	import org.eclipse.ui.PlatformUI;	32	//import org.eclipse.ui.PlatformUI;
33	import org.eclipse.ui.XMLMemento;	33	//import org.eclipse.ui.XMLMemento;
34	import org.eclipse.ui.internal.IWorkbenchConstants;	34	//import org.eclipse.ui.internal.IWorkbenchConstants;
35	import org.eclipse.ui.internal.Workbench;	35	//import org.eclipse.ui.internal.Workbench;
36	import org.eclipse.ui.internal.WorkbenchWindow;	36	//import org.eclipse.ui.internal.WorkbenchWindow;
37		37	//
38	/**	38	///**
39	* @author Brian de Alwis	39	// * @author Brian de Alwis
40	* @author Mik Kersten	40	// * @author Mik Kersten
41	* @author Shawn Minto	41	// * @author Shawn Minto
42	*/	42	// */
43	public class MultiWindowMonitorTest extends TestCase {	43	//public class MultiWindowMonitorTest extends TestCase {
44		44	//
45	private class ContextAwareWorkbenchWindow extends WorkbenchWindow implements IMonitoredWindow {	45	// private class ContextAwareWorkbenchWindow extends WorkbenchWindow implements IMonitoredWindow {
46		46	//
47	private boolean monitored = true;	47	// private boolean monitored = true;
48		48	//
49	public ContextAwareWorkbenchWindow(int number, boolean monitored) {	49	// public ContextAwareWorkbenchWindow(int number, boolean monitored) {
50	super(number);	50	// super(number);
51	this.monitored = monitored;	51	// this.monitored = monitored;
52	}	52	// }
53		53	//
54	public boolean isMonitored() {	54	// public boolean isMonitored() {
55	return monitored;	55	// return monitored;
56	}	56	// }
57		57	//
58	public boolean isPerspectiveManaged() {	58	// public boolean isPerspectiveManaged() {
59	return false;	59	// return false;
60	}	60	// }
61	}	61	// }
62		62	//
63	private class MockWorkbench {	63	// private class MockWorkbench {
64	private final Workbench wBench;	64	// private final Workbench wBench;
65		65	//
66	private WindowManager parentManager = null;	66	// private WindowManager parentManager = null;
67		67	//
68	private MockWorkbench() {	68	// private MockWorkbench() {
69	wBench = Workbench.getInstance();	69	// wBench = Workbench.getInstance();
70		70	//
71	Field wManagerField;	71	// Field wManagerField;
72	try {	72	// try {
73	wManagerField = Workbench.class.getDeclaredField("windowManager");	73	// wManagerField = Workbench.class.getDeclaredField("windowManager");
74	wManagerField.setAccessible(true);	74	// wManagerField.setAccessible(true);
75	parentManager = (WindowManager) wManagerField.get(wBench);	75	// parentManager = (WindowManager) wManagerField.get(wBench);
76		76	//
77	} catch (Exception e) {	77	// } catch (Exception e) {
78	}	78	// }
79	}	79	// }
80		80	//
81	private int getNewWindowNumber() {	81	// private int getNewWindowNumber() {
82	Window[] windows = parentManager.getWindows();	82	// Window[] windows = parentManager.getWindows();
83	int count = windows.length;	83	// int count = windows.length;
84		84	//
85	boolean checkArray[] = new boolean[count];	85	// boolean checkArray[] = new boolean[count];
86	for (int nX = 0; nX < count; nX++) {	86	// for (int nX = 0; nX < count; nX++) {
87	if (windows[nX] instanceof WorkbenchWindow) {	87	// if (windows[nX] instanceof WorkbenchWindow) {
88	WorkbenchWindow ww = (WorkbenchWindow) windows[nX];	88	// WorkbenchWindow ww = (WorkbenchWindow) windows[nX];
89	int index = ww.getNumber() - 1;	89	// int index = ww.getNumber() - 1;
90	if (index >= 0 && index < count) {	90	// if (index >= 0 && index < count) {
91	checkArray[index] = true;	91	// checkArray[index] = true;
92	}	92	// }
93	}	93	// }
94	}	94	// }
95		95	//
96	for (int index = 0; index < count; index++) {	96	// for (int index = 0; index < count; index++) {
97	if (!checkArray[index]) {	97	// if (!checkArray[index]) {
98	return index + 1;	98	// return index + 1;
99	}	99	// }
100	}	100	// }
101	return count + 1;	101	// return count + 1;
102	}	102	// }
103		103	//
104	private ContextAwareWorkbenchWindow newWorkbenchWindow(boolean isMonitored) {	104	// private ContextAwareWorkbenchWindow newWorkbenchWindow(boolean isMonitored) {
105	return new ContextAwareWorkbenchWindow(getNewWindowNumber(), isMonitored);	105	// return new ContextAwareWorkbenchWindow(getNewWindowNumber(), isMonitored);
106	}	106	// }
107		107	//
108	public ContextAwareWorkbenchWindow restoreState(IMemento memento, boolean isMonitored) {	108	// public ContextAwareWorkbenchWindow restoreState(IMemento memento, boolean isMonitored) {
109		109	//
110	ContextAwareWorkbenchWindow newWindow = newWorkbenchWindow(isMonitored);	110	// ContextAwareWorkbenchWindow newWindow = newWorkbenchWindow(isMonitored);
111	newWindow.create();	111	// newWindow.create();
112		112	//
113	parentManager.add(newWindow);	113	// parentManager.add(newWindow);
114		114	//
115	boolean opened = false;	115	// boolean opened = false;
116		116	//
117	try {	117	// try {
118	newWindow.restoreState(memento, null);	118	// newWindow.restoreState(memento, null);
119	newWindow.open();	119	// newWindow.open();
120	opened = true;	120	// opened = true;
121	} finally {	121	// } finally {
122	if (!opened) {	122	// if (!opened) {
123	newWindow.close();	123	// newWindow.close();
124	}	124	// }
125	}	125	// }
126		126	//
127	return newWindow;	127	// return newWindow;
128	}	128	// }
129	}	129	// }
130		130	//
131	private final InteractionEventLogger logger = UiUsageMonitorPlugin.getDefault().getInteractionLogger();	131	// private final InteractionEventLogger logger = UiUsageMonitorPlugin.getDefault().getInteractionLogger();
132		132	//
133	private MockSelectionMonitor selectionMonitor;	133	// private MockSelectionMonitor selectionMonitor;
134		134	//
135	private IWorkbenchWindow window1;	135	// private IWorkbenchWindow window1;
136		136	//
137	private IWorkbenchWindow window2;	137	// private IWorkbenchWindow window2;
138		138	//
139	private IWorkbenchWindow window3;	139	// private IWorkbenchWindow window3;
140		140	//
141	private IWorkbenchWindow window4;	141	// private IWorkbenchWindow window4;
142		142	//
143	private boolean monitoringWasEnabled;	143	// private boolean monitoringWasEnabled;
144		144	//
145	@Override	145	// @Override
146	protected void setUp() throws Exception {	146	// protected void setUp() throws Exception {
147	super.setUp();	147	// super.setUp();
148	selectionMonitor = new MockSelectionMonitor();	148	// selectionMonitor = new MockSelectionMonitor();
149	monitoringWasEnabled = UiUsageMonitorPlugin.getDefault().isMonitoringEnabled();	149	// monitoringWasEnabled = UiUsageMonitorPlugin.getDefault().isMonitoringEnabled();
150	UiUsageMonitorPlugin.getDefault().stopMonitoring();	150	// UiUsageMonitorPlugin.getDefault().stopMonitoring();
151		151	//
152	// make sure the MonitorUiPlugin is fully initialized	152	// // make sure the MonitorUiPlugin is fully initialized
153	while (PlatformUI.getWorkbench().getDisplay().readAndDispatch()) {	153	// while (PlatformUI.getWorkbench().getDisplay().readAndDispatch()) {
154	}	154	// }
155		155	//
156	window1 = PlatformUI.getWorkbench().getActiveWorkbenchWindow();	156	// window1 = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
157	assertTrue(MonitorUiPlugin.getDefault().getMonitoredWindows().contains(window1));	157	// assertTrue(MonitorUiPlugin.getDefault().getMonitoredWindows().contains(window1));
158	window2 = duplicateWindow(window1);	158	// window2 = duplicateWindow(window1);
159	assertNotNull(window2);	159	// assertNotNull(window2);
160	assertTrue(MonitorUiPlugin.getDefault().getMonitoredWindows().contains(window2));	160	// assertTrue(MonitorUiPlugin.getDefault().getMonitoredWindows().contains(window2));
161	window3 = createContextAwareWindow(true, window1);	161	// window3 = createContextAwareWindow(true, window1);
162	assertNotNull(window3);	162	// assertNotNull(window3);
163	assertTrue(MonitorUiPlugin.getDefault().getMonitoredWindows().contains(window3));	163	// assertTrue(MonitorUiPlugin.getDefault().getMonitoredWindows().contains(window3));
164	window4 = createContextAwareWindow(false, window1);	164	// window4 = createContextAwareWindow(false, window1);
165	assertNotNull(window4);	165	// assertNotNull(window4);
166	assertFalse(MonitorUiPlugin.getDefault().getMonitoredWindows().contains(window4));	166	// assertFalse(MonitorUiPlugin.getDefault().getMonitoredWindows().contains(window4));
167	}	167	// }
168		168	//
169	@Override	169	// @Override
170	protected void tearDown() throws Exception {	170	// protected void tearDown() throws Exception {
171	super.tearDown();	171	// super.tearDown();
172	window2.close();	172	// window2.close();
173	window3.close();	173	// window3.close();
174	window4.close();	174	// window4.close();
175	if (monitoringWasEnabled) {	175	// if (monitoringWasEnabled) {
176	UiUsageMonitorPlugin.getDefault().startMonitoring();	176	// UiUsageMonitorPlugin.getDefault().startMonitoring();
177	}	177	// }
178	if (selectionMonitor != null) {	178	// if (selectionMonitor != null) {
179	selectionMonitor.dispose();	179	// selectionMonitor.dispose();
180	}	180	// }
181	}	181	// }
182		182	//
183	protected void generateSelection(IWorkbenchWindow w) {	183	// protected void generateSelection(IWorkbenchWindow w) {
184	selectionMonitor.selectionChanged(w.getActivePage().getActivePart(), new StructuredSelection("yo"));	184	// selectionMonitor.selectionChanged(w.getActivePage().getActivePart(), new StructuredSelection("yo"));
185	}	185	// }
186		186	//
187	public void testMultipleWindows() throws IOException {	187	// public void testMultipleWindows() throws IOException {
188	File monitorFile = UiUsageMonitorPlugin.getDefault().getMonitorLogFile();	188	// File monitorFile = UiUsageMonitorPlugin.getDefault().getMonitorLogFile();
189	logger.clearInteractionHistory();	189	// logger.clearInteractionHistory();
190	assertEquals(0, logger.getHistoryFromFile(monitorFile).size());	190	// assertEquals(0, logger.getHistoryFromFile(monitorFile).size());
191		191	//
192	generateSelection(window1);	192	// generateSelection(window1);
193	assertEquals(0, logger.getHistoryFromFile(monitorFile).size());	193	// assertEquals(0, logger.getHistoryFromFile(monitorFile).size());
194		194	//
195	UiUsageMonitorPlugin.getDefault().startMonitoring();	195	// UiUsageMonitorPlugin.getDefault().startMonitoring();
196	generateSelection(window1);	196	// generateSelection(window1);
197	generateSelection(window2);	197	// generateSelection(window2);
198	generateSelection(window3);	198	// generateSelection(window3);
199	generateSelection(window4);	199	// generateSelection(window4);
200	assertEquals(3, logger.getHistoryFromFile(monitorFile).size());	200	// assertEquals(3, logger.getHistoryFromFile(monitorFile).size());
201	}	201	// }
202		202	//
203	protected IWorkbenchWindow duplicateWindow(IWorkbenchWindow window) {	203	// protected IWorkbenchWindow duplicateWindow(IWorkbenchWindow window) {
204	WorkbenchWindow w = (WorkbenchWindow) window;	204	// WorkbenchWindow w = (WorkbenchWindow) window;
205	XMLMemento memento = XMLMemento.createWriteRoot(IWorkbenchConstants.TAG_WINDOW);	205	// XMLMemento memento = XMLMemento.createWriteRoot(IWorkbenchConstants.TAG_WINDOW);
206	IStatus status = w.saveState(memento);	206	// IStatus status = w.saveState(memento);
207	if (!status.isOK()) {	207	// if (!status.isOK()) {
208	fail("failed to duplicate window: " + status);	208	// fail("failed to duplicate window: " + status);
209	}	209	// }
210	return restoreWorkbenchWindow((Workbench) w.getWorkbench(), memento);	210	// return restoreWorkbenchWindow((Workbench) w.getWorkbench(), memento);
211	}	211	// }
212		212	//
213	private IWorkbenchWindow createContextAwareWindow(boolean monitored, IWorkbenchWindow window) {	213	// private IWorkbenchWindow createContextAwareWindow(boolean monitored, IWorkbenchWindow window) {
214	WorkbenchWindow w = (WorkbenchWindow) window;	214	// WorkbenchWindow w = (WorkbenchWindow) window;
215	XMLMemento memento = XMLMemento.createWriteRoot(IWorkbenchConstants.TAG_WINDOW);	215	// XMLMemento memento = XMLMemento.createWriteRoot(IWorkbenchConstants.TAG_WINDOW);
216	IStatus status = w.saveState(memento);	216	// IStatus status = w.saveState(memento);
217	if (!status.isOK()) {	217	// if (!status.isOK()) {
218	fail("failed to duplicate window: " + status);	218	// fail("failed to duplicate window: " + status);
219	}	219	// }
220	return new MockWorkbench().restoreState(memento, monitored);	220	// return new MockWorkbench().restoreState(memento, monitored);
221	}	221	// }
222		222	//
223	protected IWorkbenchWindow restoreWorkbenchWindow(Workbench workbench, IMemento memento) {	223	// protected IWorkbenchWindow restoreWorkbenchWindow(Workbench workbench, IMemento memento) {
224	return (IWorkbenchWindow) invokeMethod(workbench, "restoreWorkbenchWindow", new Class[] { IMemento.class },	224	// return (IWorkbenchWindow) invokeMethod(workbench, "restoreWorkbenchWindow", new Class[] { IMemento.class },
225	new Object[] { memento });	225	// new Object[] { memento });
226	}	226	// }
227		227	//
228	protected Object invokeMethod(Object instance, String methodName, Class<?> argTypes[], Object arguments[]) {	228	// protected Object invokeMethod(Object instance, String methodName, Class<?> argTypes[], Object arguments[]) {
229	Class<?> clas = instance.getClass();	229	// Class<?> clas = instance.getClass();
230	try {	230	// try {
231	Method method = clas.getDeclaredMethod(methodName, argTypes);	231	// Method method = clas.getDeclaredMethod(methodName, argTypes);
232	method.setAccessible(true);	232	// method.setAccessible(true);
233	return method.invoke(instance, arguments);	233	// return method.invoke(instance, arguments);
234	} catch (Exception ex) {	234	// } catch (Exception ex) {
235	fail("exception during reflective invocation of " + clas.getName() + "." + methodName + ": " + ex);	235	// fail("exception during reflective invocation of " + clas.getName() + "." + methodName + ": " + ex);
236	return null;	236	// return null;
237	}	237	// }
238	}	238	// }
239		239	//
240	}	240	//}

Lines 33-43 Link Here

(-)src/org/eclipse/mylyn/sandbox/tests/ActiveSearchTest.java (-3 / +3 lines)
33	import org.eclipse.mylyn.java.tests.AbstractJavaContextTest;	33	import org.eclipse.mylyn.java.tests.AbstractJavaContextTest;
34	import org.eclipse.mylyn.java.tests.search.SearchPluginTestHelper;	34	import org.eclipse.mylyn.java.tests.search.SearchPluginTestHelper;
35	import org.eclipse.swt.widgets.TreeItem;	35	import org.eclipse.swt.widgets.TreeItem;
		36	import org.eclipse.ui.IPerspectiveDescriptor;
36	import org.eclipse.ui.IViewReference;	37	import org.eclipse.ui.IViewReference;
37	import org.eclipse.ui.IWorkbenchPart;	38	import org.eclipse.ui.IWorkbenchPart;
38	import org.eclipse.ui.PartInitException;	39	import org.eclipse.ui.PartInitException;
39	import org.eclipse.ui.PlatformUI;	40	import org.eclipse.ui.PlatformUI;
40	import org.eclipse.ui.internal.Perspective;
41	import org.eclipse.ui.internal.WorkbenchPage;	41	import org.eclipse.ui.internal.WorkbenchPage;
42		42
43	/**	43	/**
Lines 93-103 Link Here
93	}	93	}
94	JavaPlugin.getActivePage().showView("org.eclipse.ui.views.ProblemView");	94	JavaPlugin.getActivePage().showView("org.eclipse.ui.views.ProblemView");
95		95
96	Perspective perspective = ((WorkbenchPage) JavaPlugin.getActivePage()).getActivePerspective();	96	IPerspectiveDescriptor perspective = ((WorkbenchPage) JavaPlugin.getActivePage()).getPerspective();
97	IViewReference reference = JavaPlugin.getActivePage().findViewReference(ActiveSearchView.ID);	97	IViewReference reference = JavaPlugin.getActivePage().findViewReference(ActiveSearchView.ID);
98	assertNotNull(reference);	98	assertNotNull(reference);
99	// assertTrue(perspective.canCloseView(view));	99	// assertTrue(perspective.canCloseView(view));
100	assertTrue(perspective.hideView(reference));	100	// assertTrue(perspective.hideView(reference));
101		101
102	for (AbstractRelationProvider provider : ContextCorePlugin.getDefault().getRelationProviders()) {	102	for (AbstractRelationProvider provider : ContextCorePlugin.getDefault().getRelationProviders()) {
103	assertFalse(provider.isEnabled());	103	assertFalse(provider.isEnabled());

Lines 11-23 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/PlanningPerspectiveFactory.java (-7 / +4 lines)
11		11
12	package org.eclipse.mylyn.internal.tasks.ui;	12	package org.eclipse.mylyn.internal.tasks.ui;
13		13
14	import java.util.ArrayList;
15
16	import org.eclipse.mylyn.tasks.ui.ITasksUiConstants;	14	import org.eclipse.mylyn.tasks.ui.ITasksUiConstants;
17	import org.eclipse.ui.IFolderLayout;	15	import org.eclipse.ui.IFolderLayout;
18	import org.eclipse.ui.IPageLayout;	16	import org.eclipse.ui.IPageLayout;
19	import org.eclipse.ui.IPerspectiveFactory;	17	import org.eclipse.ui.IPerspectiveFactory;
20	import org.eclipse.ui.internal.PageLayout;
21		18
22	/**	19	/**
23	* @author Mik Kersten	20	* @author Mik Kersten
Lines 60-68 Link Here
60	}	57	}
61		58
62	public static void removeUninterestingActionSets(IPageLayout layout) {	59	public static void removeUninterestingActionSets(IPageLayout layout) {
63	ArrayList<?> actionSets = ((PageLayout) layout).getActionSets();	60	// ArrayList<?> actionSets = (layout).getActionSets();
64	actionSets.remove("org.eclipse.ui.edit.text.actionSet.annotationNavigation"); //$NON-NLS-1$	61	// actionSets.remove("org.eclipse.ui.edit.text.actionSet.annotationNavigation"); //$NON-NLS-1$
65	actionSets.remove("org.eclipse.ui.edit.text.actionSet.convertLineDelimitersTo"); //$NON-NLS-1$	62	// actionSets.remove("org.eclipse.ui.edit.text.actionSet.convertLineDelimitersTo"); //$NON-NLS-1$
66	actionSets.remove("org.eclipse.ui.externaltools.ExternalToolsSet"); //$NON-NLS-1$	63	// actionSets.remove("org.eclipse.ui.externaltools.ExternalToolsSet"); //$NON-NLS-1$
67	}	64	}
68	}	65	}