WorkbenchContentsFinder.java

/*******************************************************************************
 * Copyright (c) 2009 SWTBot Committers and others
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     Ralf Ebert www.ralfebert.de - (bug 271630) SWTBot Improved RCP / Workbench support
 *******************************************************************************/
package org.eclipse.swtbot.eclipse.finder.finders;

import static org.eclipse.swtbot.swt.finder.finders.UIThreadRunnable.syncExec;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.swtbot.swt.finder.results.ListResult;
import org.eclipse.swtbot.swt.finder.results.Result;
import org.eclipse.swtbot.swt.finder.utils.SWTUtils;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IViewReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.hamcrest.Matcher;

/**
 * WorkbenchContentsFinder allows to access the contents of a workbench window (views, editors, pages etc).
 * 
 * @author Ralf Ebert www.ralfebert.de (bug 271630)
 * @noextend This class is not intended to be subclassed by clients.
 * @noinstantiate This class is not intended to be instantiated by clients.
 */
public class WorkbenchContentsFinder {

	/**
	 * @return the active workbench window.
	 */
	public IWorkbenchWindow activeWorkbenchWindow() {
		return syncExec(new Result<IWorkbenchWindow>() {
			public IWorkbenchWindow run() {
				return PlatformUI.getWorkbench().getActiveWorkbenchWindow();
			}
		});
	}

	/**
	 * @param matcher the matcher used to match editors.
	 * @return the matching editors.
	 */
	public List<IEditorReference> findEditors(final Matcher<?> matcher) {
		return syncExec(SWTUtils.display(), new ListResult<IEditorReference>() {
			public List<IEditorReference> run() {
				return findEditorsInternal(matcher);
			}

		});
	}

	/**
	 * @param matcher the matcher used to match views
	 * @return the list of matching views
	 */
	public List<IViewReference> findViews(final Matcher<?> matcher) {
		return syncExec(SWTUtils.display(), new ListResult<IViewReference>() {
			public List<IViewReference> run() {
				return findViewsInternal(matcher);
			}
		});
	}

	/**
	 * @param matcher the matcher used to match perspectives
	 * @return the list of matching perspectives
	 */
	public List<IPerspectiveDescriptor> findPerspectives(final Matcher<?> matcher) {
		return syncExec(SWTUtils.display(), new ListResult<IPerspectiveDescriptor>() {
			public List<IPerspectiveDescriptor> run() {
				return findPerspectivesInternal(matcher);
			}
		});

	}

	private List<IViewReference> findViewsInternal(final Matcher<?> matcher) {
		List<IViewReference> result = new ArrayList<IViewReference>();
		IWorkbenchPage[] pages = workbenchPages();
		for (IWorkbenchPage page : pages) {
			IViewReference[] viewReferences = page.getViewReferences();
			for (IViewReference viewReference : viewReferences) {
				if (matcher.matches(viewReference))
					result.add(viewReference);
			}
		}
		return result;
	}

	private List<IPerspectiveDescriptor> findPerspectivesInternal(final Matcher<?> matcher) {
		IPerspectiveDescriptor[] perspectives = activeWorkbenchWindow().getWorkbench().getPerspectiveRegistry().getPerspectives();
		List<IPerspectiveDescriptor> matchingPerspectives = new ArrayList<IPerspectiveDescriptor>();
		for (IPerspectiveDescriptor perspectiveDescriptor : perspectives)
			if (matcher.matches(perspectiveDescriptor))
				matchingPerspectives.add(perspectiveDescriptor);
		return matchingPerspectives;
	}

	private List<IEditorReference> findEditorsInternal(final Matcher<?> matcher) {
		List<IEditorReference> result = new ArrayList<IEditorReference>();
		IWorkbenchPage[] pages = workbenchPages();
		for (IWorkbenchPage page : pages) {
			IEditorReference[] editorReferences = page.getEditorReferences();
			for (IEditorReference editorReference : editorReferences) {
				if (matcher.matches(editorReference))
					result.add(editorReference);
			}
		}
		return result;
	}

	/**
	 * @return the active view.
	 */
	public IViewReference findActiveView() {
		return syncExec(new Result<IViewReference>() {
			public IViewReference run() {
				return findActiveViewInternal();
			}
		});
	}

	private IViewReference findActiveViewInternal() {
		IWorkbenchPartReference partReference = activePageInternal().getActivePartReference();
		if (partReference instanceof IViewReference)
			return (IViewReference) partReference;
		return null;
	}

	/**
	 * @return the active perspective.
	 */
	public IPerspectiveDescriptor findActivePerspective() {
		return syncExec(new Result<IPerspectiveDescriptor>() {
			public IPerspectiveDescriptor run() {
				return findActivePerspectiveInternal();
			}
		});
	}

	/**
	 * @return the active editor.
	 */
	public IEditorReference findActiveEditor() {
		return syncExec(new Result<IEditorReference>() {
			public IEditorReference run() {
				return findActiveEditorInternal();
			}
		});
	}

	private IWorkbenchPage[] workbenchPages() {
		return activeWorkbenchWindow().getPages();
	}

	private IEditorReference findActiveEditorInternal() {
		IWorkbenchPage page = activePageInternal();
		IEditorPart activeEditor = page.getActiveEditor();
		return (IEditorReference) page.getReference(activeEditor);
	}

	private IPerspectiveDescriptor findActivePerspectiveInternal() {
		return activePageInternal().getPerspective();
	}

	private IWorkbenchPage activePageInternal() {
		return activeWorkbenchWindow().getActivePage();
	}
}