| /******************************************************************************* |
| * Copyright (c) 2000, 2012 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 |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jdt.ui; |
| |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| |
| import org.eclipse.swt.dnd.Transfer; |
| import org.eclipse.swt.widgets.Shell; |
| |
| import org.eclipse.core.runtime.Assert; |
| import org.eclipse.core.runtime.IPath; |
| |
| import org.eclipse.core.resources.IProject; |
| |
| import org.eclipse.jface.operation.IRunnableContext; |
| |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.dialogs.SelectionDialog; |
| |
| import org.eclipse.ui.texteditor.IDocumentProvider; |
| |
| import org.eclipse.jdt.core.IClasspathEntry; |
| import org.eclipse.jdt.core.ICompilationUnit; |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.IPackageFragmentRoot; |
| import org.eclipse.jdt.core.ISourceReference; |
| import org.eclipse.jdt.core.ITypeRoot; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jdt.core.search.IJavaSearchConstants; |
| import org.eclipse.jdt.core.search.IJavaSearchScope; |
| import org.eclipse.jdt.core.search.SearchEngine; |
| |
| import org.eclipse.jdt.internal.corext.javadoc.JavaDocLocations; |
| import org.eclipse.jdt.internal.corext.refactoring.reorg.JavaElementTransfer; |
| |
| import org.eclipse.jdt.ui.dialogs.TypeSelectionExtension; |
| import org.eclipse.jdt.ui.text.IColorManager; |
| |
| import org.eclipse.jdt.internal.ui.JavaPlugin; |
| import org.eclipse.jdt.internal.ui.JavaUIMessages; |
| import org.eclipse.jdt.internal.ui.SharedImages; |
| import org.eclipse.jdt.internal.ui.dialogs.FilteredTypesSelectionDialog; |
| import org.eclipse.jdt.internal.ui.dialogs.MainTypeSelectionDialog; |
| import org.eclipse.jdt.internal.ui.dialogs.MultiMainTypeSelectionDialog; |
| import org.eclipse.jdt.internal.ui.dialogs.PackageSelectionDialog; |
| import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility; |
| import org.eclipse.jdt.internal.ui.util.BusyIndicatorRunnableContext; |
| |
| /** |
| * Central access point for the Java UI plug-in (id <code>"org.eclipse.jdt.ui"</code>). |
| * This class provides static methods for: |
| * <ul> |
| * <li> creating various kinds of selection dialogs to present a collection |
| * of Java elements to the user and let them make a selection.</li> |
| * <li> opening a Java editor on a compilation unit.</li> |
| * </ul> |
| * <p> |
| * This class provides static methods and fields only; it is not intended to be |
| * instantiated or subclassed by clients. |
| * </p> |
| * |
| * @noinstantiate This class is not intended to be instantiated by clients. |
| */ |
| public final class JavaUI { |
| |
| private static ISharedImages fgSharedImages= null; |
| |
| private JavaUI() { |
| // prevent instantiation of JavaUI. |
| } |
| |
| /** |
| * The id of the Java plug-in (value <code>"org.eclipse.jdt.ui"</code>). |
| */ |
| public static final String ID_PLUGIN= "org.eclipse.jdt.ui"; //$NON-NLS-1$ |
| |
| /** |
| * The id of the Java perspective |
| * (value <code>"org.eclipse.jdt.ui.JavaPerspective"</code>). |
| */ |
| public static final String ID_PERSPECTIVE= "org.eclipse.jdt.ui.JavaPerspective"; //$NON-NLS-1$ |
| |
| /** |
| * The id of the Java hierarchy perspective |
| * (value <code>"org.eclipse.jdt.ui.JavaHierarchyPerspective"</code>). |
| */ |
| public static final String ID_HIERARCHYPERSPECTIVE= "org.eclipse.jdt.ui.JavaHierarchyPerspective"; //$NON-NLS-1$ |
| |
| /** |
| * The id of the Java action set |
| * (value <code>"org.eclipse.jdt.ui.JavaActionSet"</code>). |
| */ |
| public static final String ID_ACTION_SET= "org.eclipse.jdt.ui.JavaActionSet"; //$NON-NLS-1$ |
| |
| /** |
| * The id of the Java Element Creation action set |
| * (value <code>"org.eclipse.jdt.ui.JavaElementCreationActionSet"</code>). |
| * |
| * @since 2.0 |
| */ |
| public static final String ID_ELEMENT_CREATION_ACTION_SET= "org.eclipse.jdt.ui.JavaElementCreationActionSet"; //$NON-NLS-1$ |
| |
| /** |
| * The id of the Java Coding action set |
| * (value <code>"org.eclipse.jdt.ui.CodingActionSet"</code>). |
| * |
| * @since 2.0 |
| */ |
| public static final String ID_CODING_ACTION_SET= "org.eclipse.jdt.ui.CodingActionSet"; //$NON-NLS-1$ |
| |
| /** |
| * The id of the Java action set for open actions |
| * (value <code>"org.eclipse.jdt.ui.A_OpenActionSet"</code>). |
| * |
| * @since 2.0 |
| */ |
| public static final String ID_OPEN_ACTION_SET= "org.eclipse.jdt.ui.A_OpenActionSet"; //$NON-NLS-1$ |
| |
| /** |
| * The id of the Java Search action set |
| * (value <code>org.eclipse.jdt.ui.SearchActionSet"</code>). |
| * |
| * @since 2.0 |
| */ |
| public static final String ID_SEARCH_ACTION_SET= "org.eclipse.jdt.ui.SearchActionSet"; //$NON-NLS-1$ |
| |
| /** |
| * The editor part id of the editor that presents Java compilation units |
| * (value <code>"org.eclipse.jdt.ui.CompilationUnitEditor"</code>). |
| */ |
| public static final String ID_CU_EDITOR= "org.eclipse.jdt.ui.CompilationUnitEditor"; //$NON-NLS-1$ |
| |
| /** |
| * The editor part id of the editor that presents Java binary class files |
| * (value <code>"org.eclipse.jdt.ui.ClassFileEditor"</code>). |
| */ |
| public static final String ID_CF_EDITOR= "org.eclipse.jdt.ui.ClassFileEditor"; //$NON-NLS-1$ |
| |
| /** |
| * The editor part id of the code snippet editor |
| * (value <code>"org.eclipse.jdt.ui.SnippetEditor"</code>). |
| */ |
| public static final String ID_SNIPPET_EDITOR= "org.eclipse.jdt.ui.SnippetEditor"; //$NON-NLS-1$ |
| |
| /** |
| * The view part id of the Packages view |
| * (value <code>"org.eclipse.jdt.ui.PackageExplorer"</code>). |
| * <p> |
| * When this id is used to access |
| * a view part with <code>IWorkbenchPage.findView</code> or |
| * <code>showView</code>, the returned <code>IViewPart</code> |
| * can be safely cast to an <code>IPackagesViewPart</code>. |
| * </p> |
| * |
| * @see IPackagesViewPart |
| * @see org.eclipse.ui.IWorkbenchPage#findView(java.lang.String) |
| * @see org.eclipse.ui.IWorkbenchPage#showView(java.lang.String) |
| */ |
| public static final String ID_PACKAGES= "org.eclipse.jdt.ui.PackageExplorer"; //$NON-NLS-1$ |
| |
| /** |
| * The view part id of the type hierarchy part |
| * (value <code>"org.eclipse.jdt.ui.TypeHierarchy"</code>). |
| * <p> |
| * When this id is used to access |
| * a view part with <code>IWorkbenchPage.findView</code> or |
| * <code>showView</code>, the returned <code>IViewPart</code> |
| * can be safely cast to an <code>ITypeHierarchyViewPart</code>. |
| * </p> |
| * |
| * @see ITypeHierarchyViewPart |
| * @see org.eclipse.ui.IWorkbenchPage#findView(java.lang.String) |
| * @see org.eclipse.ui.IWorkbenchPage#showView(java.lang.String) |
| */ |
| public static final String ID_TYPE_HIERARCHY= "org.eclipse.jdt.ui.TypeHierarchy"; //$NON-NLS-1$ |
| |
| /** |
| * The view part id of the source (declaration) view |
| * (value <code>"org.eclipse.jdt.ui.SourceView"</code>). |
| * |
| * @see org.eclipse.ui.IWorkbenchPage#findView(java.lang.String) |
| * @see org.eclipse.ui.IWorkbenchPage#showView(java.lang.String) |
| * @since 3.0 |
| */ |
| public static final String ID_SOURCE_VIEW= "org.eclipse.jdt.ui.SourceView"; //$NON-NLS-1$ |
| |
| /** |
| * The view part id of the Javadoc view |
| * (value <code>"org.eclipse.jdt.ui.JavadocView"</code>). |
| * |
| * @see org.eclipse.ui.IWorkbenchPage#findView(java.lang.String) |
| * @see org.eclipse.ui.IWorkbenchPage#showView(java.lang.String) |
| * @since 3.0 |
| */ |
| public static final String ID_JAVADOC_VIEW= "org.eclipse.jdt.ui.JavadocView"; //$NON-NLS-1$ |
| |
| /** |
| * The id of the Java Browsing Perspective |
| * (value <code>"org.eclipse.jdt.ui.JavaBrowsingPerspective"</code>). |
| * |
| * @since 2.0 |
| */ |
| public static String ID_BROWSING_PERSPECTIVE= "org.eclipse.jdt.ui.JavaBrowsingPerspective"; //$NON-NLS-1$ |
| |
| /** |
| * The view part id of the Java Browsing Projects view |
| * (value <code>"org.eclipse.jdt.ui.ProjectsView"</code>). |
| * |
| * @since 2.0 |
| */ |
| public static String ID_PROJECTS_VIEW= "org.eclipse.jdt.ui.ProjectsView"; //$NON-NLS-1$ |
| |
| /** |
| * The view part id of the Java Browsing Packages view |
| * (value <code>"org.eclipse.jdt.ui.PackagesView"</code>). |
| * |
| * @since 2.0 |
| */ |
| public static String ID_PACKAGES_VIEW= "org.eclipse.jdt.ui.PackagesView"; //$NON-NLS-1$ |
| |
| /** |
| * The view part id of the Java Browsing Types view |
| * (value <code>"org.eclipse.jdt.ui.TypesView"</code>). |
| * |
| * @since 2.0 |
| */ |
| public static String ID_TYPES_VIEW= "org.eclipse.jdt.ui.TypesView"; //$NON-NLS-1$ |
| |
| /** |
| * The view part id of the Java Browsing Members view |
| * (value <code>"org.eclipse.jdt.ui.MembersView"</code>). |
| * |
| * @since 2.0 |
| */ |
| public static String ID_MEMBERS_VIEW= "org.eclipse.jdt.ui.MembersView"; //$NON-NLS-1$ |
| |
| |
| /** |
| * The preference page id of the user library preference page |
| * (value <code>"org.eclipse.jdt.ui.preferences.UserLibraryPreferencePage"</code>). |
| * |
| * @since 3.4 |
| */ |
| public static final String ID_USER_LIBRARY_PREFERENCE_PAGE= "org.eclipse.jdt.ui.preferences.UserLibraryPreferencePage"; //$NON-NLS-1$ |
| |
| /** |
| * The preference page id of the class path variables preference page |
| * (value <code>"org.eclipse.jdt.ui.preferences.ClasspathVariablesPreferencePage"</code>). |
| * |
| * @since 3.4 |
| */ |
| public static final String ID_CLASSPATH_VARIABLES_PREFERENCE_PAGE= "org.eclipse.jdt.ui.preferences.ClasspathVariablesPreferencePage"; //$NON-NLS-1$ |
| |
| |
| /** |
| * The class org.eclipse.debug.core.model.IProcess allows attaching String properties to |
| * processes. The Java UI contributes a property page for IProcess that will show the contents |
| * of the property with this key. The intent of this property is to show the command line a |
| * process was launched with. |
| * |
| * @deprecated As of 1.0 |
| */ |
| public static final String ATTR_CMDLINE= "org.eclipse.jdt.ui.launcher.cmdLine"; //$NON-NLS-1$ |
| |
| |
| /** |
| * @deprecated Constant introduced to avoid deprecated warning |
| */ |
| private final static int DEPRECATED_CONSIDER_TYPES= IJavaElementSearchConstants.CONSIDER_TYPES; |
| |
| /** |
| * Returns the shared images for the Java UI. |
| * |
| * @return the shared images manager |
| */ |
| public static ISharedImages getSharedImages() { |
| if (fgSharedImages == null) |
| fgSharedImages= new SharedImages(); |
| |
| return fgSharedImages; |
| } |
| |
| /** |
| * Creates a selection dialog that lists all packages of the given Java project. |
| * The caller is responsible for opening the dialog with <code>Window.open</code>, |
| * and subsequently extracting the selected package (of type |
| * <code>IPackageFragment</code>) via <code>SelectionDialog.getResult</code>. |
| * |
| * @param parent the parent shell of the dialog to be created |
| * @param project the Java project |
| * @param style flags defining the style of the dialog; the valid flags are: |
| * <code>IJavaElementSearchConstants.CONSIDER_BINARIES</code>, indicating that |
| * packages from binary package fragment roots should be included in addition |
| * to those from source package fragment roots; |
| * <code>IJavaElementSearchConstants.CONSIDER_REQUIRED_PROJECTS</code>, indicating that |
| * packages from required projects should be included as well. |
| * @param filter the initial pattern to filter the set of packages. For example "com" shows |
| * all packages starting with "com". The meta character '?' representing any character and |
| * '*' representing any string are supported. Clients can pass an empty string if no filtering |
| * is required. |
| * @return a new selection dialog |
| * @exception JavaModelException if the selection dialog could not be opened |
| * |
| * @since 2.0 |
| */ |
| public static SelectionDialog createPackageDialog(Shell parent, IJavaProject project, int style, String filter) throws JavaModelException { |
| Assert.isTrue((style | IJavaElementSearchConstants.CONSIDER_BINARIES | IJavaElementSearchConstants.CONSIDER_REQUIRED_PROJECTS) == |
| (IJavaElementSearchConstants.CONSIDER_BINARIES | IJavaElementSearchConstants.CONSIDER_REQUIRED_PROJECTS)); |
| |
| IPackageFragmentRoot[] roots= null; |
| if ((style & IJavaElementSearchConstants.CONSIDER_REQUIRED_PROJECTS) != 0) { |
| roots= project.getAllPackageFragmentRoots(); |
| } else { |
| roots= project.getPackageFragmentRoots(); |
| } |
| |
| List<IPackageFragmentRoot> consideredRoots= null; |
| if ((style & IJavaElementSearchConstants.CONSIDER_BINARIES) != 0) { |
| consideredRoots= Arrays.asList(roots); |
| } else { |
| consideredRoots= new ArrayList<IPackageFragmentRoot>(roots.length); |
| for (int i= 0; i < roots.length; i++) { |
| IPackageFragmentRoot root= roots[i]; |
| if (root.getKind() != IPackageFragmentRoot.K_BINARY) |
| consideredRoots.add(root); |
| |
| } |
| } |
| |
| IJavaSearchScope searchScope= SearchEngine.createJavaSearchScope(consideredRoots.toArray(new IJavaElement[consideredRoots.size()])); |
| BusyIndicatorRunnableContext context= new BusyIndicatorRunnableContext(); |
| if (style == 0 || style == IJavaElementSearchConstants.CONSIDER_REQUIRED_PROJECTS) { |
| return createPackageDialog(parent, context, searchScope, false, true, filter); |
| } else { |
| return createPackageDialog(parent, context, searchScope, false, false, filter); |
| } |
| } |
| |
| /** |
| * Creates a selection dialog that lists all packages of the given Java search scope. |
| * The caller is responsible for opening the dialog with <code>Window.open</code>, |
| * and subsequently extracting the selected package (of type |
| * <code>IPackageFragment</code>) via <code>SelectionDialog.getResult</code>. |
| * |
| * @param parent the parent shell of the dialog to be created |
| * @param context the runnable context to run the search in |
| * @param scope the scope defining the available packages. |
| * @param multipleSelection true if multiple selection is allowed |
| * @param removeDuplicates true if only one package is shown per package name |
| * @param filter the initial pattern to filter the set of packages. For example "com" shows |
| * all packages starting with "com". The meta character '?' representing any character and |
| * '*' representing any string are supported. Clients can pass an empty string if no filtering |
| * is required. |
| * @return a new selection dialog |
| * |
| * @since 3.2 |
| */ |
| public static SelectionDialog createPackageDialog(Shell parent, IRunnableContext context, IJavaSearchScope scope, |
| boolean multipleSelection, boolean removeDuplicates, String filter) { |
| |
| int flag= removeDuplicates ? PackageSelectionDialog.F_REMOVE_DUPLICATES : 0; |
| PackageSelectionDialog dialog= new PackageSelectionDialog(parent, context, flag, scope); |
| dialog.setFilter(filter); |
| dialog.setIgnoreCase(false); |
| dialog.setMultipleSelection(multipleSelection); |
| return dialog; |
| } |
| |
| /** |
| * Creates a selection dialog that lists all packages of the given Java project. |
| * The caller is responsible for opening the dialog with <code>Window.open</code>, |
| * and subsequently extracting the selected package (of type |
| * <code>IPackageFragment</code>) via <code>SelectionDialog.getResult</code>. |
| * |
| * @param parent the parent shell of the dialog to be created |
| * @param project the Java project |
| * @param style flags defining the style of the dialog; the valid flags are: |
| * <code>IJavaElementSearchConstants.CONSIDER_BINARIES</code>, indicating that |
| * packages from binary package fragment roots should be included in addition |
| * to those from source package fragment roots; |
| * <code>IJavaElementSearchConstants.CONSIDER_REQUIRED_PROJECTS</code>, indicating that |
| * packages from required projects should be included as well. |
| * @return a new selection dialog |
| * @exception JavaModelException if the selection dialog could not be opened |
| */ |
| public static SelectionDialog createPackageDialog(Shell parent, IJavaProject project, int style) throws JavaModelException { |
| return createPackageDialog(parent, project, style, ""); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Creates a selection dialog that lists all packages under the given package |
| * fragment root. |
| * The caller is responsible for opening the dialog with <code>Window.open</code>, |
| * and subsequently extracting the selected package (of type |
| * <code>IPackageFragment</code>) via <code>SelectionDialog.getResult</code>. |
| * |
| * @param parent the parent shell of the dialog to be created |
| * @param root the package fragment root |
| * @param filter the initial pattern to filter the set of packages. For example "com" shows |
| * all packages starting with "com". The meta character '?' representing any character and |
| * '*' representing any string are supported. Clients can pass an empty string if no filtering |
| * is required. |
| * @return a new selection dialog |
| * @exception JavaModelException if the selection dialog could not be opened |
| * |
| * @since 2.0 |
| */ |
| public static SelectionDialog createPackageDialog(Shell parent, IPackageFragmentRoot root, String filter) throws JavaModelException { |
| IJavaSearchScope scope= SearchEngine.createJavaSearchScope(new IJavaElement[] {root}); |
| BusyIndicatorRunnableContext context= new BusyIndicatorRunnableContext(); |
| return createPackageDialog(parent, context, scope, false, true, filter); |
| } |
| |
| /** |
| * Creates a selection dialog that lists all packages under the given package |
| * fragment root. |
| * The caller is responsible for opening the dialog with <code>Window.open</code>, |
| * and subsequently extracting the selected package (of type |
| * <code>IPackageFragment</code>) via <code>SelectionDialog.getResult</code>. |
| * |
| * @param parent the parent shell of the dialog to be created |
| * @param root the package fragment root |
| * @return a new selection dialog |
| * @exception JavaModelException if the selection dialog could not be opened |
| */ |
| public static SelectionDialog createPackageDialog(Shell parent, IPackageFragmentRoot root) throws JavaModelException { |
| return createPackageDialog(parent, root, ""); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Creates a selection dialog that lists all types in the given project. |
| * The caller is responsible for opening the dialog with <code>Window.open</code>, |
| * and subsequently extracting the selected type(s) (of type |
| * <code>IType</code>) via <code>SelectionDialog.getResult</code>. |
| * |
| * @param parent the parent shell of the dialog to be created |
| * @param context the runnable context used to show progress when the dialog |
| * is being populated |
| * @param project the Java project |
| * @param style flags defining the style of the dialog; the only valid values are |
| * {@link IJavaElementSearchConstants#CONSIDER_CLASSES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_INTERFACES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_ANNOTATION_TYPES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_ENUMS}, |
| * {@link IJavaElementSearchConstants#CONSIDER_ALL_TYPES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_CLASSES_AND_INTERFACES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_CLASSES_AND_ENUMS}, and |
| * {@link IJavaElementSearchConstants#CONSIDER_INTERFACES_AND_ANNOTATIONS}. Please note that |
| * the bitwise OR combination of the elementary constants is not supported. |
| * @param multipleSelection <code>true</code> if multiple selection is allowed |
| * |
| * @return a new selection dialog |
| * |
| * @exception JavaModelException if the selection dialog could not be opened |
| */ |
| public static SelectionDialog createTypeDialog(Shell parent, IRunnableContext context, IProject project, int style, boolean multipleSelection) throws JavaModelException { |
| IJavaSearchScope scope= SearchEngine.createJavaSearchScope(new IJavaProject[] { JavaCore.create(project) }); |
| return createTypeDialog(parent, context, scope, style, multipleSelection); |
| } |
| |
| /** |
| * Creates a selection dialog that lists all types in the given scope. |
| * The caller is responsible for opening the dialog with <code>Window.open</code>, |
| * and subsequently extracting the selected type(s) (of type |
| * <code>IType</code>) via <code>SelectionDialog.getResult</code>. |
| * |
| * @param parent the parent shell of the dialog to be created |
| * @param context the runnable context used to show progress when the dialog |
| * is being populated |
| * @param scope the scope that limits which types are included |
| * @param style flags defining the style of the dialog; the only valid values are |
| * {@link IJavaElementSearchConstants#CONSIDER_CLASSES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_INTERFACES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_ANNOTATION_TYPES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_ENUMS}, |
| * {@link IJavaElementSearchConstants#CONSIDER_ALL_TYPES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_CLASSES_AND_INTERFACES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_CLASSES_AND_ENUMS}, and |
| * {@link IJavaElementSearchConstants#CONSIDER_INTERFACES_AND_ANNOTATIONS}. Please note that |
| * the bitwise OR combination of the elementary constants is not supported. |
| * @param multipleSelection <code>true</code> if multiple selection is allowed |
| * |
| * @return a new selection dialog |
| * |
| * @exception JavaModelException if the selection dialog could not be opened |
| */ |
| public static SelectionDialog createTypeDialog(Shell parent, IRunnableContext context, IJavaSearchScope scope, int style, boolean multipleSelection) throws JavaModelException { |
| return createTypeDialog(parent, context, scope, style, multipleSelection, "");//$NON-NLS-1$ |
| } |
| |
| /** |
| * Creates a selection dialog that lists all types in the given scope. |
| * The caller is responsible for opening the dialog with <code>Window.open</code>, |
| * and subsequently extracting the selected type(s) (of type |
| * <code>IType</code>) via <code>SelectionDialog.getResult</code>. |
| * |
| * @param parent the parent shell of the dialog to be created |
| * @param context the runnable context used to show progress when the dialog |
| * is being populated |
| * @param scope the scope that limits which types are included |
| * @param style flags defining the style of the dialog; the only valid values are |
| * {@link IJavaElementSearchConstants#CONSIDER_CLASSES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_INTERFACES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_ANNOTATION_TYPES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_ENUMS}, |
| * {@link IJavaElementSearchConstants#CONSIDER_ALL_TYPES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_CLASSES_AND_INTERFACES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_CLASSES_AND_ENUMS}, and |
| * {@link IJavaElementSearchConstants#CONSIDER_INTERFACES_AND_ANNOTATIONS}. Please note that |
| * the bitwise OR combination of the elementary constants is not supported. |
| * @param multipleSelection <code>true</code> if multiple selection is allowed |
| * @param filter the initial pattern to filter the set of types. For example "Abstract" shows |
| * all types starting with "abstract". The meta character '?' representing any character and |
| * '*' representing any string are supported. Clients can pass an empty string if no filtering |
| * is required. |
| * |
| * @return a new selection dialog |
| * |
| * @exception JavaModelException if the selection dialog could not be opened |
| * |
| * @since 2.0 |
| */ |
| public static SelectionDialog createTypeDialog(Shell parent, IRunnableContext context, IJavaSearchScope scope, int style, boolean multipleSelection, String filter) throws JavaModelException { |
| return createTypeDialog(parent, context, scope, style, multipleSelection, filter, null); |
| } |
| |
| /** |
| * Creates a selection dialog that lists all types in the given scope. |
| * The caller is responsible for opening the dialog with <code>Window.open</code>, |
| * and subsequently extracting the selected type(s) (of type |
| * <code>IType</code>) via <code>SelectionDialog.getResult</code>. |
| * |
| * @param parent the parent shell of the dialog to be created |
| * @param context the runnable context used to show progress when the dialog |
| * is being populated |
| * @param scope the scope that limits which types are included |
| * @param style flags defining the style of the dialog; the only valid values are |
| * {@link IJavaElementSearchConstants#CONSIDER_CLASSES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_INTERFACES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_ANNOTATION_TYPES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_ENUMS}, |
| * {@link IJavaElementSearchConstants#CONSIDER_ALL_TYPES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_CLASSES_AND_INTERFACES}, |
| * {@link IJavaElementSearchConstants#CONSIDER_CLASSES_AND_ENUMS}, and |
| * {@link IJavaElementSearchConstants#CONSIDER_INTERFACES_AND_ANNOTATIONS}. Please note that |
| * the bitwise OR combination of the elementary constants is not supported. |
| * @param multipleSelection <code>true</code> if multiple selection is allowed |
| * @param filter the initial pattern to filter the set of types. For example "Abstract" shows |
| * all types starting with "abstract". The meta character '?' representing any character and |
| * '*' representing any string are supported. Clients can pass an empty string if no filtering |
| * is required. |
| * @param extension a user interface extension to the type selection dialog or <code>null</code> |
| * if no extension is desired |
| * |
| * @return a new selection dialog |
| * |
| * @exception JavaModelException if the selection dialog could not be opened |
| * |
| * @since 3.2 |
| */ |
| public static SelectionDialog createTypeDialog(Shell parent, IRunnableContext context, IJavaSearchScope scope, int style, |
| boolean multipleSelection, String filter, TypeSelectionExtension extension) throws JavaModelException { |
| int elementKinds= 0; |
| if (style == IJavaElementSearchConstants.CONSIDER_ALL_TYPES) { |
| elementKinds= IJavaSearchConstants.TYPE; |
| } else if (style == IJavaElementSearchConstants.CONSIDER_INTERFACES) { |
| elementKinds= IJavaSearchConstants.INTERFACE; |
| } else if (style == IJavaElementSearchConstants.CONSIDER_CLASSES) { |
| elementKinds= IJavaSearchConstants.CLASS; |
| } else if (style == IJavaElementSearchConstants.CONSIDER_ANNOTATION_TYPES) { |
| elementKinds= IJavaSearchConstants.ANNOTATION_TYPE; |
| } else if (style == IJavaElementSearchConstants.CONSIDER_ENUMS) { |
| elementKinds= IJavaSearchConstants.ENUM; |
| } else if (style == IJavaElementSearchConstants.CONSIDER_CLASSES_AND_INTERFACES) { |
| elementKinds= IJavaSearchConstants.CLASS_AND_INTERFACE; |
| } else if (style == IJavaElementSearchConstants.CONSIDER_CLASSES_AND_ENUMS) { |
| elementKinds= IJavaSearchConstants.CLASS_AND_ENUM; |
| } else if (style == DEPRECATED_CONSIDER_TYPES) { |
| elementKinds= IJavaSearchConstants.CLASS_AND_INTERFACE; |
| } else if (style == IJavaElementSearchConstants.CONSIDER_INTERFACES_AND_ANNOTATIONS) { |
| elementKinds= IJavaSearchConstants.INTERFACE_AND_ANNOTATION; |
| } else { |
| throw new IllegalArgumentException("Invalid style constant."); //$NON-NLS-1$ |
| } |
| FilteredTypesSelectionDialog dialog= new FilteredTypesSelectionDialog(parent, multipleSelection, |
| context, scope, elementKinds, extension); |
| dialog.setMessage(JavaUIMessages.JavaUI_defaultDialogMessage); |
| dialog.setInitialPattern(filter); |
| return dialog; |
| } |
| |
| /** |
| * Creates a selection dialog that lists all types in the given scope containing |
| * a standard <code>main</code> method. |
| * The caller is responsible for opening the dialog with <code>Window.open</code>, |
| * and subsequently extracting the selected type(s) (of type |
| * <code>IType</code>) via <code>SelectionDialog.getResult</code>. |
| * |
| * @param parent the parent shell of the dialog to be created |
| * @param context the runnable context used to show progress when the dialog |
| * is being populated |
| * @param scope the scope that limits which types are included |
| * @param style flags defining the style of the dialog; the only valid values are |
| * <code>IJavaElementSearchConstants.CONSIDER_BINARIES</code>, |
| * <code>CONSIDER_EXTERNAL_JARS</code>, or their bitwise OR, or <code>0</code> |
| * @param multipleSelection <code>true</code> if multiple selection is allowed |
| * @param filter the initial pattern to filter the set of types containing a main method. For |
| * example "App" shows all types starting with "app". The meta character '?' representing |
| * any character and '*' representing any string are supported. Clients can pass an empty |
| * string if no filtering is required. |
| * @return a new selection dialog |
| * |
| * @since 2.0 |
| */ |
| public static SelectionDialog createMainTypeDialog(Shell parent, IRunnableContext context, IJavaSearchScope scope, int style, boolean multipleSelection, String filter) { |
| if (multipleSelection) { |
| MultiMainTypeSelectionDialog dialog= new MultiMainTypeSelectionDialog(parent, context, scope, style); |
| dialog.setFilter(filter); |
| return dialog; |
| } else { |
| MainTypeSelectionDialog dialog= new MainTypeSelectionDialog(parent, context, scope, style); |
| dialog.setFilter(filter); |
| return dialog; |
| } |
| } |
| |
| /** |
| * Creates a selection dialog that lists all types in the given scope containing |
| * a standard <code>main</code> method. |
| * The caller is responsible for opening the dialog with <code>Window.open</code>, |
| * and subsequently extracting the selected type(s) (of type |
| * <code>IType</code>) via <code>SelectionDialog.getResult</code>. |
| * |
| * @param parent the parent shell of the dialog to be created |
| * @param context the runnable context used to show progress when the dialog |
| * is being populated |
| * @param scope the scope that limits which types are included |
| * @param style flags defining the style of the dialog; the only valid values are |
| * <code>IJavaElementSearchConstants.CONSIDER_BINARIES</code>, |
| * <code>CONSIDER_EXTERNAL_JARS</code>, or their bitwise OR, or <code>0</code> |
| * @param multipleSelection <code>true</code> if multiple selection is allowed |
| * @return a new selection dialog |
| */ |
| public static SelectionDialog createMainTypeDialog(Shell parent, IRunnableContext context, IJavaSearchScope scope, int style, boolean multipleSelection) { |
| return createMainTypeDialog(parent, context, scope, style, multipleSelection, "");//$NON-NLS-1$ |
| } |
| |
| /** |
| * Opens an editor on the given Java element in the active page. Valid elements are all Java elements that are {@link ISourceReference}. |
| * For elements inside a compilation unit or class file, the parent is opened in the editor is opened and the element revealed. |
| * If there already is an open Java editor for the given element, it is returned. |
| * |
| * @param element the input element; either a compilation unit |
| * (<code>ICompilationUnit</code>) or a class file (<code>IClassFile</code>) or source references inside. |
| * @return returns the editor part of the opened editor or <code>null</code> if the element is not a {@link ISourceReference} or the |
| * file was opened in an external editor. |
| * @exception PartInitException if the editor could not be initialized or no workbench page is active |
| * @exception JavaModelException if this element does not exist or if an exception occurs while accessing its underlying resource |
| */ |
| public static IEditorPart openInEditor(IJavaElement element) throws JavaModelException, PartInitException { |
| return openInEditor(element, true, true); |
| } |
| |
| /** |
| * Opens an editor on the given Java element in the active page. Valid elements are all Java elements that are {@link ISourceReference}. |
| * For elements inside a compilation unit or class file, the parent is opened in the editor is opened. |
| * If there already is an open Java editor for the given element, it is returned. |
| * |
| * @param element the input element; either a compilation unit |
| * (<code>ICompilationUnit</code>) or a class file (<code>IClassFile</code>) or source references inside. |
| * @param activate if set, the editor will be activated. |
| * @param reveal if set, the element will be revealed. |
| * @return returns the editor part of the opened editor or <code>null</code> if the element is not a {@link ISourceReference} or the |
| * file was opened in an external editor. |
| * @exception PartInitException if the editor could not be initialized or no workbench page is active |
| * @exception JavaModelException if this element does not exist or if an exception occurs while accessing its underlying resource |
| * @since 3.3 |
| */ |
| public static IEditorPart openInEditor(IJavaElement element, boolean activate, boolean reveal) throws JavaModelException, PartInitException { |
| if (!(element instanceof ISourceReference)) { |
| return null; |
| } |
| IEditorPart part= EditorUtility.openInEditor(element, activate); |
| if (reveal && part != null) { |
| EditorUtility.revealInEditor(part, element); |
| } |
| return part; |
| } |
| |
| /** |
| * Reveals the source range of the given source reference element in the |
| * given editor. No checking is done if the editor displays a compilation unit or |
| * class file that contains the given source reference. The editor simply reveals |
| * the source range denoted by the given source reference. |
| * |
| * @param part the editor displaying the compilation unit or class file |
| * @param element the source reference element defining the source range to be revealed |
| * |
| * @deprecated use <code>revealInEditor(IEditorPart, IJavaElement)</code> instead |
| */ |
| public static void revealInEditor(IEditorPart part, ISourceReference element) { |
| if (element instanceof IJavaElement) |
| revealInEditor(part, (IJavaElement) element); |
| } |
| |
| /** |
| * Reveals the given java element in the given editor. If the element is not an instance |
| * of <code>ISourceReference</code> this method result in a NOP. If it is a source |
| * reference no checking is done if the editor displays a compilation unit or class file that |
| * contains the source reference element. The editor simply reveals the source range |
| * denoted by the given element. |
| * |
| * @param part the editor displaying a compilation unit or class file |
| * @param element the element to be revealed |
| * |
| * @since 2.0 |
| */ |
| public static void revealInEditor(IEditorPart part, IJavaElement element) { |
| EditorUtility.revealInEditor(part, element); |
| } |
| |
| /** |
| * Returns the working copy manager for the Java UI plug-in. |
| * |
| * @return the working copy manager for the Java UI plug-in |
| */ |
| public static IWorkingCopyManager getWorkingCopyManager() { |
| return JavaPlugin.getDefault().getWorkingCopyManager(); |
| } |
| |
| /** |
| * Returns the Java element wrapped by the given editor input. |
| * |
| * @param editorInput the editor input |
| * @return the Java element wrapped by <code>editorInput</code> or <code>null</code> if none |
| * @since 3.2 |
| */ |
| public static IJavaElement getEditorInputJavaElement(IEditorInput editorInput) { |
| // Performance: check working copy manager first: this is faster |
| IJavaElement je= JavaPlugin.getDefault().getWorkingCopyManager().getWorkingCopy(editorInput); |
| if (je != null) |
| return je; |
| |
| return editorInput.getAdapter(IJavaElement.class); |
| } |
| |
| /** |
| * Returns the {@link ITypeRoot} wrapped by the given editor input. |
| * |
| * @param editorInput the editor input |
| * @return the {@link ITypeRoot} wrapped by <code>editorInput</code> or <code>null</code> if the editor input |
| * does not stand for a ITypeRoot |
| * |
| * @since 3.4 |
| */ |
| public static ITypeRoot getEditorInputTypeRoot(IEditorInput editorInput) { |
| // Performance: check working copy manager first: this is faster |
| ICompilationUnit cu= JavaPlugin.getDefault().getWorkingCopyManager().getWorkingCopy(editorInput); |
| if (cu != null) |
| return cu; |
| |
| IJavaElement je= editorInput.getAdapter(IJavaElement.class); |
| if (je instanceof ITypeRoot) |
| return (ITypeRoot) je; |
| |
| return null; |
| } |
| |
| /** |
| * Answers the shared working copies currently registered for the Java plug-in. |
| * Note that the returned array can include working copies that are |
| * not on the class path of a Java project. |
| * |
| * @return the list of shared working copies |
| * |
| * @see org.eclipse.jdt.core.JavaCore#getSharedWorkingCopies(org.eclipse.jdt.core.IBufferFactory) |
| * @since 2.0 |
| * @deprecated Use {@link JavaCore#getWorkingCopies(org.eclipse.jdt.core.WorkingCopyOwner)} instead with <code>null</code> as |
| * argument for owner. |
| */ |
| public static org.eclipse.jdt.core.IWorkingCopy[] getSharedWorkingCopies() { |
| return JavaCore.getSharedWorkingCopies(getBufferFactory()); |
| } |
| |
| /** |
| * Answers the shared working copies that are on the class path of a Java |
| * project currently registered for the Java plug-in. |
| * |
| * |
| * @return the list of shared working copies |
| * |
| * @see #getSharedWorkingCopies() |
| * @since 2.1 |
| * @deprecated Use {@link JavaCore#getWorkingCopies(org.eclipse.jdt.core.WorkingCopyOwner)} instead and filter the list |
| * with {@link IJavaProject#isOnClasspath(IJavaElement)}. |
| */ |
| public static org.eclipse.jdt.core.IWorkingCopy[] getSharedWorkingCopiesOnClasspath() { |
| org.eclipse.jdt.core.IWorkingCopy[] wcs= getSharedWorkingCopies(); |
| List<org.eclipse.jdt.core.IWorkingCopy> result= new ArrayList<org.eclipse.jdt.core.IWorkingCopy>(wcs.length); |
| for (int i = 0; i < wcs.length; i++) { |
| org.eclipse.jdt.core.IWorkingCopy wc= wcs[i]; |
| if (wc instanceof IJavaElement) { |
| IJavaElement je= (IJavaElement)wc; |
| if (je.getJavaProject().isOnClasspath(je)) { |
| result.add(wc); |
| } |
| } |
| } |
| return result.toArray(new org.eclipse.jdt.core.IWorkingCopy[result.size()]); |
| } |
| |
| /** |
| * Returns the buffer factory for the Java UI plug-in. |
| * |
| * @return the buffer factory for the Java UI plug-in |
| * |
| * @see org.eclipse.jdt.core.IBufferFactory |
| * @since 2.0 |
| * @deprecated {@link org.eclipse.jdt.core.IBufferFactory} has been replaced by {@link org.eclipse.jdt.core.WorkingCopyOwner}. |
| * The Java UI plug-in uses the <i>primary working copy owner</i> that can be accessed with <code>null</code> in |
| * API's that require an owner |
| */ |
| public static org.eclipse.jdt.core.IBufferFactory getBufferFactory() { |
| return JavaPlugin.getDefault().getBufferFactory(); |
| } |
| |
| /** |
| * Returns the DocumentProvider used for Java compilation units. |
| * |
| * @return the DocumentProvider for Java compilation units. |
| * |
| * @see IDocumentProvider |
| * @since 2.0 |
| */ |
| public static IDocumentProvider getDocumentProvider() { |
| return JavaPlugin.getDefault().getCompilationUnitDocumentProvider(); |
| } |
| |
| /** |
| * Sets the Javadoc location for an archive with the given path. |
| * |
| * @param archivePath the path of the library; this can be an workspace path |
| * or an external path in case of an external library. |
| * @param url the Javadoc location to set. This location should contain index.html and |
| * a file 'package-list'. <code>null</code> clears the current documentation |
| * location. |
| * @deprecated Javadoc is now attached to the classpath entry. |
| * Evaluate the libraries classpath entry and reconfigure the Javadoc location there. |
| * |
| * @since 2.0 |
| */ |
| public static void setLibraryJavadocLocation(IPath archivePath, URL url) { |
| // deprecated |
| } |
| |
| /** |
| * Sets the Javadoc locations for archives with the given paths. |
| * |
| * @param archivePaths the paths of the libraries. can be workspace paths |
| * or external paths in case of an external library. |
| * @param urls the Javadoc locations to set. Each location corresponds to the archive path of the same index. A location should contain index.html and |
| * a file 'package-list'. <code>null</code> is a valid location entry and clears the current documentation |
| * location. The length of the location array must be equals to the number of archive paths passed. |
| * |
| * @deprecated Javadoc is now attached to the classpath entry. |
| * Evaluate the libraries classpath entry and reconfigure the Javadoc location there. |
| * |
| * @since 3.0 |
| */ |
| public static void setLibraryJavadocLocations(IPath[] archivePaths, URL[] urls) { |
| // deprecated |
| } |
| |
| /** |
| * Returns the Javadoc location for an archive or <code>null</code> if no |
| * location is available. |
| * |
| * @param archivePath the path of the library. This can be an workspace path |
| * or an external path in case of an external library. |
| * @return the Javadoc location for an archive or <code>null</code>. |
| * |
| * @deprecated Javadoc is now attached to the classpath entry. Use {@link #getJavadocBaseLocation(IJavaElement)} |
| * with the archive's {@link IPackageFragmentRoot} or use {@link #getLibraryJavadocLocation(IClasspathEntry)} |
| * with the archive's {@link IClasspathEntry}. |
| * |
| * @since 2.0 |
| */ |
| public static URL getLibraryJavadocLocation(IPath archivePath) { |
| return null; |
| } |
| |
| /** |
| * Returns the Javadoc location for library's classpath entry or <code>null</code> if no |
| * location is available. Note that only classpath entries of kind {@link IClasspathEntry#CPE_LIBRARY} and |
| * {@link IClasspathEntry#CPE_VARIABLE} support Javadoc locations. |
| * |
| * @param entry the classpath entry to get the Javadoc location for |
| * @return the Javadoc location or<code>null</code> if no Javadoc location is available |
| * @throws IllegalArgumentException Thrown when the entry is <code>null</code> or not of kind |
| * {@link IClasspathEntry#CPE_LIBRARY} or {@link IClasspathEntry#CPE_VARIABLE}. |
| * |
| * @since 3.1 |
| */ |
| public static URL getLibraryJavadocLocation(IClasspathEntry entry) { |
| return JavaDocLocations.getLibraryJavadocLocation(entry); |
| } |
| |
| /** |
| * Sets the Javadoc location for a Java project. This location is used for |
| * all types located in the project's source folders. |
| * |
| * @param project the project |
| * @param url the Javadoc location to set. This location should contain index.html and |
| * a file 'package-list'. <code>null</code> clears the current documentation |
| * location. |
| * |
| * @since 2.1 |
| */ |
| public static void setProjectJavadocLocation(IJavaProject project, URL url) { |
| JavaDocLocations.setProjectJavadocLocation(project, url); |
| } |
| |
| /** |
| * Returns the Javadoc location for a Java project or <code>null</code> if no |
| * location is available. This location is used for all types located in the project's |
| * source folders. |
| * |
| * @param project the project |
| * @return the Javadoc location for a Java project or <code>null</code> |
| * |
| * @since 2.1 |
| */ |
| public static URL getProjectJavadocLocation(IJavaProject project) { |
| return JavaDocLocations.getProjectJavadocLocation(project); |
| } |
| |
| /** |
| * Returns the Javadoc base URL for an element. The base location contains the |
| * index file. This location doesn't have to exist. Returns <code>null</code> |
| * if no javadoc location has been attached to the element's library or project. |
| * Example of a returned URL is <i>http://www.junit.org/junit/javadoc</i>. |
| * |
| * @param element the element for which the documentation URL is requested. |
| * @return the base location |
| * @throws JavaModelException thrown when the element can not be accessed |
| * |
| * @since 2.0 |
| */ |
| public static URL getJavadocBaseLocation(IJavaElement element) throws JavaModelException { |
| return JavaDocLocations.getJavadocBaseLocation(element); |
| } |
| |
| /** |
| * Returns the Javadoc URL for an element. Example of a returned URL is |
| * <i>http://www.junit.org/junit/javadoc/junit/extensions/TestSetup.html</i>. |
| * This returned location doesn't have to exist. Returns <code>null</code> |
| * if no javadoc location has been attached to the element's library or |
| * project. |
| * |
| * @param element the element for which the documentation URL is requested. |
| * @param includeAnchor If set, the URL contains an anchor for member references: |
| * <i>http://www.junit.org/junit/javadoc/junit/extensions/TestSetup.html#run(junit.framework.TestResult)</i>. Note |
| * that this involves type resolving and is a more expensive call than without anchor. |
| * @return the Javadoc URL for the element |
| * @throws JavaModelException thrown when the element can not be accessed |
| * |
| * @since 2.0 |
| */ |
| public static URL getJavadocLocation(IJavaElement element, boolean includeAnchor) throws JavaModelException { |
| return JavaDocLocations.getJavadocLocation(element, includeAnchor); |
| } |
| |
| /** |
| * Returns the transfer instance used to copy/paste Java elements to |
| * and from the clipboard. Objects managed by this transfer instance |
| * are of type <code>IJavaElement[]</code>. So to access data from the |
| * clipboard clients should use the following code snippet: |
| * <pre> |
| * IJavaElement[] elements= |
| * (IJavaElement[])clipboard.getContents(JavaUI.getJavaElementClipboardTransfer()); |
| * </pre> |
| * |
| * To put elements into the clipboard use the following snippet: |
| * |
| * <pre> |
| * IJavaElement[] javaElements= ...; |
| * clipboard.setContents( |
| * new Object[] { javaElements }, |
| * new Transfer[] { JavaUI.getJavaElementClipboardTransfer() } ); |
| * </pre> |
| * |
| * @return returns the transfer object used to copy/paste Java elements |
| * to and from the clipboard |
| * |
| * @since 3.0 |
| */ |
| public static Transfer getJavaElementClipboardTransfer() { |
| return JavaElementTransfer.getInstance(); |
| } |
| |
| /** |
| * Returns the color manager the Java UI plug-in which is used to manage |
| * any Java-specific colors needed for such things like syntax highlighting. |
| * |
| * @return the color manager to be used for Java text viewers |
| * @since 3.2 |
| */ |
| public static IColorManager getColorManager() { |
| return JavaPlugin.getDefault().getJavaTextTools().getColorManager(); |
| } |
| } |
