core/plugins/org.eclipse.dltk.ui/src/org/eclipse/dltk/internal/ui/search/DLTKSearchScopeFactory.java - dltk/org.eclipse.dltk.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2018 IBM Corporation 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
  *
  *******************************************************************************/
 package org.eclipse.dltk.internal.ui.search;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;

 import org.eclipse.core.resources.IFolder;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.IWorkspaceRoot;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.dltk.core.DLTKCore;
 import org.eclipse.dltk.core.IBuildpathContainer;
 import org.eclipse.dltk.core.IBuildpathEntry;
 import org.eclipse.dltk.core.IDLTKLanguageToolkit;
 import org.eclipse.dltk.core.IModelElement;
 import org.eclipse.dltk.core.IProjectFragment;
 import org.eclipse.dltk.core.IScriptFolder;
 import org.eclipse.dltk.core.IScriptProject;
 import org.eclipse.dltk.core.IType;
 import org.eclipse.dltk.core.ModelException;
 import org.eclipse.dltk.core.search.IDLTKSearchScope;
 import org.eclipse.dltk.core.search.SearchEngine;
 import org.eclipse.dltk.internal.corext.util.Messages;
 import org.eclipse.dltk.internal.ui.browsing.LogicalPackage;
 import org.eclipse.dltk.ui.DLTKUIPlugin;
 import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.jface.viewers.IStructuredSelection;
 import org.eclipse.jface.window.Window;
 import org.eclipse.swt.widgets.Shell;
 import org.eclipse.ui.IEditorInput;
 import org.eclipse.ui.IWorkingSet;
 import org.eclipse.ui.PlatformUI;
 import org.eclipse.ui.dialogs.IWorkingSetSelectionDialog;

 public class DLTKSearchScopeFactory {

 	private static DLTKSearchScopeFactory fgInstance;
 	private final IDLTKSearchScope EMPTY_SCOPE = SearchEngine
 			.createSearchScope(new IModelElement[] {}, null);

 	private DLTKSearchScopeFactory() {
 	}

 	public static synchronized DLTKSearchScopeFactory getInstance() {
 		if (fgInstance == null)
 			fgInstance = new DLTKSearchScopeFactory();
 		return fgInstance;
 	}

 	public IWorkingSet[] queryWorkingSets() throws ModelException {
 		Shell shell = DLTKUIPlugin.getActiveWorkbenchShell();
 		if (shell == null)
 			return null;
 		IWorkingSetSelectionDialog dialog = PlatformUI.getWorkbench()
 				.getWorkingSetManager()
 				.createWorkingSetSelectionDialog(shell, true);
 		if (dialog.open() == Window.OK) {
 			IWorkingSet[] workingSets = dialog.getSelection();
 			if (workingSets.length > 0)
 				return workingSets;
 		}
 		return null;
 	}

 	public IDLTKSearchScope createSearchScope(IWorkingSet[] workingSets,
 			boolean includeInterp, IDLTKLanguageToolkit toolkit) {
 		if (workingSets == null || workingSets.length < 1)
 			return EMPTY_SCOPE;

 		Set modelElements = new HashSet(workingSets.length * 10);
 		for (int i = 0; i < workingSets.length; i++) {
 			IWorkingSet workingSet = workingSets[i];
 			if (workingSet.isEmpty() && workingSet.isAggregateWorkingSet()) {
 				return createWorkspaceScope(includeInterp, toolkit);
 			}
 			addModelElements(modelElements, workingSet);
 		}
 		return createSearchScope(modelElements, includeInterp, toolkit);
 	}

 	public IDLTKSearchScope createSearchScope(IWorkingSet workingSet,
 			boolean includeInterp, IDLTKLanguageToolkit toolkit) {
 		Set modelElements = new HashSet(10);
 		if (workingSet.isEmpty() && workingSet.isAggregateWorkingSet()) {
 			return createWorkspaceScope(includeInterp, toolkit);
 		}
 		addModelElements(modelElements, workingSet);
 		return createSearchScope(modelElements, includeInterp, toolkit);
 	}

 	public IDLTKSearchScope createSearchScope(IResource[] resources,
 			boolean includeInterp, IDLTKLanguageToolkit toolkit) {
 		if (resources == null)
 			return EMPTY_SCOPE;
 		Set modelElements = new HashSet(resources.length);
 		addModelElements(modelElements, resources);
 		return createSearchScope(modelElements, includeInterp, toolkit);
 	}

 	public IDLTKSearchScope createSearchScope(ISelection selection,
 			boolean includeInterp, IDLTKLanguageToolkit toolkit) {
 		return createSearchScope(getModelElements(selection), includeInterp,
 				toolkit);
 	}

 	public IDLTKSearchScope createProjectSearchScope(String[] projectNames,
 			boolean includeInterp, IDLTKLanguageToolkit toolkit) {
 		ArrayList res = new ArrayList();
 		IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
 		for (int i = 0; i < projectNames.length; i++) {
 			IScriptProject project = DLTKCore
 					.create(root.getProject(projectNames[i]));
 			if (project.exists()) {
 				res.add(project);
 			}
 		}
 		return createSearchScope(res, includeInterp, toolkit);
 	}

 	public IDLTKSearchScope createProjectSearchScope(IScriptProject project,
 			boolean includeInterp) {
 		return SearchEngine.createSearchScope(project,
 				getSearchFlags(includeInterp));
 	}

 	public IDLTKSearchScope createProjectSearchScope(IEditorInput editorInput,
 			boolean includeInterp) {
 		IModelElement elem = DLTKUIPlugin
 				.getEditorInputModelElement(editorInput);
 		if (elem != null) {
 			IScriptProject project = elem.getScriptProject();
 			if (project != null) {
 				return createProjectSearchScope(project, includeInterp);
 			}
 		}
 		return EMPTY_SCOPE;
 	}

 	public String getWorkspaceScopeDescription(boolean includeInterp) {
 		return includeInterp ? SearchMessages.WorkspaceScope
 				: SearchMessages.WorkspaceScopeNoInterpreterEnvironment;
 	}

 	public String getProjectScopeDescription(String[] projectNames,
 			boolean includeInterp) {
 		if (projectNames.length == 0) {
 			return SearchMessages.DLTKSearchScopeFactory_undefined_projects;
 		}
 		String scopeDescription;
 		if (projectNames.length == 1) {
 			String label = includeInterp ? SearchMessages.EnclosingProjectScope
 					: SearchMessages.EnclosingProjectScopeNoInterpreterEnvironment;
 			scopeDescription = Messages.format(label, projectNames[0]);
 		} else if (projectNames.length == 2) {
 			String label = includeInterp
 					? SearchMessages.EnclosingProjectsScope2
 					: SearchMessages.EnclosingProjectsScope2NoInterpreterEnvironment;
 			scopeDescription = Messages.format(label, projectNames[0],
 					projectNames[1]);
 		} else {
 			String label = includeInterp ? SearchMessages.EnclosingProjectsScope
 					: SearchMessages.EnclosingProjectsScopeNoInterpreterEnvironment;
 			scopeDescription = Messages.format(label, projectNames[0],
 					projectNames[1]);
 		}
 		return scopeDescription;
 	}

 	public String getProjectScopeDescription(IScriptProject project,
 			boolean includeInterp) {
 		if (includeInterp) {
 			return Messages.format(SearchMessages.ProjectScope,
 					project.getElementName());
 		}
 		return Messages.format(
 				SearchMessages.ProjectScopeNoInterpreterEnvironment,
 				project.getElementName());
 	}

 	public String getProjectScopeDescription(IEditorInput editorInput,
 			boolean includeInterp) {
 		IModelElement elem = DLTKUIPlugin
 				.getEditorInputModelElement(editorInput);
 		if (elem != null) {
 			IScriptProject project = elem.getScriptProject();
 			if (project != null) {
 				return getProjectScopeDescription(project, includeInterp);
 			}
 		}
 		return Messages.format(SearchMessages.ProjectScope, ""); //$NON-NLS-1$
 	}

 	public String getHierarchyScopeDescription(IType type) {
 		return Messages.format(SearchMessages.HierarchyScope,
 				type.getElementName());
 	}

 	public String getSelectionScopeDescription(IModelElement[] modelElements,
 			boolean includeInterp) {
 		if (modelElements.length == 0) {
 			return SearchMessages.DLTKSearchScopeFactory_undefined_selection;
 		}
 		String scopeDescription;
 		if (modelElements.length == 1) {
 			String label = includeInterp ? SearchMessages.SingleSelectionScope
 					: SearchMessages.SingleSelectionScopeNoInterpreterEnvironment;
 			scopeDescription = Messages.format(label,
 					modelElements[0].getElementName());
 		} else if (modelElements.length == 1) {
 			String label = includeInterp ? SearchMessages.DoubleSelectionScope
 					: SearchMessages.DoubleSelectionScopeNoInterpreterEnvironment;
 			scopeDescription = Messages.format(label,
 					modelElements[0].getElementName(),
 					modelElements[1].getElementName());
 		} else {
 			String label = includeInterp ? SearchMessages.SelectionScope
 					: SearchMessages.SelectionScopeNoInterpreterEnvironment;
 			scopeDescription = Messages.format(label,
 					modelElements[0].getElementName(),
 					modelElements[1].getElementName());
 		}
 		return scopeDescription;
 	}

 	public String getWorkingSetScopeDescription(IWorkingSet[] workingSets,
 			boolean includeInterp) {
 		if (workingSets.length == 0) {
 			return SearchMessages.DLTKSearchScopeFactory_undefined_workingsets;
 		}
 		if (workingSets.length == 1) {
 			String label = includeInterp ? SearchMessages.SingleWorkingSetScope
 					: SearchMessages.SingleWorkingSetScopeNoInterpreterEnvironment;
 			return Messages.format(label, workingSets[0].getLabel());
 		}
 		Arrays.sort(workingSets, new WorkingSetComparator());
 		if (workingSets.length == 2) {
 			String label = includeInterp ? SearchMessages.DoubleWorkingSetScope
 					: SearchMessages.DoubleWorkingSetScopeNoInterpreterEnvironment;
 			return Messages.format(label, workingSets[0].getLabel(),
 					workingSets[1].getLabel());
 		}
 		String label = includeInterp ? SearchMessages.WorkingSetsScope
 				: SearchMessages.WorkingSetsScopeNoInterpreterEnvironment;
 		return Messages.format(label, workingSets[0].getLabel(),
 				workingSets[1].getLabel());
 	}

 	public IProject[] getProjects(IDLTKSearchScope scope) {
 		IPath[] paths = scope.enclosingProjectsAndZips();
 		HashSet<IProject> temp = new HashSet<>();
 		for (int i = 0; i < paths.length; i++) {
 			IResource resource = ResourcesPlugin.getWorkspace().getRoot()
 					.findMember(paths[i]);
 			if (resource != null && resource.getType() == IResource.PROJECT)
 				temp.add((IProject) resource);
 		}
 		return temp.toArray(new IProject[temp.size()]);
 	}

 	public IModelElement[] getModelElements(ISelection selection) {
 		if (selection instanceof IStructuredSelection && !selection.isEmpty()) {
 			return getModelElements(
 					((IStructuredSelection) selection).toArray());
 		}
 		return new IModelElement[0];
 	}

 	private IModelElement[] getModelElements(Object[] elements) {
 		if (elements.length == 0)
 			return new IModelElement[0];

 		Set<IModelElement> result = new HashSet<>(elements.length);
 		for (int i = 0; i < elements.length; i++) {
 			Object selectedElement = elements[i];
 			if (selectedElement instanceof IModelElement) {
 				addModelElements(result, (IModelElement) selectedElement);
 			} else if (selectedElement instanceof IResource) {
 				addModelElements(result, (IResource) selectedElement);
 			} else if (selectedElement instanceof LogicalPackage) {
 				addModelElements(result, (LogicalPackage) selectedElement);
 			} else if (selectedElement instanceof IWorkingSet) {
 				IWorkingSet ws = (IWorkingSet) selectedElement;
 				addModelElements(result, ws);
 			} else if (selectedElement instanceof IAdaptable) {
 				IResource resource = ((IAdaptable) selectedElement)
 						.getAdapter(IResource.class);
 				if (resource != null)
 					addModelElements(result, resource);

 				IModelElement modelElement = ((IAdaptable) selectedElement)
 						.getAdapter(IModelElement.class);
 				if (modelElement != null)
 					addModelElements(result, modelElement);
 			}

 		}
 		return result.toArray(new IModelElement[result.size()]);
 	}

 	public IDLTKSearchScope createSearchScope(IModelElement[] modelElements,
 			boolean includeInterp, IDLTKLanguageToolkit toolkit) {
 		if (modelElements.length == 0)
 			return EMPTY_SCOPE;
 		return SearchEngine.createSearchScope(modelElements,
 				getSearchFlags(includeInterp), toolkit);
 	}

 	private IDLTKSearchScope createSearchScope(
 			Collection<IModelElement> modelElements, boolean includeInterp,
 			IDLTKLanguageToolkit toolkit) {
 		if (modelElements.isEmpty())
 			return EMPTY_SCOPE;
 		IModelElement[] elementArray = modelElements
 				.toArray(new IModelElement[modelElements.size()]);
 		return SearchEngine.createSearchScope(elementArray,
 				getSearchFlags(includeInterp), toolkit);
 	}

 	private static int getSearchFlags(boolean includeInterp) {
 		int flags = IDLTKSearchScope.SOURCES
 				| IDLTKSearchScope.APPLICATION_LIBRARIES;
 		if (includeInterp)
 			flags |= IDLTKSearchScope.SYSTEM_LIBRARIES;
 		return flags;
 	}

 	private void addModelElements(Set modelElements, IResource[] resources) {
 		for (int i = 0; i < resources.length; i++)
 			addModelElements(modelElements, resources[i]);
 	}

 	private void addModelElements(Set modelElements, IResource resource) {
 		IModelElement modelElement = resource.getAdapter(IModelElement.class);
 		if (modelElement == null)
 			// not a Script resource
 			return;

 		if (modelElement.getElementType() == IModelElement.SCRIPT_FOLDER) {
 			// add other possible package fragments
 			try {
 				addModelElements(modelElements, ((IFolder) resource).members());
 			} catch (CoreException ex) {
 				// don't add elements
 			}
 		}

 		modelElements.add(modelElement);
 	}

 	private void addModelElements(Set modelElements,
 			IModelElement modelElement) {
 		modelElements.add(modelElement);
 	}

 	private void addModelElements(Set modelElements, IWorkingSet workingSet) {
 		if (workingSet == null)
 			return;

 		if (workingSet.isAggregateWorkingSet() && workingSet.isEmpty()) {
 			try {
 				IScriptProject[] projects = DLTKCore
 						.create(ResourcesPlugin.getWorkspace().getRoot())
 						.getScriptProjects();
 				modelElements.addAll(Arrays.asList(projects));
 			} catch (ModelException e) {
 				DLTKUIPlugin.log(e);
 			}
 			return;
 		}

 		IAdaptable[] elements = workingSet.getElements();
 		for (int i = 0; i < elements.length; i++) {
 			IModelElement modelElement = elements[i]
 					.getAdapter(IModelElement.class);
 			if (modelElement != null) {
 				addModelElements(modelElements, modelElement);
 				continue;
 			}
 			IResource resource = elements[i].getAdapter(IResource.class);
 			if (resource != null) {
 				addModelElements(modelElements, resource);
 			}

 			// else we don't know what to do with it, ignore.
 		}
 	}

 	public void addModelElements(Set modelElements,
 			LogicalPackage selectedElement) {
 		IScriptFolder[] packages = selectedElement.getFragments();
 		for (int i = 0; i < packages.length; i++)
 			addModelElements(modelElements, packages[i]);
 	}

 	public IDLTKSearchScope createWorkspaceScope(boolean includeInterp,
 			IDLTKLanguageToolkit toolkit) {
 		if (!includeInterp) {
 			try {
 				IScriptProject[] projects = DLTKCore
 						.create(ResourcesPlugin.getWorkspace().getRoot())
 						.getScriptProjects();
 				return SearchEngine.createSearchScope(projects,
 						getSearchFlags(includeInterp), toolkit);
 			} catch (ModelException e) {
 				// ignore, use workspace scope instead
 			}
 		}
 		return SearchEngine.createWorkspaceScope(toolkit);
 	}

 	public boolean isInsideInterpreter(IModelElement element) {
 		IProjectFragment root = (IProjectFragment) element
 				.getAncestor(IModelElement.PROJECT_FRAGMENT);
 		if (root != null) {
 			try {
 				IBuildpathEntry entry = root.getRawBuildpathEntry();
 				if (entry != null && entry
 						.getEntryKind() == IBuildpathEntry.BPE_CONTAINER) {
 					IBuildpathContainer container = DLTKCore
 							.getBuildpathContainer(entry.getPath(),
 									root.getScriptProject());
 					return container != null && container
 							.getKind() == IBuildpathContainer.K_DEFAULT_SYSTEM;
 				}
 				return false;
 			} catch (ModelException e) {
 				DLTKUIPlugin.log(e);
 			}
 		}
 		return true; // include InterpreterEnvironment in doubt
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2018 IBM Corporation 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
	*
	*******************************************************************************/
	package org.eclipse.dltk.internal.ui.search;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.HashSet;
	import java.util.Set;

	import org.eclipse.core.resources.IFolder;
	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.resources.IWorkspaceRoot;
	import org.eclipse.core.resources.ResourcesPlugin;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IAdaptable;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.dltk.core.DLTKCore;
	import org.eclipse.dltk.core.IBuildpathContainer;
	import org.eclipse.dltk.core.IBuildpathEntry;
	import org.eclipse.dltk.core.IDLTKLanguageToolkit;
	import org.eclipse.dltk.core.IModelElement;
	import org.eclipse.dltk.core.IProjectFragment;
	import org.eclipse.dltk.core.IScriptFolder;
	import org.eclipse.dltk.core.IScriptProject;
	import org.eclipse.dltk.core.IType;
	import org.eclipse.dltk.core.ModelException;
	import org.eclipse.dltk.core.search.IDLTKSearchScope;
	import org.eclipse.dltk.core.search.SearchEngine;
	import org.eclipse.dltk.internal.corext.util.Messages;
	import org.eclipse.dltk.internal.ui.browsing.LogicalPackage;
	import org.eclipse.dltk.ui.DLTKUIPlugin;
	import org.eclipse.jface.viewers.ISelection;
	import org.eclipse.jface.viewers.IStructuredSelection;
	import org.eclipse.jface.window.Window;
	import org.eclipse.swt.widgets.Shell;
	import org.eclipse.ui.IEditorInput;
	import org.eclipse.ui.IWorkingSet;
	import org.eclipse.ui.PlatformUI;
	import org.eclipse.ui.dialogs.IWorkingSetSelectionDialog;

	public class DLTKSearchScopeFactory {

	private static DLTKSearchScopeFactory fgInstance;
	private final IDLTKSearchScope EMPTY_SCOPE = SearchEngine
	.createSearchScope(new IModelElement[] {}, null);

	private DLTKSearchScopeFactory() {
	}

	public static synchronized DLTKSearchScopeFactory getInstance() {
	if (fgInstance == null)
	fgInstance = new DLTKSearchScopeFactory();
	return fgInstance;
	}

	public IWorkingSet[] queryWorkingSets() throws ModelException {
	Shell shell = DLTKUIPlugin.getActiveWorkbenchShell();
	if (shell == null)
	return null;
	IWorkingSetSelectionDialog dialog = PlatformUI.getWorkbench()
	.getWorkingSetManager()
	.createWorkingSetSelectionDialog(shell, true);
	if (dialog.open() == Window.OK) {
	IWorkingSet[] workingSets = dialog.getSelection();
	if (workingSets.length > 0)
	return workingSets;
	}
	return null;
	}

	public IDLTKSearchScope createSearchScope(IWorkingSet[] workingSets,
	boolean includeInterp, IDLTKLanguageToolkit toolkit) {
	if (workingSets == null \|\| workingSets.length < 1)
	return EMPTY_SCOPE;

	Set modelElements = new HashSet(workingSets.length * 10);
	for (int i = 0; i < workingSets.length; i++) {
	IWorkingSet workingSet = workingSets[i];
	if (workingSet.isEmpty() && workingSet.isAggregateWorkingSet()) {
	return createWorkspaceScope(includeInterp, toolkit);
	}
	addModelElements(modelElements, workingSet);
	}
	return createSearchScope(modelElements, includeInterp, toolkit);
	}

	public IDLTKSearchScope createSearchScope(IWorkingSet workingSet,
	boolean includeInterp, IDLTKLanguageToolkit toolkit) {
	Set modelElements = new HashSet(10);
	if (workingSet.isEmpty() && workingSet.isAggregateWorkingSet()) {
	return createWorkspaceScope(includeInterp, toolkit);
	}
	addModelElements(modelElements, workingSet);
	return createSearchScope(modelElements, includeInterp, toolkit);
	}

	public IDLTKSearchScope createSearchScope(IResource[] resources,
	boolean includeInterp, IDLTKLanguageToolkit toolkit) {
	if (resources == null)
	return EMPTY_SCOPE;
	Set modelElements = new HashSet(resources.length);
	addModelElements(modelElements, resources);
	return createSearchScope(modelElements, includeInterp, toolkit);
	}

	public IDLTKSearchScope createSearchScope(ISelection selection,
	boolean includeInterp, IDLTKLanguageToolkit toolkit) {
	return createSearchScope(getModelElements(selection), includeInterp,
	toolkit);
	}

	public IDLTKSearchScope createProjectSearchScope(String[] projectNames,
	boolean includeInterp, IDLTKLanguageToolkit toolkit) {
	ArrayList res = new ArrayList();
	IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
	for (int i = 0; i < projectNames.length; i++) {
	IScriptProject project = DLTKCore
	.create(root.getProject(projectNames[i]));
	if (project.exists()) {
	res.add(project);
	}
	}
	return createSearchScope(res, includeInterp, toolkit);
	}

	public IDLTKSearchScope createProjectSearchScope(IScriptProject project,
	boolean includeInterp) {
	return SearchEngine.createSearchScope(project,
	getSearchFlags(includeInterp));
	}

	public IDLTKSearchScope createProjectSearchScope(IEditorInput editorInput,
	boolean includeInterp) {
	IModelElement elem = DLTKUIPlugin
	.getEditorInputModelElement(editorInput);
	if (elem != null) {
	IScriptProject project = elem.getScriptProject();
	if (project != null) {
	return createProjectSearchScope(project, includeInterp);
	}
	}
	return EMPTY_SCOPE;
	}

	public String getWorkspaceScopeDescription(boolean includeInterp) {
	return includeInterp ? SearchMessages.WorkspaceScope
	: SearchMessages.WorkspaceScopeNoInterpreterEnvironment;
	}

	public String getProjectScopeDescription(String[] projectNames,
	boolean includeInterp) {
	if (projectNames.length == 0) {
	return SearchMessages.DLTKSearchScopeFactory_undefined_projects;
	}
	String scopeDescription;
	if (projectNames.length == 1) {
	String label = includeInterp ? SearchMessages.EnclosingProjectScope
	: SearchMessages.EnclosingProjectScopeNoInterpreterEnvironment;
	scopeDescription = Messages.format(label, projectNames[0]);
	} else if (projectNames.length == 2) {
	String label = includeInterp
	? SearchMessages.EnclosingProjectsScope2
	: SearchMessages.EnclosingProjectsScope2NoInterpreterEnvironment;
	scopeDescription = Messages.format(label, projectNames[0],
	projectNames[1]);
	} else {
	String label = includeInterp ? SearchMessages.EnclosingProjectsScope
	: SearchMessages.EnclosingProjectsScopeNoInterpreterEnvironment;
	scopeDescription = Messages.format(label, projectNames[0],
	projectNames[1]);
	}
	return scopeDescription;
	}

	public String getProjectScopeDescription(IScriptProject project,
	boolean includeInterp) {
	if (includeInterp) {
	return Messages.format(SearchMessages.ProjectScope,
	project.getElementName());
	}
	return Messages.format(
	SearchMessages.ProjectScopeNoInterpreterEnvironment,
	project.getElementName());
	}

	public String getProjectScopeDescription(IEditorInput editorInput,
	boolean includeInterp) {
	IModelElement elem = DLTKUIPlugin
	.getEditorInputModelElement(editorInput);
	if (elem != null) {
	IScriptProject project = elem.getScriptProject();
	if (project != null) {
	return getProjectScopeDescription(project, includeInterp);
	}
	}
	return Messages.format(SearchMessages.ProjectScope, ""); //$NON-NLS-1$
	}

	public String getHierarchyScopeDescription(IType type) {
	return Messages.format(SearchMessages.HierarchyScope,
	type.getElementName());
	}

	public String getSelectionScopeDescription(IModelElement[] modelElements,
	boolean includeInterp) {
	if (modelElements.length == 0) {
	return SearchMessages.DLTKSearchScopeFactory_undefined_selection;
	}
	String scopeDescription;
	if (modelElements.length == 1) {
	String label = includeInterp ? SearchMessages.SingleSelectionScope
	: SearchMessages.SingleSelectionScopeNoInterpreterEnvironment;
	scopeDescription = Messages.format(label,
	modelElements[0].getElementName());
	} else if (modelElements.length == 1) {
	String label = includeInterp ? SearchMessages.DoubleSelectionScope
	: SearchMessages.DoubleSelectionScopeNoInterpreterEnvironment;
	scopeDescription = Messages.format(label,
	modelElements[0].getElementName(),
	modelElements[1].getElementName());
	} else {
	String label = includeInterp ? SearchMessages.SelectionScope
	: SearchMessages.SelectionScopeNoInterpreterEnvironment;
	scopeDescription = Messages.format(label,
	modelElements[0].getElementName(),
	modelElements[1].getElementName());
	}
	return scopeDescription;
	}

	public String getWorkingSetScopeDescription(IWorkingSet[] workingSets,
	boolean includeInterp) {
	if (workingSets.length == 0) {
	return SearchMessages.DLTKSearchScopeFactory_undefined_workingsets;
	}
	if (workingSets.length == 1) {
	String label = includeInterp ? SearchMessages.SingleWorkingSetScope
	: SearchMessages.SingleWorkingSetScopeNoInterpreterEnvironment;
	return Messages.format(label, workingSets[0].getLabel());
	}
	Arrays.sort(workingSets, new WorkingSetComparator());
	if (workingSets.length == 2) {
	String label = includeInterp ? SearchMessages.DoubleWorkingSetScope
	: SearchMessages.DoubleWorkingSetScopeNoInterpreterEnvironment;
	return Messages.format(label, workingSets[0].getLabel(),
	workingSets[1].getLabel());
	}
	String label = includeInterp ? SearchMessages.WorkingSetsScope
	: SearchMessages.WorkingSetsScopeNoInterpreterEnvironment;
	return Messages.format(label, workingSets[0].getLabel(),
	workingSets[1].getLabel());
	}

	public IProject[] getProjects(IDLTKSearchScope scope) {
	IPath[] paths = scope.enclosingProjectsAndZips();
	HashSet<IProject> temp = new HashSet<>();
	for (int i = 0; i < paths.length; i++) {
	IResource resource = ResourcesPlugin.getWorkspace().getRoot()
	.findMember(paths[i]);
	if (resource != null && resource.getType() == IResource.PROJECT)
	temp.add((IProject) resource);
	}
	return temp.toArray(new IProject[temp.size()]);
	}

	public IModelElement[] getModelElements(ISelection selection) {
	if (selection instanceof IStructuredSelection && !selection.isEmpty()) {
	return getModelElements(
	((IStructuredSelection) selection).toArray());
	}
	return new IModelElement[0];
	}

	private IModelElement[] getModelElements(Object[] elements) {
	if (elements.length == 0)
	return new IModelElement[0];

	Set<IModelElement> result = new HashSet<>(elements.length);
	for (int i = 0; i < elements.length; i++) {
	Object selectedElement = elements[i];
	if (selectedElement instanceof IModelElement) {
	addModelElements(result, (IModelElement) selectedElement);
	} else if (selectedElement instanceof IResource) {
	addModelElements(result, (IResource) selectedElement);
	} else if (selectedElement instanceof LogicalPackage) {
	addModelElements(result, (LogicalPackage) selectedElement);
	} else if (selectedElement instanceof IWorkingSet) {
	IWorkingSet ws = (IWorkingSet) selectedElement;
	addModelElements(result, ws);
	} else if (selectedElement instanceof IAdaptable) {
	IResource resource = ((IAdaptable) selectedElement)
	.getAdapter(IResource.class);
	if (resource != null)
	addModelElements(result, resource);

	IModelElement modelElement = ((IAdaptable) selectedElement)
	.getAdapter(IModelElement.class);
	if (modelElement != null)
	addModelElements(result, modelElement);
	}

	}
	return result.toArray(new IModelElement[result.size()]);
	}

	public IDLTKSearchScope createSearchScope(IModelElement[] modelElements,
	boolean includeInterp, IDLTKLanguageToolkit toolkit) {
	if (modelElements.length == 0)
	return EMPTY_SCOPE;
	return SearchEngine.createSearchScope(modelElements,
	getSearchFlags(includeInterp), toolkit);
	}

	private IDLTKSearchScope createSearchScope(
	Collection<IModelElement> modelElements, boolean includeInterp,
	IDLTKLanguageToolkit toolkit) {
	if (modelElements.isEmpty())
	return EMPTY_SCOPE;
	IModelElement[] elementArray = modelElements
	.toArray(new IModelElement[modelElements.size()]);
	return SearchEngine.createSearchScope(elementArray,
	getSearchFlags(includeInterp), toolkit);
	}

	private static int getSearchFlags(boolean includeInterp) {
	int flags = IDLTKSearchScope.SOURCES
	\| IDLTKSearchScope.APPLICATION_LIBRARIES;
	if (includeInterp)
	flags \|= IDLTKSearchScope.SYSTEM_LIBRARIES;
	return flags;
	}

	private void addModelElements(Set modelElements, IResource[] resources) {
	for (int i = 0; i < resources.length; i++)
	addModelElements(modelElements, resources[i]);
	}

	private void addModelElements(Set modelElements, IResource resource) {
	IModelElement modelElement = resource.getAdapter(IModelElement.class);
	if (modelElement == null)
	// not a Script resource
	return;

	if (modelElement.getElementType() == IModelElement.SCRIPT_FOLDER) {
	// add other possible package fragments
	try {
	addModelElements(modelElements, ((IFolder) resource).members());
	} catch (CoreException ex) {
	// don't add elements
	}
	}

	modelElements.add(modelElement);
	}

	private void addModelElements(Set modelElements,
	IModelElement modelElement) {
	modelElements.add(modelElement);
	}

	private void addModelElements(Set modelElements, IWorkingSet workingSet) {
	if (workingSet == null)
	return;

	if (workingSet.isAggregateWorkingSet() && workingSet.isEmpty()) {
	try {
	IScriptProject[] projects = DLTKCore
	.create(ResourcesPlugin.getWorkspace().getRoot())
	.getScriptProjects();
	modelElements.addAll(Arrays.asList(projects));
	} catch (ModelException e) {
	DLTKUIPlugin.log(e);
	}
	return;
	}

	IAdaptable[] elements = workingSet.getElements();
	for (int i = 0; i < elements.length; i++) {
	IModelElement modelElement = elements[i]
	.getAdapter(IModelElement.class);
	if (modelElement != null) {
	addModelElements(modelElements, modelElement);
	continue;
	}
	IResource resource = elements[i].getAdapter(IResource.class);
	if (resource != null) {
	addModelElements(modelElements, resource);
	}

	// else we don't know what to do with it, ignore.
	}
	}

	public void addModelElements(Set modelElements,
	LogicalPackage selectedElement) {
	IScriptFolder[] packages = selectedElement.getFragments();
	for (int i = 0; i < packages.length; i++)
	addModelElements(modelElements, packages[i]);
	}

	public IDLTKSearchScope createWorkspaceScope(boolean includeInterp,
	IDLTKLanguageToolkit toolkit) {
	if (!includeInterp) {
	try {
	IScriptProject[] projects = DLTKCore
	.create(ResourcesPlugin.getWorkspace().getRoot())
	.getScriptProjects();
	return SearchEngine.createSearchScope(projects,
	getSearchFlags(includeInterp), toolkit);
	} catch (ModelException e) {
	// ignore, use workspace scope instead
	}
	}
	return SearchEngine.createWorkspaceScope(toolkit);
	}

	public boolean isInsideInterpreter(IModelElement element) {
	IProjectFragment root = (IProjectFragment) element
	.getAncestor(IModelElement.PROJECT_FRAGMENT);
	if (root != null) {
	try {
	IBuildpathEntry entry = root.getRawBuildpathEntry();
	if (entry != null && entry
	.getEntryKind() == IBuildpathEntry.BPE_CONTAINER) {
	IBuildpathContainer container = DLTKCore
	.getBuildpathContainer(entry.getPath(),
	root.getScriptProject());
	return container != null && container
	.getKind() == IBuildpathContainer.K_DEFAULT_SYSTEM;
	}
	return false;
	} catch (ModelException e) {
	DLTKUIPlugin.log(e);
	}
	}
	return true; // include InterpreterEnvironment in doubt
	}
	}