--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2000, 2011 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.internal.ui;
+
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+
+import org.osgi.framework.BundleContext;
+import org.osgi.service.prefs.BackingStoreException;
+
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Shell;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.MultiStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.preferences.InstanceScope;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IWorkspace;
+import org.eclipse.core.resources.ResourcesPlugin;
+
+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.preference.IPreferenceStore;
+import org.eclipse.jface.preference.PreferenceConverter;
+import org.eclipse.jface.resource.ImageRegistry;
+import org.eclipse.jface.resource.JFaceResources;
+import org.eclipse.jface.util.IPropertyChangeListener;
+import org.eclipse.jface.util.PropertyChangeEvent;
+
+import org.eclipse.jface.text.templates.ContextTypeRegistry;
+import org.eclipse.jface.text.templates.TemplateContextType;
+import org.eclipse.jface.text.templates.TemplateVariableResolver;
+import org.eclipse.jface.text.templates.persistence.TemplateStore;
+
+import org.eclipse.ui.IPageLayout;
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.IWorkbenchWindow;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.forms.FormColors;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+import org.eclipse.ui.navigator.ICommonMenuConstants;
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+import org.eclipse.ui.themes.IThemeManager;
+
+import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;
+import org.eclipse.ui.texteditor.ChainedPreferenceStore;
+import org.eclipse.ui.texteditor.ConfigurationElementSorter;
+import org.eclipse.ui.texteditor.IDocumentProvider;
+
+import org.eclipse.ui.editors.text.EditorsUI;
+import org.eclipse.ui.editors.text.templates.ContributionContextTypeRegistry;
+import org.eclipse.ui.editors.text.templates.ContributionTemplateStore;
+
+import org.eclipse.jdt.core.IBuffer;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.WorkingCopyOwner;
+import org.eclipse.jdt.core.manipulation.JavaManipulation;
+
+import org.eclipse.jdt.internal.corext.fix.CleanUpRegistry;
+import org.eclipse.jdt.internal.corext.javadoc.JavaDocLocations;
+import org.eclipse.jdt.internal.corext.template.java.AbstractJavaContextType;
+import org.eclipse.jdt.internal.corext.template.java.CodeTemplateContextType;
+import org.eclipse.jdt.internal.corext.template.java.JavaContextType;
+import org.eclipse.jdt.internal.corext.template.java.SWTContextType;
+import org.eclipse.jdt.internal.corext.util.OpenTypeHistory;
+import org.eclipse.jdt.internal.corext.util.QualifiedTypeNameHistory;
+import org.eclipse.jdt.internal.corext.util.TypeFilter;
+
+import org.eclipse.jdt.ui.IContextMenuConstants;
+import org.eclipse.jdt.ui.JavaUI;
+import org.eclipse.jdt.ui.PreferenceConstants;
+import org.eclipse.jdt.ui.text.JavaTextTools;
+
+import org.eclipse.jdt.internal.ui.javaeditor.ASTProvider;
+import org.eclipse.jdt.internal.ui.javaeditor.ClassFileDocumentProvider;
+import org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitDocumentProvider;
+import org.eclipse.jdt.internal.ui.javaeditor.DocumentAdapter;
+import org.eclipse.jdt.internal.ui.javaeditor.ICompilationUnitDocumentProvider;
+import org.eclipse.jdt.internal.ui.javaeditor.WorkingCopyManager;
+import org.eclipse.jdt.internal.ui.javaeditor.saveparticipant.SaveParticipantRegistry;
+import org.eclipse.jdt.internal.ui.preferences.MembersOrderPreferenceCache;
+import org.eclipse.jdt.internal.ui.preferences.formatter.FormatterProfileStore;
+import org.eclipse.jdt.internal.ui.propertiesfileeditor.PropertiesFileDocumentProvider;
+import org.eclipse.jdt.internal.ui.text.PreferencesAdapter;
+import org.eclipse.jdt.internal.ui.text.folding.JavaFoldingStructureProviderRegistry;
+import org.eclipse.jdt.internal.ui.text.java.ContentAssistHistory;
+import org.eclipse.jdt.internal.ui.text.java.hover.JavaEditorTextHoverDescriptor;
+import org.eclipse.jdt.internal.ui.text.spelling.SpellCheckEngine;
+import org.eclipse.jdt.internal.ui.viewsupport.ImageDescriptorRegistry;
+import org.eclipse.jdt.internal.ui.viewsupport.ImagesOnFileSystemRegistry;
+import org.eclipse.jdt.internal.ui.viewsupport.ProblemMarkerManager;
+import org.eclipse.jdt.internal.ui.wizards.buildpaths.ClasspathAttributeConfigurationDescriptors;
+
+
+/**
+ * Represents the java plug-in. It provides a series of convenience methods such as
+ * access to the workbench, keeps track of elements shared by all editors and viewers
+ * of the plug-in such as document providers and find-replace-dialogs.
+ */
+public class JavaPlugin extends AbstractUIPlugin {
+
+
+ /**
+ * The view id for the workbench's Resource Navigator standard component.
+ * @since 3.6
+ */
+ public static final String ID_RES_NAV= IPageLayout.ID_RES_NAV;
+
+ /**
+ * The key to store customized templates.
+ * @since 3.0
+ */
+ private static final String TEMPLATES_KEY= "org.eclipse.jdt.ui.text.custom_templates"; //$NON-NLS-1$
+ /**
+ * The key to store customized code templates.
+ * @since 3.0
+ */
+ private static final String CODE_TEMPLATES_KEY= "org.eclipse.jdt.ui.text.custom_code_templates"; //$NON-NLS-1$
+ /**
+ * The key to store whether the legacy templates have been migrated
+ * @since 3.0
+ */
+ private static final String TEMPLATES_MIGRATION_KEY= "org.eclipse.jdt.ui.text.templates_migrated"; //$NON-NLS-1$
+ /**
+ * The key to store whether the legacy code templates have been migrated
+ * @since 3.0
+ */
+ private static final String CODE_TEMPLATES_MIGRATION_KEY= "org.eclipse.jdt.ui.text.code_templates_migrated"; //$NON-NLS-1$
+
+ private static JavaPlugin fgJavaPlugin;
+
+ private static LinkedHashMap<String, Long> fgRepeatedMessages= new LinkedHashMap<String, Long>(20, 0.75f, true) {
+ private static final long serialVersionUID= 1L;
+ @Override
+ protected boolean removeEldestEntry(java.util.Map.Entry<String, Long> eldest) {
+ return size() >= 20;
+ }
+ };
+
+ /**
+ * The template context type registry for the java editor.
+ * @since 3.0
+ */
+ private ContextTypeRegistry fContextTypeRegistry;
+ /**
+ * The code template context type registry for the java editor.
+ * @since 3.0
+ */
+ private ContextTypeRegistry fCodeTemplateContextTypeRegistry;
+
+ /**
+ * The template store for the java editor.
+ * @since 3.0
+ */
+ private TemplateStore fTemplateStore;
+ /**
+ * The coded template store for the java editor.
+ * @since 3.0
+ */
+ private TemplateStore fCodeTemplateStore;
+
+ /**
+ * Default instance of the appearance type filters.
+ * @since 3.0
+ */
+ private TypeFilter fTypeFilter;
+
+
+ private WorkingCopyManager fWorkingCopyManager;
+
+ /**
+ * @deprecated to avoid deprecation warning
+ */
+ private org.eclipse.jdt.core.IBufferFactory fBufferFactory;
+ private ICompilationUnitDocumentProvider fCompilationUnitDocumentProvider;
+ private ClassFileDocumentProvider fClassFileDocumentProvider;
+ private JavaTextTools fJavaTextTools;
+ private ProblemMarkerManager fProblemMarkerManager;
+ private ImageDescriptorRegistry fImageDescriptorRegistry;
+
+ private MembersOrderPreferenceCache fMembersOrderPreferenceCache;
+ private IPropertyChangeListener fFontPropertyChangeListener;
+
+ /**
+ * Property change listener on this plugin's preference store.
+ * @since 3.0
+ */
+ private IPropertyChangeListener fPropertyChangeListener;
+
+ private JavaEditorTextHoverDescriptor[] fJavaEditorTextHoverDescriptors;
+
+ /**
+ * The AST provider.
+ * @since 3.0
+ */
+ private ASTProvider fASTProvider;
+
+ /**
+ * The combined preference store.
+ * @since 3.0
+ */
+ private IPreferenceStore fCombinedPreferenceStore;
+
+ /**
+ * The extension point registry for the <code>org.eclipse.jdt.ui.javaFoldingStructureProvider</code>
+ * extension point.
+ *
+ * @since 3.0
+ */
+ private JavaFoldingStructureProviderRegistry fFoldingStructureProviderRegistry;
+
+ /**
+ * The shared Java properties file document provider.
+ * @since 3.1
+ */
+ private IDocumentProvider fPropertiesFileDocumentProvider;
+
+ /**
+ * Content assist history.
+ * @since 3.2
+ */
+ private ContentAssistHistory fContentAssistHistory;
+
+ /**
+ * The save participant registry.
+ * @since 3.3
+ */
+ private SaveParticipantRegistry fSaveParticipantRegistry;
+
+ /**
+ * The clean up registry
+ * @since 3.4
+ */
+ private CleanUpRegistry fCleanUpRegistry;
+
+ /**
+ * The descriptors from the 'classpathAttributeConfiguration' extension point.
+ * @since 3.3
+ */
+ private ClasspathAttributeConfigurationDescriptors fClasspathAttributeConfigurationDescriptors;
+
+ private FormToolkit fDialogsFormToolkit;
+
+ private ImagesOnFileSystemRegistry fImagesOnFSRegistry;
+
+ /**
+ * Theme listener.
+ * @since 3.3
+ */
+ private IPropertyChangeListener fThemeListener;
+
+ public static JavaPlugin getDefault() {
+ return fgJavaPlugin;
+ }
+
+ public static IWorkspace getWorkspace() {
+ return ResourcesPlugin.getWorkspace();
+ }
+
+ public static IWorkbenchPage getActivePage() {
+ return getDefault().internalGetActivePage();
+ }
+
+ public static IWorkbenchWindow getActiveWorkbenchWindow() {
+ return getDefault().getWorkbench().getActiveWorkbenchWindow();
+ }
+
+ public static Shell getActiveWorkbenchShell() {
+ IWorkbenchWindow window= getActiveWorkbenchWindow();
+ if (window != null) {
+ return window.getShell();
+ }
+ return null;
+ }
+
+ public static String getPluginId() {
+ return JavaUI.ID_PLUGIN;
+ }
+
+ public static void log(IStatus status) {
+ getDefault().getLog().log(status);
+ }
+
+ public static void logErrorMessage(String message) {
+ log(new Status(IStatus.ERROR, getPluginId(), IJavaStatusConstants.INTERNAL_ERROR, message, null));
+ }
+
+ public static void logErrorStatus(String message, IStatus status) {
+ if (status == null) {
+ logErrorMessage(message);
+ return;
+ }
+ MultiStatus multi= new MultiStatus(getPluginId(), IJavaStatusConstants.INTERNAL_ERROR, message, null);
+ multi.add(status);
+ log(multi);
+ }
+
+ public static void log(Throwable e) {
+ log(new Status(IStatus.ERROR, getPluginId(), IJavaStatusConstants.INTERNAL_ERROR, JavaUIMessages.JavaPlugin_internal_error, e));
+ }
+
+ /**
+ * Log a message that is potentially repeated after a very short time.
+ * The first time this method is called with a given message, the
+ * message is written to the log along with the detail message and a stack trace.
+ * <p>
+ * Only intended for use in debug statements.
+ *
+ * @param message the (generic) message
+ * @param detail the detail message
+ */
+ public static void logRepeatedMessage(String message, String detail) {
+ long now= System.currentTimeMillis();
+ boolean writeToLog= true;
+ if (fgRepeatedMessages.containsKey(message)) {
+ long last= fgRepeatedMessages.get(message).longValue();
+ writeToLog= now - last > 5000;
+ }
+ fgRepeatedMessages.put(message, new Long(now));
+ if (writeToLog)
+ log(new Exception(message + detail).fillInStackTrace());
+ }
+
+ public static boolean isDebug() {
+ return getDefault().isDebugging();
+ }
+
+ public static ImageDescriptorRegistry getImageDescriptorRegistry() {
+ return getDefault().internalGetImageDescriptorRegistry();
+ }
+
+ public JavaPlugin() {
+ super();
+ fgJavaPlugin = this;
+ }
+
+ /* (non - Javadoc)
+ * Method declared in plug-in
+ */
+ @Override
+ public void start(BundleContext context) throws Exception {
+ super.start(context);
+
+ WorkingCopyOwner.setPrimaryBufferProvider(new WorkingCopyOwner() {
+ @Override
+ public IBuffer createBuffer(ICompilationUnit workingCopy) {
+ ICompilationUnit original= workingCopy.getPrimary();
+ IResource resource= original.getResource();
+ if (resource instanceof IFile)
+ return new DocumentAdapter(workingCopy, (IFile) resource);
+ return DocumentAdapter.NULL;
+ }
+ });
+
+ ensurePreferenceStoreBackwardsCompatibility();
+
+ // make sure org.eclipse.jdt.core.manipulation is loaded too
+ // can be removed if JavaElementPropertyTester is moved down to jdt.core (bug 127085)
+ JavaManipulation.class.toString();
+
+ if (PlatformUI.isWorkbenchRunning()) {
+ // Initialize AST provider
+ getASTProvider();
+
+ fThemeListener= new IPropertyChangeListener() {
+ public void propertyChange(PropertyChangeEvent event) {
+ if (IThemeManager.CHANGE_CURRENT_THEME.equals(event.getProperty()))
+ JavaUIPreferenceInitializer.setThemeBasedPreferences(PreferenceConstants.getPreferenceStore(), true);
+ }
+ };
+ PlatformUI.getWorkbench().getThemeManager().addPropertyChangeListener(fThemeListener);
+ new InitializeAfterLoadJob().schedule(); // last call in start, see bug 191193
+ }
+ }
+
+ /* package */ static void initializeAfterLoad(IProgressMonitor monitor) {
+ OpenTypeHistory.getInstance().checkConsistency(monitor);
+ }
+
+ /**
+ * Private deprecated method to avoid deprecation warnings
+ *
+ * @return the deprecated preference store
+ * @deprecated to avoid deprecation warnings
+ */
+ private static IPreferenceStore getDeprecatedWorkbenchPreferenceStore() {
+ return PlatformUI.getWorkbench().getPreferenceStore();
+ }
+
+ /** @deprecated to avoid deprecation warnings */
+ private static final String DEPRECATED_EDITOR_TAB_WIDTH= PreferenceConstants.EDITOR_TAB_WIDTH;
+
+ /** @deprecated to avoid deprecation warnings */
+ private static final String DEPRECATED_REFACTOR_ERROR_PAGE_SEVERITY_THRESHOLD= PreferenceConstants.REFACTOR_ERROR_PAGE_SEVERITY_THRESHOLD;
+
+ /** @deprecated to avoid deprecation warnings */
+ private static final String DEPRECATED_CODEASSIST_ORDER_PROPOSALS= PreferenceConstants.CODEASSIST_ORDER_PROPOSALS;
+
+ /**
+ * Installs backwards compatibility for the preference store.
+ */
+ private void ensurePreferenceStoreBackwardsCompatibility() {
+
+ IPreferenceStore store= getPreferenceStore();
+
+ // must add here to guarantee that it is the first in the listener list
+ fMembersOrderPreferenceCache= new MembersOrderPreferenceCache();
+ fMembersOrderPreferenceCache.install(store);
+
+
+ /*
+ * Installs backwards compatibility: propagate the Java editor font from a
+ * pre-2.1 plug-in to the Platform UI's preference store to preserve
+ * the Java editor font from a pre-2.1 workspace. This is done only
+ * once.
+ */
+ String fontPropagatedKey= "fontPropagated"; //$NON-NLS-1$
+ if (store.contains(JFaceResources.TEXT_FONT) && !store.isDefault(JFaceResources.TEXT_FONT)) {
+ if (!store.getBoolean(fontPropagatedKey))
+ PreferenceConverter.setValue(
+ getDeprecatedWorkbenchPreferenceStore(), PreferenceConstants.EDITOR_TEXT_FONT, PreferenceConverter.getFontDataArray(store, JFaceResources.TEXT_FONT));
+ }
+ store.setValue(fontPropagatedKey, true);
+
+ /*
+ * Backwards compatibility: set the Java editor font in this plug-in's
+ * preference store to let older versions access it. Since 2.1 the
+ * Java editor font is managed by the workbench font preference page.
+ */
+ PreferenceConverter.putValue(store, JFaceResources.TEXT_FONT, JFaceResources.getFontRegistry().getFontData(PreferenceConstants.EDITOR_TEXT_FONT));
+
+ fFontPropertyChangeListener= new IPropertyChangeListener() {
+ public void propertyChange(PropertyChangeEvent event) {
+ if (PreferenceConstants.EDITOR_TEXT_FONT.equals(event.getProperty()))
+ PreferenceConverter.putValue(getPreferenceStore(), JFaceResources.TEXT_FONT, JFaceResources.getFontRegistry().getFontData(PreferenceConstants.EDITOR_TEXT_FONT));
+ }
+ };
+ JFaceResources.getFontRegistry().addListener(fFontPropertyChangeListener);
+
+ /*
+ * Backwards compatibility: propagate the Java editor tab width from a
+ * pre-3.0 plug-in to the new preference key. This is done only once.
+ */
+ final String oldTabWidthKey= DEPRECATED_EDITOR_TAB_WIDTH;
+ final String newTabWidthKey= AbstractDecoratedTextEditorPreferenceConstants.EDITOR_TAB_WIDTH;
+ String tabWidthPropagatedKey= "tabWidthPropagated"; //$NON-NLS-1$
+ if (store.contains(oldTabWidthKey) && !store.isDefault(oldTabWidthKey)) {
+ if (!store.getBoolean(tabWidthPropagatedKey))
+ store.setValue(newTabWidthKey, store.getInt(oldTabWidthKey));
+ }
+ store.setValue(tabWidthPropagatedKey, true);
+
+ /*
+ * Backwards compatibility: set the Java editor tab width in this plug-in's
+ * preference store with the old key to let older versions access it.
+ * Since 3.0 the tab width is managed by the extended text editor and
+ * uses a new key.
+ */
+ store.putValue(oldTabWidthKey, store.getString(newTabWidthKey));
+
+ fPropertyChangeListener= new IPropertyChangeListener() {
+ public void propertyChange(PropertyChangeEvent event) {
+ if (newTabWidthKey.equals(event.getProperty())) {
+ IPreferenceStore prefStore= getPreferenceStore();
+ prefStore.putValue(oldTabWidthKey, prefStore.getString(newTabWidthKey));
+ }
+ }
+ };
+ store.addPropertyChangeListener(fPropertyChangeListener);
+
+ /*
+ * Backward compatibility for the refactoring preference key.
+ */
+// store.setValue(
+// PreferenceConstants.REFACTOR_ERROR_PAGE_SEVERITY_THRESHOLD,
+// RefactoringCore.getConditionCheckingFailedSeverity());
+
+ // The commented call above triggers the eager loading of the LTK core plug-in
+ // Since the condition checking failed severity is guaranteed to be of RefactoringStatus.SEVERITY_WARNING,
+ // we directly insert the inlined value of this constant
+ store.setToDefault(DEPRECATED_REFACTOR_ERROR_PAGE_SEVERITY_THRESHOLD);
+
+ if (!store.getBoolean(JavaDocLocations.PREF_JAVADOCLOCATIONS_MIGRATED)) {
+ JavaDocLocations.migrateToClasspathAttributes();
+ }
+
+ FormatterProfileStore.checkCurrentOptionsVersion();
+
+ /*
+ * Backward compatibility: migrate "alphabetic ordering" preference to point the sorter
+ * preference to the alphabetic sorter.
+ */
+ String proposalOrderMigrated= "proposalOrderMigrated"; //$NON-NLS-1$
+
+ if (store.contains(DEPRECATED_CODEASSIST_ORDER_PROPOSALS)) {
+ if (!store.getBoolean(proposalOrderMigrated)) {
+ boolean alphabetic= store.getBoolean(DEPRECATED_CODEASSIST_ORDER_PROPOSALS);
+ if (alphabetic)
+ store.setValue(PreferenceConstants.CODEASSIST_SORTER, "org.eclipse.jdt.ui.AlphabeticSorter"); //$NON-NLS-1$
+ }
+ }
+ store.setValue(proposalOrderMigrated, true);
+
+ }
+
+ /**
+ * Uninstalls backwards compatibility for the preference store.
+ */
+ private void uninstallPreferenceStoreBackwardsCompatibility() {
+ JFaceResources.getFontRegistry().removeListener(fFontPropertyChangeListener);
+ getPreferenceStore().removePropertyChangeListener(fPropertyChangeListener);
+ }
+
+ /*
+ * @see org.eclipse.ui.plugin.AbstractUIPlugin#createImageRegistry()
+ */
+ @Override
+ protected ImageRegistry createImageRegistry() {
+ return JavaPluginImages.getImageRegistry();
+ }
+
+ /*
+ * @see org.eclipse.core.runtime.Plugin#stop
+ */
+ @Override
+ public void stop(BundleContext context) throws Exception {
+ try {
+ if (fImageDescriptorRegistry != null)
+ fImageDescriptorRegistry.dispose();
+
+ if (fASTProvider != null) {
+ fASTProvider.dispose();
+ fASTProvider= null;
+ }
+
+ if (fWorkingCopyManager != null) {
+ fWorkingCopyManager.shutdown();
+ fWorkingCopyManager= null;
+ }
+
+ if (fCompilationUnitDocumentProvider != null) {
+ fCompilationUnitDocumentProvider.shutdown();
+ fCompilationUnitDocumentProvider= null;
+ }
+
+ if (fJavaTextTools != null) {
+ fJavaTextTools.dispose();
+ fJavaTextTools= null;
+ }
+
+ if (fTypeFilter != null) {
+ fTypeFilter.dispose();
+ fTypeFilter= null;
+ }
+
+ if (fContentAssistHistory != null) {
+ ContentAssistHistory.store(fContentAssistHistory, getPluginPreferences(), PreferenceConstants.CODEASSIST_LRU_HISTORY);
+ fContentAssistHistory= null;
+ }
+
+ uninstallPreferenceStoreBackwardsCompatibility();
+
+ if (fTemplateStore != null) {
+ fTemplateStore.stopListeningForPreferenceChanges();
+ fTemplateStore= null;
+ }
+
+ if (fCodeTemplateStore != null) {
+ fCodeTemplateStore.stopListeningForPreferenceChanges();
+ fCodeTemplateStore= null;
+ }
+
+ if (fMembersOrderPreferenceCache != null) {
+ fMembersOrderPreferenceCache.dispose();
+ fMembersOrderPreferenceCache= null;
+ }
+
+ if (fSaveParticipantRegistry != null) {
+ fSaveParticipantRegistry.dispose();
+ fSaveParticipantRegistry= null;
+ }
+
+ if (fDialogsFormToolkit != null) {
+ fDialogsFormToolkit.dispose();
+ fDialogsFormToolkit= null;
+ }
+
+ if (fThemeListener != null) {
+ PlatformUI.getWorkbench().getThemeManager().removePropertyChangeListener(fThemeListener);
+ fThemeListener= null;
+ }
+
+ if (fImagesOnFSRegistry != null) {
+ fImagesOnFSRegistry.dispose();
+ fImagesOnFSRegistry= null;
+ }
+
+ SpellCheckEngine.shutdownInstance();
+
+ QualifiedTypeNameHistory.getDefault().save();
+
+ // must add here to guarantee that it is the first in the listener list
+
+ OpenTypeHistory.shutdown();
+ } finally {
+ super.stop(context);
+ }
+ }
+
+ private IWorkbenchPage internalGetActivePage() {
+ IWorkbenchWindow window= getWorkbench().getActiveWorkbenchWindow();
+ if (window == null)
+ return null;
+ return window.getActivePage();
+ }
+
+ /**
+ * Private deprecated method to avoid deprecation warnings
+ *
+ * @return the deprecated buffer factory
+ * @deprecated to avoid deprecation warnings
+ */
+ public synchronized org.eclipse.jdt.core.IBufferFactory getBufferFactory() {
+ if (fBufferFactory == null)
+ fBufferFactory= new org.eclipse.jdt.internal.ui.javaeditor.CustomBufferFactory();
+ return fBufferFactory;
+ }
+
+ public synchronized ICompilationUnitDocumentProvider getCompilationUnitDocumentProvider() {
+ if (fCompilationUnitDocumentProvider == null)
+ fCompilationUnitDocumentProvider= new CompilationUnitDocumentProvider();
+ return fCompilationUnitDocumentProvider;
+ }
+
+ /**
+ * Returns the shared document provider for Java properties files
+ * used by this plug-in instance.
+ *
+ * @return the shared document provider for Java properties files
+ * @since 3.1
+ */
+ public synchronized IDocumentProvider getPropertiesFileDocumentProvider() {
+ if (fPropertiesFileDocumentProvider == null)
+ fPropertiesFileDocumentProvider= new PropertiesFileDocumentProvider();
+ return fPropertiesFileDocumentProvider;
+ }
+
+ public synchronized ClassFileDocumentProvider getClassFileDocumentProvider() {
+ if (fClassFileDocumentProvider == null)
+ fClassFileDocumentProvider= new ClassFileDocumentProvider();
+ return fClassFileDocumentProvider;
+ }
+
+ public synchronized WorkingCopyManager getWorkingCopyManager() {
+ if (fWorkingCopyManager == null) {
+ ICompilationUnitDocumentProvider provider= getCompilationUnitDocumentProvider();
+ fWorkingCopyManager= new WorkingCopyManager(provider);
+ }
+ return fWorkingCopyManager;
+ }
+
+ public synchronized ProblemMarkerManager getProblemMarkerManager() {
+ if (fProblemMarkerManager == null)
+ fProblemMarkerManager= new ProblemMarkerManager();
+ return fProblemMarkerManager;
+ }
+
+ public synchronized JavaTextTools getJavaTextTools() {
+ if (fJavaTextTools == null)
+ fJavaTextTools= new JavaTextTools(getPreferenceStore(), getJavaCorePluginPreferences());
+ return fJavaTextTools;
+ }
+
+ /**
+ * Returns the Java Core plug-in preferences.
+ *
+ * @return the Java Core plug-in preferences
+ * @since 3.7
+ */
+ public static org.eclipse.core.runtime.Preferences getJavaCorePluginPreferences() {
+ return JavaCore.getPlugin().getPluginPreferences();
+ }
+
+ /**
+ * Returns the AST provider.
+ *
+ * @return the AST provider
+ * @since 3.0
+ */
+ public synchronized ASTProvider getASTProvider() {
+ if (fASTProvider == null)
+ fASTProvider= new ASTProvider();
+
+ return fASTProvider;
+ }
+
+ public synchronized MembersOrderPreferenceCache getMemberOrderPreferenceCache() {
+ // initialized on startup
+ return fMembersOrderPreferenceCache;
+ }
+
+
+ public synchronized TypeFilter getTypeFilter() {
+ if (fTypeFilter == null)
+ fTypeFilter= new TypeFilter();
+ return fTypeFilter;
+ }
+
+ public FormToolkit getDialogsFormToolkit() {
+ if (fDialogsFormToolkit == null) {
+ FormColors colors= new FormColors(Display.getCurrent());
+ colors.setBackground(null);
+ colors.setForeground(null);
+ fDialogsFormToolkit= new FormToolkit(colors);
+ }
+ return fDialogsFormToolkit;
+ }
+
+ /**
+ * Returns all Java editor text hovers contributed to the workbench.
+ *
+ * @return an array of JavaEditorTextHoverDescriptor
+ * @since 2.1
+ */
+ public synchronized JavaEditorTextHoverDescriptor[] getJavaEditorTextHoverDescriptors() {
+ if (fJavaEditorTextHoverDescriptors == null) {
+ fJavaEditorTextHoverDescriptors= JavaEditorTextHoverDescriptor.getContributedHovers();
+ ConfigurationElementSorter sorter= new ConfigurationElementSorter() {
+ /*
+ * @see org.eclipse.ui.texteditor.ConfigurationElementSorter#getConfigurationElement(java.lang.Object)
+ */
+ @Override
+ public IConfigurationElement getConfigurationElement(Object object) {
+ return ((JavaEditorTextHoverDescriptor)object).getConfigurationElement();
+ }
+ };
+ sorter.sort(fJavaEditorTextHoverDescriptors);
+
+ // Move Best Match hover to front
+ for (int i= 0; i < fJavaEditorTextHoverDescriptors.length - 1; i++) {
+ if (PreferenceConstants.ID_BESTMATCH_HOVER.equals(fJavaEditorTextHoverDescriptors[i].getId())) {
+ JavaEditorTextHoverDescriptor hoverDescriptor= fJavaEditorTextHoverDescriptors[i];
+ for (int j= i; j > 0; j--)
+ fJavaEditorTextHoverDescriptors[j]= fJavaEditorTextHoverDescriptors[j-1];
+ fJavaEditorTextHoverDescriptors[0]= hoverDescriptor;
+ break;
+ }
+
+ }
+ }
+
+ return fJavaEditorTextHoverDescriptors;
+ }
+
+ /**
+ * Resets the Java 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>
+ *
+ * @since 2.1
+ */
+ public synchronized void resetJavaEditorTextHoverDescriptors() {
+ fJavaEditorTextHoverDescriptors= null;
+ }
+
+ /**
+ * Creates the Java 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));
+ }
+
+ /**
+ * Returns the template context type registry for the java plug-in.
+ *
+ * @return the template context type registry for the java plug-in
+ * @since 3.0
+ */
+ public synchronized ContextTypeRegistry getTemplateContextRegistry() {
+ if (fContextTypeRegistry == null) {
+ ContributionContextTypeRegistry registry= new ContributionContextTypeRegistry(JavaUI.ID_CU_EDITOR);
+
+ TemplateContextType all_contextType= registry.getContextType(JavaContextType.ID_ALL);
+ ((AbstractJavaContextType) all_contextType).initializeContextTypeResolvers();
+
+ registerJavaContext(registry, JavaContextType.ID_MEMBERS, all_contextType);
+ registerJavaContext(registry, JavaContextType.ID_STATEMENTS, all_contextType);
+
+ registerJavaContext(registry, SWTContextType.ID_ALL, all_contextType);
+ all_contextType= registry.getContextType(SWTContextType.ID_ALL);
+
+ registerJavaContext(registry, SWTContextType.ID_MEMBERS, all_contextType);
+ registerJavaContext(registry, SWTContextType.ID_STATEMENTS, all_contextType);
+
+ fContextTypeRegistry= registry;
+ }
+
+ return fContextTypeRegistry;
+ }
+
+ /**
+ * Registers the given Java template context.
+ *
+ * @param registry the template context type registry
+ * @param id the context type id
+ * @param parent the parent context type
+ * @since 3.4
+ */
+ private static void registerJavaContext(ContributionContextTypeRegistry registry, String id, TemplateContextType parent) {
+ TemplateContextType contextType= registry.getContextType(id);
+ Iterator<TemplateVariableResolver> iter= parent.resolvers();
+ while (iter.hasNext())
+ contextType.addResolver(iter.next());
+ }
+
+ /**
+ * Returns the template store for the java editor templates.
+ *
+ * @return the template store for the java editor templates
+ * @since 3.0
+ */
+ public TemplateStore getTemplateStore() {
+ if (fTemplateStore == null) {
+ final IPreferenceStore store= getPreferenceStore();
+ boolean alreadyMigrated= store.getBoolean(TEMPLATES_MIGRATION_KEY);
+ if (alreadyMigrated)
+ fTemplateStore= new ContributionTemplateStore(getTemplateContextRegistry(), store, TEMPLATES_KEY);
+ else {
+ fTemplateStore= new CompatibilityTemplateStore(getTemplateContextRegistry(), store, TEMPLATES_KEY, getOldTemplateStoreInstance());
+ store.setValue(TEMPLATES_MIGRATION_KEY, true);
+ }
+
+ try {
+ fTemplateStore.load();
+ } catch (IOException e) {
+ log(e);
+ }
+ fTemplateStore.startListeningForPreferenceChanges();
+ }
+
+ return fTemplateStore;
+ }
+
+ /**
+ * Private deprecated method to avoid deprecation warnings
+ *
+ * @return the deprecated template store
+ * @deprecated to avoid deprecation warnings
+ */
+ private org.eclipse.jdt.internal.corext.template.java.Templates getOldTemplateStoreInstance() {
+ return org.eclipse.jdt.internal.corext.template.java.Templates.getInstance();
+ }
+
+ /**
+ * Returns the template context type registry for the code generation
+ * templates.
+ *
+ * @return the template context type registry for the code generation
+ * templates
+ * @since 3.0
+ */
+ public ContextTypeRegistry getCodeTemplateContextRegistry() {
+ if (fCodeTemplateContextTypeRegistry == null) {
+ fCodeTemplateContextTypeRegistry= new ContributionContextTypeRegistry();
+
+ CodeTemplateContextType.registerContextTypes(fCodeTemplateContextTypeRegistry);
+ }
+
+ return fCodeTemplateContextTypeRegistry;
+ }
+
+ /**
+ * Returns the template store for the code generation templates.
+ *
+ * @return the template store for the code generation templates
+ * @since 3.0
+ */
+ public TemplateStore getCodeTemplateStore() {
+ if (fCodeTemplateStore == null) {
+ IPreferenceStore store= getPreferenceStore();
+ boolean alreadyMigrated= store.getBoolean(CODE_TEMPLATES_MIGRATION_KEY);
+ if (alreadyMigrated)
+ fCodeTemplateStore= new ContributionTemplateStore(getCodeTemplateContextRegistry(), store, CODE_TEMPLATES_KEY);
+ else {
+ fCodeTemplateStore= new CompatibilityTemplateStore(getCodeTemplateContextRegistry(), store, CODE_TEMPLATES_KEY, getOldCodeTemplateStoreInstance());
+ store.setValue(CODE_TEMPLATES_MIGRATION_KEY, true);
+ }
+
+ try {
+ fCodeTemplateStore.load();
+ } catch (IOException e) {
+ log(e);
+ }
+
+ fCodeTemplateStore.startListeningForPreferenceChanges();
+
+ // compatibility / bug fixing code for duplicated templates
+ // TODO remove for 3.0
+ CompatibilityTemplateStore.pruneDuplicates(fCodeTemplateStore, true);
+
+ }
+
+ return fCodeTemplateStore;
+ }
+
+ /**
+ * Private deprecated method to avoid deprecation warnings
+ *
+ * @return the deprecated code template store
+ * @deprecated to avoid deprecation warnings
+ */
+ private org.eclipse.jdt.internal.corext.template.java.CodeTemplates getOldCodeTemplateStoreInstance() {
+ return org.eclipse.jdt.internal.corext.template.java.CodeTemplates.getInstance();
+ }
+
+ private synchronized ImageDescriptorRegistry internalGetImageDescriptorRegistry() {
+ if (fImageDescriptorRegistry == null)
+ fImageDescriptorRegistry= new ImageDescriptorRegistry();
+ return fImageDescriptorRegistry;
+ }
+
+ /**
+ * Returns a combined preference store, this store is read-only.
+ *
+ * @return the combined preference store
+ *
+ * @since 3.0
+ */
+ public IPreferenceStore getCombinedPreferenceStore() {
+ if (fCombinedPreferenceStore == null) {
+ IPreferenceStore generalTextStore= EditorsUI.getPreferenceStore();
+ fCombinedPreferenceStore= new ChainedPreferenceStore(new IPreferenceStore[] { getPreferenceStore(), new PreferencesAdapter(getJavaCorePluginPreferences()), generalTextStore });
+ }
+ return fCombinedPreferenceStore;
+ }
+
+ /**
+ * Flushes the instance scope of this plug-in.
+ *
+ * @since 3.7
+ */
+ public static void flushInstanceScope() {
+ try {
+ InstanceScope.INSTANCE.getNode(JavaUI.ID_PLUGIN).flush();
+ } catch (BackingStoreException e) {
+ log(e);
+ }
+ }
+
+ /**
+ * Returns the registry of the extensions to the
+ * <code>org.eclipse.jdt.ui.javaFoldingStructureProvider</code> extension point.
+ *
+ * @return the registry of contributed <code>IJavaFoldingStructureProvider</code>
+ * @since 3.0
+ */
+ public synchronized JavaFoldingStructureProviderRegistry getFoldingStructureProviderRegistry() {
+ if (fFoldingStructureProviderRegistry == null)
+ fFoldingStructureProviderRegistry= new JavaFoldingStructureProviderRegistry();
+ return fFoldingStructureProviderRegistry;
+ }
+
+ /**
+ * Returns the save participant registry.
+ *
+ * @return the save participant registry, not null
+ * @since 3.3
+ */
+ public synchronized SaveParticipantRegistry getSaveParticipantRegistry() {
+ if (fSaveParticipantRegistry == null)
+ fSaveParticipantRegistry= new SaveParticipantRegistry();
+ return fSaveParticipantRegistry;
+ }
+
+ public synchronized CleanUpRegistry getCleanUpRegistry() {
+ if (fCleanUpRegistry == null)
+ fCleanUpRegistry= new CleanUpRegistry();
+
+ return fCleanUpRegistry;
+ }
+
+ /**
+ * Returns the Java content assist history.
+ *
+ * @return the Java content assist history
+ * @since 3.2
+ */
+ public ContentAssistHistory getContentAssistHistory() {
+ if (fContentAssistHistory == null) {
+ try {
+ fContentAssistHistory= ContentAssistHistory.load(getPluginPreferences(), PreferenceConstants.CODEASSIST_LRU_HISTORY);
+ } catch (CoreException x) {
+ log(x);
+ }
+ if (fContentAssistHistory == null)
+ fContentAssistHistory= new ContentAssistHistory();
+ }
+
+ return fContentAssistHistory;
+ }
+
+ /**
+ * Returns a section in the Java plugin's dialog settings. If the section doesn't exist yet, it is created.
+ *
+ * @param name the name of the section
+ * @return the section of the given name
+ * @since 3.2
+ */
+ public IDialogSettings getDialogSettingsSection(String name) {
+ IDialogSettings dialogSettings= getDialogSettings();
+ IDialogSettings section= dialogSettings.getSection(name);
+ if (section == null) {
+ section= dialogSettings.addNewSection(name);
+ }
+ return section;
+ }
+
+ /**
+ * Returns the descriptors for the class path attribute configuration extension point
+ *
+ * @return access to the descriptors for the class path attribute configuration extension point
+ * @since 3.3
+ */
+ public ClasspathAttributeConfigurationDescriptors getClasspathAttributeConfigurationDescriptors() {
+ if (fClasspathAttributeConfigurationDescriptors == null) {
+ fClasspathAttributeConfigurationDescriptors= new ClasspathAttributeConfigurationDescriptors();
+ }
+ return fClasspathAttributeConfigurationDescriptors;
+ }
+
+ /**
+ * Returns the image registry that keeps its images on the local file system.
+ *
+ * @return the image registry
+ * @since 3.4
+ */
+ public ImagesOnFileSystemRegistry getImagesOnFSRegistry() {
+ if (fImagesOnFSRegistry == null) {
+ fImagesOnFSRegistry= new ImagesOnFileSystemRegistry();
+ }
+ return fImagesOnFSRegistry;
+ }
+
+ /**
+ * Returns the content assist additional info focus affordance string.
+ *
+ * @return the affordance string which is <code>null</code> if the
+ * preference is disabled
+ *
+ * @see EditorsUI#getTooltipAffordanceString()
+ * @since 3.4
+ */
+ public static final String getAdditionalInfoAffordanceString() {
+ if (!EditorsUI.getPreferenceStore().getBoolean(AbstractDecoratedTextEditorPreferenceConstants.EDITOR_SHOW_TEXT_HOVER_AFFORDANCE))
+ return null;
+
+ return JavaUIMessages.JavaPlugin_additionalInfo_affordance;
+ }
+}
git://git.uio.no / ifi-stolz-refaktor.git / blobdiff