/*******************************************************************************
* Copyright (c) 2000, 2007 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.text.completion;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IContributor;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.InvalidRegistryObjectException;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.dltk.internal.corext.util.Messages;
import org.eclipse.dltk.ui.DLTKUIPlugin;
import org.eclipse.dltk.ui.PreferenceConstants;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Link;
import org.eclipse.ui.dialogs.PreferencesUtil;
public final class CompletionProposalComputerRegistry {
private static final String EXTENSION_POINT = "scriptCompletionProposalComputer"; //$NON-NLS-1$
/** The singleton instance. */
private static CompletionProposalComputerRegistry fgSingleton = null;
/**
* Returns the default computer registry.
* <p>
* TODO keep this or add some other singleton, e.g. JavaPlugin?
* </p>
*
* @return the singleton instance
*/
public static synchronized CompletionProposalComputerRegistry getDefault() {
if (fgSingleton == null) {
fgSingleton = new CompletionProposalComputerRegistry();
}
return fgSingleton;
}
/**
* The sets of descriptors, grouped by partition type (key type:
* {@link String}, value type: {@linkplain List
* List<CompletionProposalComputerDescriptor>}).
*/
private final Map<String, List<CompletionProposalComputerDescriptor>> fDescriptorsByPartition = new HashMap<String, List<CompletionProposalComputerDescriptor>>();
/**
* Unmodifiable versions of the sets stored in
* <code>fDescriptorsByPartition</code> (key type: {@link String}, value
* type: {@linkplain List List<CompletionProposalComputerDescriptor>}
* ).
*/
private final Map<String, List<CompletionProposalComputerDescriptor>> fPublicDescriptorsByPartition = new HashMap<String, List<CompletionProposalComputerDescriptor>>();
/**
* All descriptors (element type:
* {@link CompletionProposalComputerDescriptor}).
*/
private final List<CompletionProposalComputerDescriptor> fDescriptors = new ArrayList<CompletionProposalComputerDescriptor>();
/**
* Unmodifiable view of <code>fDescriptors</code>
*/
private final List<CompletionProposalComputerDescriptor> fPublicDescriptors = Collections
.unmodifiableList(fDescriptors);
private final List<CompletionProposalCategory> fCategories = new ArrayList<CompletionProposalCategory>();
private final List<CompletionProposalCategory> fPublicCategories = Collections
.unmodifiableList(fCategories);
/**
* <code>true</code> if this registry has been loaded.
*/
private boolean fLoaded = false;
/**
* Creates a new instance.
*/
public CompletionProposalComputerRegistry() {
}
/**
* Returns the list of {@link CompletionProposalComputerDescriptor}s
* describing all extensions to the
* <code>javaCompletionProposalComputer</code> extension point for the given
* partition type.
* <p>
* A valid partition is either one of the constants defined in
* {@link org.eclipse.dltk.ui.text.IJavaPartitions} or
* {@link org.eclipse.jface.text.IDocument#DEFAULT_CONTENT_TYPE}. An empty
* list is returned if there are no extensions for the given partition.
* </p>
* <p>
* The returned list is read-only and is sorted in the order that the
* extensions were read in. There are no duplicate elements in the returned
* list. The returned list may change if plug-ins are loaded or unloaded
* while the application is running or if an extension violates the API
* contract of
* {@link org.eclipse.dltk.ui.text.java.IScriptCompletionProposalComputer}.
* When computing proposals, it is therefore imperative to copy the returned
* list before iterating over it.
* </p>
*
* @param partition
* the partition type for which to retrieve the computer
* descriptors
* @return the list of extensions to the
* <code>javaCompletionProposalComputer</code> extension point
* (element type: {@link CompletionProposalComputerDescriptor})
*/
List<CompletionProposalComputerDescriptor> getProposalComputerDescriptors(
String partition) {
ensureExtensionPointRead();
List<CompletionProposalComputerDescriptor> result = fPublicDescriptorsByPartition
.get(partition);
return result != null ? result : Collections
.<CompletionProposalComputerDescriptor> emptyList();
}
/**
* Returns the list of {@link CompletionProposalComputerDescriptor}s
* describing all extensions to the
* <code>javaCompletionProposalComputer</code> extension point.
* <p>
* The returned list is read-only and is sorted in the order that the
* extensions were read in. There are no duplicate elements in the returned
* list. The returned list may change if plug-ins are loaded or unloaded
* while the application is running or if an extension violates the API
* contract of
* {@link org.eclipse.dltk.ui.text.java.IScriptCompletionProposalComputer}.
* When computing proposals, it is therefore imperative to copy the returned
* list before iterating over it.
* </p>
*
* @return the list of extensions to the
* <code>javaCompletionProposalComputer</code> extension point
* (element type: {@link CompletionProposalComputerDescriptor})
*/
List<CompletionProposalComputerDescriptor> getProposalComputerDescriptors() {
ensureExtensionPointRead();
return fPublicDescriptors;
}
/**
* Returns the list of proposal categories contributed to the
* <code>javaCompletionProposalComputer</code> extension point.
* <p>
* <p>
* The returned list is read-only and is sorted in the order that the
* extensions were read in. There are no duplicate elements in the returned
* list. The returned list may change if plug-ins are loaded or unloaded
* while the application is running.
* </p>
*
* @return list of proposal categories contributed to the
* <code>javaCompletionProposalComputer</code> extension point
* (element type: {@link CompletionProposalCategory})
*/
public List<CompletionProposalCategory> getProposalCategories() {
ensureExtensionPointRead();
return fPublicCategories;
}
/**
* Ensures that the extensions are read and stored in
* <code>fDescriptorsByPartition</code>.
*/
private void ensureExtensionPointRead() {
boolean reload;
synchronized (this) {
reload = !fLoaded;
fLoaded = true;
}
if (reload)
reload();
}
/**
* Reloads the extensions to the extension point.
* <p>
* This method can be called more than once in order to reload from a
* changed extension registry.
* </p>
*/
public void reload() {
IExtensionRegistry registry = Platform.getExtensionRegistry();
List<IConfigurationElement> elements = new ArrayList<IConfigurationElement>(
Arrays.asList(registry.getConfigurationElementsFor(DLTKUIPlugin
.getPluginId(), EXTENSION_POINT)));
Map<String, List<CompletionProposalComputerDescriptor>> map = new HashMap<String, List<CompletionProposalComputerDescriptor>>();
List<CompletionProposalComputerDescriptor> all = new ArrayList<CompletionProposalComputerDescriptor>();
List<CompletionProposalCategory> categories = getCategories(elements);
for (Iterator<IConfigurationElement> iter = elements.iterator(); iter
.hasNext();) {
IConfigurationElement element = iter.next();
try {
CompletionProposalComputerDescriptor desc = new CompletionProposalComputerDescriptor(
element, this, categories);
final Set<String> partitions = desc.getPartitions();
for (String partition : partitions) {
List<CompletionProposalComputerDescriptor> list = map
.get(partition);
if (list == null) {
list = new ArrayList<CompletionProposalComputerDescriptor>();
map.put(partition, list);
}
list.add(desc);
}
all.add(desc);
} catch (InvalidRegistryObjectException x) {
/*
* Element is not valid any longer as the contributing plug-in
* was unloaded or for some other reason. Do not include the
* extension in the list and inform the user about it.
*/
Object[] args = { element.toString() };
String message = Messages
.format(
ScriptTextMessages.CompletionProposalComputerRegistry_invalid_message,
args);
IStatus status = new Status(IStatus.WARNING, DLTKUIPlugin
.getPluginId(), IStatus.OK, message, x);
informUser(status);
}
}
synchronized (this) {
fCategories.clear();
fCategories.addAll(categories);
Set<String> partitions = map.keySet();
fDescriptorsByPartition.keySet().retainAll(partitions);
fPublicDescriptorsByPartition.keySet().retainAll(partitions);
for (Iterator<String> it = partitions.iterator(); it.hasNext();) {
String partition = it.next();
List<CompletionProposalComputerDescriptor> old = fDescriptorsByPartition
.get(partition);
List<CompletionProposalComputerDescriptor> current = map
.get(partition);
if (old != null) {
old.clear();
old.addAll(current);
} else {
fDescriptorsByPartition.put(partition, current);
fPublicDescriptorsByPartition.put(partition, Collections
.unmodifiableList(current));
}
}
fDescriptors.clear();
fDescriptors.addAll(all);
}
}
private List<CompletionProposalCategory> getCategories(
List<IConfigurationElement> elements) {
IPreferenceStore store = DLTKUIPlugin.getDefault().getPreferenceStore();
String preference = store
.getString(PreferenceConstants.CODEASSIST_EXCLUDED_CATEGORIES);
Set<String> disabled = new HashSet<String>();
StringTokenizer tok = new StringTokenizer(preference, "\0"); //$NON-NLS-1$
while (tok.hasMoreTokens())
disabled.add(tok.nextToken());
Map<String, Integer> ordered = new HashMap<String, Integer>();
preference = store
.getString(PreferenceConstants.CODEASSIST_CATEGORY_ORDER);
tok = new StringTokenizer(preference, "\0"); //$NON-NLS-1$
while (tok.hasMoreTokens()) {
StringTokenizer inner = new StringTokenizer(tok.nextToken(), ":"); //$NON-NLS-1$
String id = inner.nextToken();
int rank = Integer.parseInt(inner.nextToken());
ordered.put(id, new Integer(rank));
}
List<CompletionProposalCategory> categories = new ArrayList<CompletionProposalCategory>();
for (Iterator<IConfigurationElement> iter = elements.iterator(); iter
.hasNext();) {
IConfigurationElement element = iter.next();
try {
if (element.getName().equals("proposalCategory")) { //$NON-NLS-1$
iter.remove(); // remove from list to leave only computers
CompletionProposalCategory category = new CompletionProposalCategory(
element, this);
categories.add(category);
category.setIncluded(!disabled.contains(category.getId()));
Integer rank = ordered.get(category.getId());
if (rank != null) {
int r = rank.intValue();
boolean separate = r < 0xffff;
category.setSeparateCommand(separate);
category.setSortOrder(r);
}
}
} catch (InvalidRegistryObjectException x) {
/*
* Element is not valid any longer as the contributing plug-in
* was unloaded or for some other reason. Do not include the
* extension in the list and inform the user about it.
*/
Object[] args = { element.toString() };
String message = Messages
.format(
ScriptTextMessages.CompletionProposalComputerRegistry_invalid_message,
args);
IStatus status = new Status(IStatus.WARNING, DLTKUIPlugin
.getPluginId(), IStatus.OK, message, x);
informUser(status);
}
}
return categories;
}
/**
* Log the status and inform the user about a misbehaving extension.
*
* @param descriptor
* the descriptor of the misbehaving extension
* @param status
* a status object that will be logged
*/
void informUser(CompletionProposalComputerDescriptor descriptor,
IStatus status) {
DLTKUIPlugin.log(status);
String title = ScriptTextMessages.CompletionProposalComputerRegistry_error_dialog_title;
CompletionProposalCategory category = descriptor.getCategory();
IContributor culprit = descriptor.getContributor();
Set<String> affectedPlugins = getAffectedContributors(category, culprit);
final String avoidHint;
final String culpritName = culprit == null ? null : culprit.getName();
if (affectedPlugins.isEmpty())
avoidHint = Messages
.format(
ScriptTextMessages.CompletionProposalComputerRegistry_messageAvoidanceHint,
new Object[] { culpritName,
category.getDisplayName() });
else
avoidHint = Messages
.format(
ScriptTextMessages.CompletionProposalComputerRegistry_messageAvoidanceHintWithWarning,
new Object[] { culpritName,
category.getDisplayName(),
toString(affectedPlugins) });
String message = status.getMessage();
// inlined from MessageDialog.openError
MessageDialog dialog = new MessageDialog(DLTKUIPlugin
.getActiveWorkbenchShell(), title, null /* default image */,
message, MessageDialog.ERROR,
new String[] { IDialogConstants.OK_LABEL }, 0) {
protected Control createCustomArea(Composite parent) {
Link link = new Link(parent, SWT.NONE);
link.setText(avoidHint);
link.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
PreferencesUtil
.createPreferenceDialogOn(
getShell(),
"org.eclipse.dltk.ui.preferences.CodeAssistPreferenceAdvanced", null, null).open(); //$NON-NLS-1$
}
});
GridData gridData = new GridData(SWT.FILL, SWT.BEGINNING, true,
false);
gridData.widthHint = this.getMinimumMessageWidth();
link.setLayoutData(gridData);
return link;
}
};
dialog.open();
}
/**
* Returns the names of contributors affected by disabling a category.
*
* @param category
* the category that would be disabled
* @param culprit
* the cuprit plug-in, which is not included in the returned list
* @return the names of the contributors other than <code>culprit</code>
* that contribute to <code>category</code> (element type:
* {@link String})
*/
private Set<String> getAffectedContributors(
CompletionProposalCategory category, IContributor culprit) {
Set<String> affectedPlugins = new HashSet<String>();
for (Iterator<CompletionProposalComputerDescriptor> it = getProposalComputerDescriptors()
.iterator(); it.hasNext();) {
CompletionProposalComputerDescriptor desc = it.next();
CompletionProposalCategory cat = desc.getCategory();
if (cat.equals(category)) {
IContributor contributor = desc.getContributor();
if (contributor != null && !culprit.equals(contributor))
affectedPlugins.add(contributor.getName());
}
}
return affectedPlugins;
}
private Object toString(Collection<String> collection) {
// strip brackets off AbstractCollection.toString()
String string = collection.toString();
return string.substring(1, string.length() - 1);
}
private void informUser(IStatus status) {
DLTKUIPlugin.log(status);
String title = ScriptTextMessages.CompletionProposalComputerRegistry_error_dialog_title;
String message = status.getMessage();
MessageDialog.openError(DLTKUIPlugin.getActiveWorkbenchShell(), title,
message);
}
}