| /******************************************************************************* |
| * Copyright (c) 2005, 2016 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.ui; |
| |
| import java.io.IOException; |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| import org.eclipse.core.filesystem.URIUtil; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IConfigurationElement; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.ISafeRunnable; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.ListenerList; |
| import org.eclipse.core.runtime.MultiStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.SafeRunner; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.dltk.core.DLTKCore; |
| import org.eclipse.dltk.core.IBuffer; |
| import org.eclipse.dltk.core.IExternalSourceModule; |
| import org.eclipse.dltk.core.IModelElement; |
| import org.eclipse.dltk.core.IModelElementVisitor; |
| import org.eclipse.dltk.core.IProjectFragment; |
| import org.eclipse.dltk.core.IScriptFolder; |
| import org.eclipse.dltk.core.IScriptModel; |
| import org.eclipse.dltk.core.IScriptProject; |
| import org.eclipse.dltk.core.IShutdownListener; |
| import org.eclipse.dltk.core.ISourceModule; |
| import org.eclipse.dltk.core.ISourceReference; |
| import org.eclipse.dltk.core.ModelException; |
| import org.eclipse.dltk.core.WorkingCopyOwner; |
| import org.eclipse.dltk.core.environment.EnvironmentManager; |
| import org.eclipse.dltk.core.environment.IEnvironment; |
| import org.eclipse.dltk.internal.core.BufferManager; |
| import org.eclipse.dltk.internal.core.BuiltinSourceModule; |
| import org.eclipse.dltk.internal.core.ExternalProjectFragment; |
| import org.eclipse.dltk.internal.launching.DLTKLaunchingPlugin; |
| import org.eclipse.dltk.internal.ui.DLTKUI; |
| import org.eclipse.dltk.internal.ui.DLTKUIMessages; |
| import org.eclipse.dltk.internal.ui.IDLTKStatusConstants; |
| import org.eclipse.dltk.internal.ui.InitializeJob; |
| import org.eclipse.dltk.internal.ui.editor.DocumentAdapter; |
| import org.eclipse.dltk.internal.ui.editor.EditorUtility; |
| import org.eclipse.dltk.internal.ui.editor.IScriptEditor; |
| import org.eclipse.dltk.internal.ui.editor.ISourceModuleDocumentProvider; |
| import org.eclipse.dltk.internal.ui.editor.SourceModuleDocumentProvider; |
| import org.eclipse.dltk.internal.ui.editor.WorkingCopyManager; |
| import org.eclipse.dltk.internal.ui.text.hover.EditorTextHoverDescriptor; |
| import org.eclipse.dltk.internal.ui.viewsupport.ContextActivator; |
| import org.eclipse.dltk.internal.ui.wizards.buildpath.BuildpathAttributeConfigurationDescriptors; |
| import org.eclipse.dltk.launching.sourcelookup.DBGPSourceModule; |
| import org.eclipse.dltk.ui.editor.saveparticipant.SaveParticipantRegistry; |
| import org.eclipse.dltk.ui.text.completion.ContentAssistHistory; |
| import org.eclipse.dltk.ui.viewsupport.ImageDescriptorRegistry; |
| import org.eclipse.dltk.ui.viewsupport.ImagesOnFileSystemRegistry; |
| import org.eclipse.dltk.ui.viewsupport.ProblemMarkerManager; |
| import org.eclipse.dltk.utils.ExecutionContexts; |
| import org.eclipse.dltk.utils.IExecutableOperation; |
| import org.eclipse.dltk.utils.IExecutionContextManager; |
| import org.eclipse.jface.action.GroupMarker; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.action.Separator; |
| import org.eclipse.jface.dialogs.IDialogSettings; |
| import org.eclipse.jface.dialogs.ProgressMonitorDialog; |
| import org.eclipse.jface.operation.IRunnableWithProgress; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorReference; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchListener; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.editors.text.EditorsUI; |
| import org.eclipse.ui.ide.FileStoreEditorInput; |
| import org.eclipse.ui.navigator.ICommonMenuConstants; |
| import org.eclipse.ui.plugin.AbstractUIPlugin; |
| import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants; |
| import org.eclipse.ui.texteditor.ConfigurationElementSorter; |
| import org.osgi.framework.BundleContext; |
| |
| /** |
| * The main plugin class to be used in the desktop. |
| */ |
| public class DLTKUIPlugin extends AbstractUIPlugin { |
| |
| public static final String PLUGIN_ID = "org.eclipse.dltk.ui"; //$NON-NLS-1$ |
| /** |
| * @since 2.0 |
| */ |
| public static final String ID_SCRIPT_EXPLORER = "org.eclipse.dltk.ui.ScriptExplorer"; //$NON-NLS-1$ |
| @Deprecated |
| public static final String ID_SCRIPTEXPLORER = ID_SCRIPT_EXPLORER; |
| public static final String ID_TYPE_HIERARCHY = "org.eclipse.dltk.ui.TypeHierarchy"; //$NON-NLS-1$ |
| /** |
| * The preference page id of the build path variables preference page (value |
| * |
| * <code>"org.eclipse.dltk.ui.preferences.BuildpathVariablesPreferencePage"</code> |
| * ). |
| * |
| */ |
| public static final String ID_BUILDPATH_VARIABLES_PREFERENCE_PAGE = "org.eclipse.dltk.ui.preferences.BuildpathVariablesPreferencePage"; //$NON-NLS-1$ |
| public static final String CONTEXT_VIEWS = "org.eclipse.dltk.ui.context.views"; //$NON-NLS-1$ |
| // The shared instance. |
| private static DLTKUIPlugin plugin; |
| |
| private MembersOrderPreferenceCache fMembersOrderPreferenceCache; |
| |
| // private static ISharedImages fgSharedImages = null; |
| |
| /** |
| * Content assist history. |
| * |
| * |
| */ |
| private ContentAssistHistory fContentAssistHistory; |
| |
| private BuildpathAttributeConfigurationDescriptors fBuildpathAttributeConfigurationDescriptors; |
| |
| /** |
| * The constructor. |
| */ |
| public DLTKUIPlugin() { |
| DLTKUIPlugin.plugin = this; |
| } |
| |
| /** |
| * This method is called upon plug-in activation |
| */ |
| public void start(BundleContext context) throws Exception { |
| super.start(context); |
| |
| WorkingCopyOwner.setPrimaryBufferProvider(new WorkingCopyOwner() { |
| public IBuffer createBuffer(ISourceModule workingCopy) { |
| ISourceModule original = workingCopy.getPrimary(); |
| IResource resource = original.getResource(); |
| if (resource != null) { |
| if (resource instanceof IFile) { |
| return new DocumentAdapter(workingCopy, |
| (IFile) resource); |
| } |
| } else if (original instanceof IExternalSourceModule) { |
| IProjectFragment fragment = (IProjectFragment) original |
| .getAncestor(IModelElement.PROJECT_FRAGMENT); |
| if (!fragment.isArchive()) { |
| // IPath path = original.getPath(); |
| // return new DocumentAdapter(workingCopy, path); |
| return BufferManager.createBuffer(original); |
| } |
| return BufferManager.createBuffer(original); |
| } |
| |
| if (original instanceof DBGPSourceModule) { |
| return BufferManager.createBuffer(original); |
| } |
| |
| if (original instanceof BuiltinSourceModule) { |
| // IPath path = original.getPath(); |
| // return new DocumentAdapter(workingCopy, path); |
| return BufferManager.createBuffer(original); |
| } |
| return DocumentAdapter.NULL; |
| } |
| }); |
| |
| // must add here to guarantee that it is the first in the listener list |
| |
| IPreferenceStore store = getPreferenceStore(); |
| fMembersOrderPreferenceCache = new MembersOrderPreferenceCache(); |
| fMembersOrderPreferenceCache.install(store); |
| |
| // to initialize launching |
| DLTKLaunchingPlugin.getDefault(); |
| |
| // Close all open editors which has remote environment files open |
| try { |
| PlatformUI.getWorkbench().addWorkbenchListener( |
| new ShutdownCloseRemoteEditorsListener()); |
| ContextActivator.getInstance().install(); |
| } catch (IllegalStateException e) { |
| // IGNORE: workbench has not been created yet. |
| } |
| |
| ExecutionContexts.setManager(new UIExecutionContextManager()); |
| new InitializeJob().schedule(); |
| } |
| |
| static class ShutdownCloseRemoteEditorsListener implements |
| IWorkbenchListener { |
| public void postShutdown(IWorkbench workbench) { |
| // empty |
| } |
| |
| public boolean preShutdown(final IWorkbench workbench, boolean forced) { |
| SafeRunner.run(new ISafeRunnable() { |
| public void run() throws Exception { |
| preShutdownInternal(workbench); |
| } |
| |
| public void handleException(Throwable exception) { |
| // Logged by SafeRunner |
| } |
| }); |
| return true; |
| } |
| |
| void preShutdownInternal(final IWorkbench workbench) { |
| IWorkbenchWindow window = workbench.getActiveWorkbenchWindow(); |
| if (window != null) { |
| IWorkbenchPage page = window.getActivePage(); |
| if (page != null) { |
| IEditorReference[] references = page.getEditorReferences(); |
| for (int i = 0; i < references.length; i++) { |
| IEditorPart editor = references[i].getEditor(false); |
| if (editor != null && editor instanceof IScriptEditor) { |
| closeEditor(page, editor); |
| } |
| } |
| } |
| } |
| } |
| |
| private void closeEditor(IWorkbenchPage page, IEditorPart editor) { |
| IModelElement modelElement = EditorUtility |
| .getEditorInputModelElement(editor, false); |
| if (modelElement != null) { |
| IEnvironment environment = EnvironmentManager |
| .getEnvironment(modelElement); |
| if (environment != null && !environment.isLocal()) { |
| page.closeEditor(editor, false); |
| } |
| } |
| } |
| } |
| |
| private static class UIExecutionContextManager implements |
| IExecutionContextManager { |
| |
| private boolean active = false; |
| |
| public void executeInBackground(final IExecutableOperation operation) { |
| if (!isRunningInUIThread()) { |
| operation.execute(new NullProgressMonitor()); |
| } else if (DLTKUI.isStarted()) { |
| if (active) { |
| return; |
| } |
| final ProgressMonitorDialog dialog = new ProgressMonitorDialog( |
| null) { |
| @Override |
| protected void configureShell(Shell shell) { |
| super.configureShell(shell); |
| shell.setText(operation.getOperationName()); |
| } |
| }; |
| active = true; |
| try { |
| dialog.run(true, false, new IRunnableWithProgress() { |
| public void run(IProgressMonitor monitor) { |
| if (!isRunningInUIThread()) { |
| operation.execute(monitor); |
| } |
| } |
| }); |
| } catch (InvocationTargetException e) { |
| DLTKCore.error(e.getMessage(), e); |
| } catch (InterruptedException e) { |
| DLTKCore.error(e.getMessage(), e); |
| } finally { |
| active = false; |
| } |
| } |
| } |
| |
| public boolean isRunningInUIThread() { |
| return Display.getCurrent() != null; |
| } |
| |
| } |
| |
| private final ListenerList shutdownListeners = new ListenerList(); |
| |
| public void addShutdownListener(IShutdownListener listener) { |
| shutdownListeners.add(listener); |
| } |
| |
| /** |
| * This method is called when the plug-in is stopped |
| */ |
| @Override |
| public void stop(BundleContext context) throws Exception { |
| |
| ExecutionContexts.setManager(null); |
| if (fMembersOrderPreferenceCache != null) { |
| fMembersOrderPreferenceCache.dispose(); |
| fMembersOrderPreferenceCache = null; |
| } |
| Object[] listeners = shutdownListeners.getListeners(); |
| for (int i = 0; i < listeners.length; ++i) { |
| ((IShutdownListener) listeners[i]).shutdown(); |
| } |
| shutdownListeners.clear(); |
| super.stop(context); |
| DLTKUIPlugin.plugin = null; |
| } |
| |
| private IWorkbenchPage internalGetActivePage() { |
| final IWorkbench workbench; |
| try { |
| workbench = getWorkbench(); |
| } catch (IllegalStateException e) { |
| // Workbench has not been created yet - can happen in tests |
| return null; |
| } |
| final IWorkbenchWindow window = workbench.getActiveWorkbenchWindow(); |
| if (window == null) { |
| return null; |
| } |
| return workbench.getActiveWorkbenchWindow().getActivePage(); |
| } |
| |
| /** |
| * Returns the shared instance. |
| */ |
| public static DLTKUIPlugin getDefault() { |
| return DLTKUIPlugin.plugin; |
| } |
| |
| public IDialogSettings getDialogSettingsSection(String name) { |
| IDialogSettings dialogSettings = getDialogSettings(); |
| IDialogSettings section = dialogSettings.getSection(name); |
| if (section == null) { |
| section = dialogSettings.addNewSection(name); |
| } |
| return section; |
| } |
| |
| public static IWorkbenchPage getActivePage() { |
| return DLTKUIPlugin.getDefault().internalGetActivePage(); |
| } |
| |
| public static IWorkbenchWindow getActiveWorkbenchWindow() { |
| return DLTKUIPlugin.getDefault().getWorkbench() |
| .getActiveWorkbenchWindow(); |
| } |
| |
| /** |
| * Returns an image descriptor for the image file at the given plug-in |
| * relative path. |
| * |
| * @param path |
| * the path |
| * @return the image descriptor |
| */ |
| public static ImageDescriptor getImageDescriptor(String path) { |
| return AbstractUIPlugin.imageDescriptorFromPlugin( |
| "org.eclipse.dltk.ui", path); //$NON-NLS-1$ |
| } |
| |
| private IWorkingCopyManager fWorkingCopyManager; |
| private ISourceModuleDocumentProvider fSourceModuleDocumentProvider; |
| private ProblemMarkerManager fProblemMarkerManager; |
| private ImageDescriptorRegistry fImageDescriptorRegistry; |
| |
| public synchronized IWorkingCopyManager getWorkingCopyManager() { |
| if (fWorkingCopyManager == null) { |
| ISourceModuleDocumentProvider provider = getSourceModuleDocumentProvider(); |
| fWorkingCopyManager = new WorkingCopyManager(provider); |
| } |
| return fWorkingCopyManager; |
| } |
| |
| public synchronized ISourceModuleDocumentProvider getSourceModuleDocumentProvider() { |
| |
| if (fSourceModuleDocumentProvider == null) { |
| fSourceModuleDocumentProvider = new SourceModuleDocumentProvider(); |
| } |
| return fSourceModuleDocumentProvider; |
| } |
| |
| public static ISourceModuleDocumentProvider getDocumentProvider() { |
| return DLTKUIPlugin.getDefault().getSourceModuleDocumentProvider(); |
| } |
| |
| public static ImageDescriptorRegistry getImageDescriptorRegistry() { |
| return DLTKUIPlugin.getDefault().internalGetImageDescriptorRegistry(); |
| } |
| |
| private ImageDescriptorRegistry internalGetImageDescriptorRegistry() { |
| if (fImageDescriptorRegistry == null) { |
| fImageDescriptorRegistry = new ImageDescriptorRegistry(); |
| } |
| return fImageDescriptorRegistry; |
| } |
| |
| /** |
| * Returns the model element wrapped by the given editor input. |
| * |
| * @param editorInput |
| * the editor input |
| * @return the model element wrapped by <code>editorInput</code> or |
| * <code>null</code> if none |
| */ |
| public static ISourceModule getEditorInputModelElement( |
| IEditorInput editorInput) { |
| // Performance: check working copy manager first: this is faster |
| ISourceModule je = DLTKUIPlugin.getDefault().getWorkingCopyManager() |
| .getWorkingCopy(editorInput, false); |
| if (je != null) { |
| return je; |
| } |
| |
| if (editorInput instanceof FileStoreEditorInput) { |
| ISourceModule module = resolveSourceModule((FileStoreEditorInput) editorInput); |
| if (module != null) { |
| return module; |
| } |
| } |
| IModelElement me = editorInput |
| .getAdapter(IModelElement.class); |
| if (me instanceof ISourceModule) { |
| return (ISourceModule) me; |
| } |
| return null; |
| } |
| |
| public static IWorkspace getWorkspace() { |
| return ResourcesPlugin.getWorkspace(); |
| } |
| |
| public static void log(IStatus status) { |
| DLTKUIPlugin.getDefault().getLog().log(status); |
| } |
| |
| public static void log(Throwable e) { |
| DLTKUIPlugin.log(new Status(IStatus.ERROR, DLTKUIPlugin.PLUGIN_ID, |
| IDLTKStatusConstants.INTERNAL_ERROR, |
| DLTKUIMessages.ScriptPlugin_internal_error, e)); |
| } |
| |
| public static void logErrorMessage(String message) { |
| logErrorMessage(message, null); |
| } |
| |
| public static void warn(String message) { |
| warn(message, null); |
| } |
| |
| public static void warn(String message, Throwable throwable) { |
| log(new Status(IStatus.WARNING, PLUGIN_ID, |
| IDLTKStatusConstants.INTERNAL_ERROR, message, throwable)); |
| } |
| |
| public static void logErrorMessage(String message, Throwable throwable) { |
| DLTKUIPlugin.log(new Status(IStatus.ERROR, DLTKUIPlugin.PLUGIN_ID, |
| IDLTKStatusConstants.INTERNAL_ERROR, message, throwable)); |
| } |
| |
| public static void logErrorStatus(String message, IStatus status) { |
| if (status == null) { |
| DLTKUIPlugin.logErrorMessage(message); |
| return; |
| } |
| MultiStatus multi = new MultiStatus(DLTKUIPlugin.PLUGIN_ID, |
| IDLTKStatusConstants.INTERNAL_ERROR, message, null); |
| multi.add(status); |
| DLTKUIPlugin.log(multi); |
| } |
| |
| public static Shell getActiveWorkbenchShell() { |
| IWorkbenchWindow window = DLTKUIPlugin.getActiveWorkbenchWindow(); |
| if (window != null) { |
| return window.getShell(); |
| } |
| return null; |
| } |
| |
| /** |
| * Creates the DLTK plug-in's standard groups for view context menus. |
| * |
| * @param menu |
| * the menu manager to be populated |
| */ |
| public static void createStandardGroups(IMenuManager menu) { |
| if (!menu.isEmpty()) { |
| return; |
| } |
| |
| menu.add(new Separator(IContextMenuConstants.GROUP_NEW)); |
| menu.add(new GroupMarker(IContextMenuConstants.GROUP_GOTO)); |
| menu.add(new Separator(IContextMenuConstants.GROUP_OPEN)); |
| menu.add(new GroupMarker(IContextMenuConstants.GROUP_SHOW)); |
| menu.add(new Separator(ICommonMenuConstants.GROUP_EDIT)); |
| menu.add(new Separator(IContextMenuConstants.GROUP_REORGANIZE)); |
| menu.add(new Separator(IContextMenuConstants.GROUP_GENERATE)); |
| menu.add(new Separator(IContextMenuConstants.GROUP_SEARCH)); |
| menu.add(new Separator(IContextMenuConstants.GROUP_BUILD)); |
| menu.add(new Separator(IContextMenuConstants.GROUP_ADDITIONS)); |
| menu.add(new Separator(IContextMenuConstants.GROUP_VIEWER_SETUP)); |
| menu.add(new Separator(IContextMenuConstants.GROUP_PROPERTIES)); |
| } |
| |
| public synchronized MembersOrderPreferenceCache getMemberOrderPreferenceCache() { |
| // initialized on startup |
| return fMembersOrderPreferenceCache; |
| } |
| |
| public static String getPluginId() { |
| return DLTKUIPlugin.PLUGIN_ID; |
| } |
| |
| /** |
| * Returns the Script content assist history. |
| * |
| * @return the Script content assist history |
| * |
| */ |
| public ContentAssistHistory getContentAssistHistory() { |
| if (fContentAssistHistory == null) { |
| try { |
| fContentAssistHistory = ContentAssistHistory.load( |
| getPluginPreferences(), |
| PreferenceConstants.CODEASSIST_LRU_HISTORY); |
| } catch (CoreException x) { |
| DLTKUIPlugin.log(x); |
| } |
| if (fContentAssistHistory == null) { |
| fContentAssistHistory = new ContentAssistHistory(); |
| } |
| } |
| |
| return fContentAssistHistory; |
| } |
| |
| private final Map<String, EditorTextHoverDescriptor[]> editorTextHoverDescriptorsByNature = new HashMap<String, EditorTextHoverDescriptor[]>(); |
| |
| /** |
| * Resets editor text hovers contributed to the workbench. |
| * <p> |
| * This will force a rebuild of the descriptors the next time a client asks |
| * for them. |
| * </p> |
| * |
| * @deprecated |
| */ |
| @Deprecated |
| public void resetEditorTextHoverDescriptors() { |
| synchronized (editorTextHoverDescriptorsByNature) { |
| editorTextHoverDescriptorsByNature.clear(); |
| } |
| } |
| |
| /** |
| * Resets editor text hovers contributed to the workbench. |
| * <p> |
| * This will force a rebuild of the descriptors the next time a client asks |
| * for them. |
| * </p> |
| */ |
| public void resetEditorTextHoverDescriptors(String natureId) { |
| synchronized (editorTextHoverDescriptorsByNature) { |
| editorTextHoverDescriptorsByNature.remove(natureId); |
| } |
| } |
| |
| /** |
| * Returns all editor text hovers contributed to the workbench without |
| * specified nature. |
| * |
| * @param store |
| * @return |
| * @deprecated |
| */ |
| @Deprecated |
| public EditorTextHoverDescriptor[] getEditorTextHoverDescriptors( |
| IPreferenceStore store) { |
| return initializeEditorTextHoverDescriprtors(store, null); |
| } |
| |
| /** |
| * Returns all editor text hovers contributed to the workbench for the |
| * specified nature. |
| * |
| * @param store |
| * preference store to initialize settings from |
| * @param natureId |
| * the nature to filter text hovers |
| * @return an array of EditorTextHoverDescriptor |
| */ |
| public EditorTextHoverDescriptor[] getEditorTextHoverDescriptors( |
| IPreferenceStore store, String natureId) { |
| EditorTextHoverDescriptor[] descriptors; |
| synchronized (editorTextHoverDescriptorsByNature) { |
| descriptors = editorTextHoverDescriptorsByNature.get(natureId); |
| } |
| if (descriptors == null) { |
| descriptors = initializeEditorTextHoverDescriprtors(store, natureId); |
| if (descriptors != null && natureId != null) { |
| synchronized (editorTextHoverDescriptorsByNature) { |
| editorTextHoverDescriptorsByNature.put(natureId, |
| descriptors); |
| } |
| } |
| } |
| return descriptors; |
| } |
| |
| private EditorTextHoverDescriptor[] initializeEditorTextHoverDescriprtors( |
| IPreferenceStore store, String natureId) { |
| EditorTextHoverDescriptor[] descriptors = EditorTextHoverDescriptor |
| .getContributedHovers(natureId, store); |
| ConfigurationElementSorter sorter = new ConfigurationElementSorter() { |
| /* |
| * @see org.eclipse.ui.texteditor.ConfigurationElementSorter# |
| * getConfigurationElement(java.lang.Object) |
| */ |
| public IConfigurationElement getConfigurationElement(Object object) { |
| return ((EditorTextHoverDescriptor) object) |
| .getConfigurationElement(); |
| } |
| }; |
| sorter.sort(descriptors); |
| // Move Best Match hover to front |
| for (int i = 0; i < descriptors.length - 1; i++) { |
| if (PreferenceConstants.ID_BESTMATCH_HOVER.equals(descriptors[i] |
| .getId())) { |
| final EditorTextHoverDescriptor hoverDescriptor = descriptors[i]; |
| for (int j = i; j > 0; j--) |
| descriptors[j] = descriptors[j - 1]; |
| descriptors[0] = hoverDescriptor; |
| break; |
| } |
| } |
| return descriptors; |
| } |
| |
| /** |
| * 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(IModelElement element) |
| throws ModelException, PartInitException { |
| return DLTKUIPlugin.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(IModelElement element, |
| boolean activate, boolean reveal) throws ModelException, |
| PartInitException { |
| if (!(element instanceof ISourceReference)) { |
| return null; |
| } |
| IEditorPart part = EditorUtility.openInEditor(element, activate); |
| if (reveal && part != null) { |
| EditorUtility.revealInEditor(part, element); |
| } |
| return part; |
| } |
| |
| public synchronized ProblemMarkerManager getProblemMarkerManager() { |
| if (fProblemMarkerManager == null) { |
| fProblemMarkerManager = new ProblemMarkerManager(); |
| } |
| return fProblemMarkerManager; |
| } |
| |
| public static boolean isDebug() { |
| return DLTKCore.DEBUG; |
| } |
| |
| public BuildpathAttributeConfigurationDescriptors getClasspathAttributeConfigurationDescriptors() { |
| if (fBuildpathAttributeConfigurationDescriptors == null) { |
| fBuildpathAttributeConfigurationDescriptors = new BuildpathAttributeConfigurationDescriptors(); |
| } |
| return fBuildpathAttributeConfigurationDescriptors; |
| } |
| |
| public static ISourceModule resolveSourceModule(FileStoreEditorInput input) { |
| final ISourceModule[] modules = new ISourceModule[1]; |
| final IPath filePath = URIUtil.toPath(input.getURI()); |
| IScriptModel scriptModel = DLTKCore.create(ResourcesPlugin |
| .getWorkspace().getRoot()); |
| try { |
| scriptModel.accept(new IModelElementVisitor() { |
| |
| public boolean visit(IModelElement element) { |
| boolean shouldDescend = (modules[0] == null); |
| |
| if (shouldDescend == true) { |
| if (element instanceof ExternalProjectFragment) { |
| ExternalProjectFragment fragment = (ExternalProjectFragment) element; |
| |
| try { |
| if (filePath |
| .removeLastSegments(1) |
| .toFile() |
| .getCanonicalPath() |
| .startsWith( |
| fragment.getPath().toFile() |
| .getCanonicalPath()) == true) { |
| IPath folderPath = new Path(filePath |
| .removeLastSegments(1).toFile() |
| .getCanonicalPath()); |
| folderPath = folderPath |
| .removeFirstSegments(new Path( |
| fragment.getPath().toFile() |
| .getCanonicalPath()) |
| .segmentCount()); |
| IScriptFolder folder = fragment |
| .getScriptFolder(folderPath); |
| if ((folder != null) |
| && (folder.exists() == true)) { |
| ISourceModule module = folder |
| .getSourceModule(filePath |
| .lastSegment()); |
| if (module != null) { |
| modules[0] = module; |
| } |
| } |
| } |
| } catch (IOException ixcn) { |
| ixcn.printStackTrace(); |
| } |
| |
| shouldDescend = false; |
| } else { |
| shouldDescend = ((element instanceof IScriptProject) || (element instanceof IScriptModel)); |
| } |
| } |
| |
| return shouldDescend; |
| } |
| |
| }); |
| } catch (ModelException mxcn) { |
| mxcn.printStackTrace(); |
| } |
| |
| return modules[0]; |
| } |
| |
| /** |
| * Returns the standard display to be used. The method first checks, if the |
| * thread calling this method has an associated display. If so, this display |
| * is returned. Otherwise the method returns the default display. |
| */ |
| public static Display getStandardDisplay() { |
| Display display; |
| display = Display.getCurrent(); |
| if (display == null) |
| display = Display.getDefault(); |
| return display; |
| } |
| |
| public static String getAdditionalInfoAffordanceString() { |
| if (!EditorsUI |
| .getPreferenceStore() |
| .getBoolean( |
| AbstractDecoratedTextEditorPreferenceConstants.EDITOR_SHOW_TEXT_HOVER_AFFORDANCE)) |
| return null; |
| return Messages.DLTKUIPlugin_additionalInfo_affordance; |
| } |
| |
| /** |
| * The save participant registry. |
| * |
| * @since 3.0 |
| */ |
| private SaveParticipantRegistry fSaveParticipantRegistry; |
| |
| /** |
| * Returns the save participant registry. |
| * |
| * @return the save participant registry, not null |
| * @since 3.0 |
| */ |
| public synchronized SaveParticipantRegistry getSaveParticipantRegistry() { |
| if (fSaveParticipantRegistry == null) |
| fSaveParticipantRegistry = new SaveParticipantRegistry(); |
| return fSaveParticipantRegistry; |
| } |
| |
| private ImagesOnFileSystemRegistry fImagesOnFSRegistry; |
| |
| /** |
| * Returns the image registry that keeps its images on the local file |
| * system. |
| * |
| * @return the image registry |
| * @since 4.0 |
| */ |
| public ImagesOnFileSystemRegistry getImagesOnFSRegistry() { |
| if (fImagesOnFSRegistry == null) { |
| fImagesOnFSRegistry = new ImagesOnFileSystemRegistry(); |
| } |
| return fImagesOnFSRegistry; |
| } |
| } |