bundles/org.eclipse.ui.navigator/src/org/eclipse/ui/internal/navigator/actions/CommonActionDescriptorManager.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2015 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.ui.internal.navigator.actions;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import org.eclipse.core.runtime.Assert;
 import org.eclipse.core.runtime.IConfigurationElement;
 import org.eclipse.core.runtime.ISafeRunnable;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.SafeRunner;
 import org.eclipse.jface.viewers.IStructuredSelection;
 import org.eclipse.jface.viewers.StructuredSelection;
 import org.eclipse.ui.actions.ActionContext;
 import org.eclipse.ui.internal.navigator.NavigatorPlugin;
 import org.eclipse.ui.internal.navigator.extensions.NavigatorContentRegistryReader;
 import org.eclipse.ui.navigator.INavigatorContentService;
 import org.eclipse.ui.navigator.Priority;

 /**
  * Manages descriptors consumed from the 'actionProvider' elements of the
  * <b>org.eclipse.ui.navigator.navigatorContent</b> extension point.
  *
  * @since 3.2
  *
  */
 public class CommonActionDescriptorManager {

 	private static final CommonActionProviderDescriptor[] NO_DESCRIPTORS = new CommonActionProviderDescriptor[0];

 	private static final CommonActionDescriptorManager INSTANCE = new CommonActionDescriptorManager();

 	private CommonActionDescriptorManager() {

 		new ActionProviderRegistry().readRegistry();
 	}

 	/**
 	 * @return the singleton instance of the registry
 	 */
 	public static CommonActionDescriptorManager getInstance() {
 		return INSTANCE;
 	}

 	/* Provides a map of (ids, CommonActionProviderDescriptor)-pairs. */
 	private final Map<String, CommonActionProviderDescriptor> dependentDescriptors = new LinkedHashMap<String, CommonActionProviderDescriptor>();

 	/* Provides a map of (ids, CommonActionProviderDescriptor)-pairs. */
 	private final Map<String, CommonActionProviderDescriptor> rootDescriptors = new LinkedHashMap<String, CommonActionProviderDescriptor>();

 	/* Provides a map of (ids, CommonActionProviderDescriptor)-pairs. */
 	private final Set<CommonActionProviderDescriptor> overridingDescriptors = new LinkedHashSet<CommonActionProviderDescriptor>();


 	private final LinkedList<CommonActionProviderDescriptor> rootDescriptorsList = new LinkedList<CommonActionProviderDescriptor>();
 	private final LinkedList<CommonActionProviderDescriptor> dependentDescriptorsList = new LinkedList<CommonActionProviderDescriptor>();


 	/**
 	 *
 	 * @param aDescriptor
 	 *            A valid descriptor to begin managing.
 	 */
 	protected void addActionDescriptor(
 			CommonActionProviderDescriptor aDescriptor) {

 		if (aDescriptor.getDependsOnId() == null) {
 			rootDescriptorsList.add(aDescriptor);
 		} else {
 			dependentDescriptorsList.add(aDescriptor);
 		}

 		if (aDescriptor.getOverridesId() != null) {
 			overridingDescriptors.add(aDescriptor);
 		}
 	}

 	private int findId(List<CommonActionProviderDescriptor> list, String id) {
 		for (int i= 0, len = list.size(); i< len; i++) {
 			CommonActionProviderDescriptor desc = list.get(i);
 			if (desc.getId().equals(id))
 				return i;
 		}
 		return -1;
 	}


 	/**
 	 * Sorts the descriptors according to the appearsBefore property
 	 */
 	private void sortDescriptors(LinkedList<CommonActionProviderDescriptor> list, Map<String, CommonActionProviderDescriptor> outMap) {
 		boolean changed = true;
 		while (changed) {
 			changed = false;
 			for (int i = 0, len = list.size(); i < len; i++) {
 				CommonActionProviderDescriptor desc = list.get(i);
 				if (desc.getAppearsBeforeId() != null) {
 					int beforeInd = findId(list, desc.getAppearsBeforeId());
 					if (beforeInd < i) {
 						list.add(beforeInd, desc);
 						list.remove(i + 1);
 						changed = true;
 					}
 				}
 			}
 		}
 		for (int i = 0, len = list.size(); i < len; i++) {
 			CommonActionProviderDescriptor desc = list.get(i);
 			outMap.put(desc.getDefinedId(), desc);
 		}
 	}


 	/**
 	 * Orders the set of available descriptors based on the order defined by the
 	 * <i>dependsOn</i> attribute from the <actionProvider /> element in
 	 * <b>org.eclipse.ui.navigator.navigatorContent</b>
 	 *
 	 */
 	protected void computeOrdering() {
 		sortDescriptors(rootDescriptorsList, rootDescriptors);
 		sortDescriptors(dependentDescriptorsList, dependentDescriptors);

 		CommonActionProviderDescriptor dependentDescriptor;
 		CommonActionProviderDescriptor requiredDescriptor;

 		CommonActionProviderDescriptor descriptor;
 		CommonActionProviderDescriptor overriddenDescriptor;
 		for (Iterator<CommonActionProviderDescriptor> iter = overridingDescriptors.iterator(); iter.hasNext();) {
 			descriptor = iter.next();
 			if (rootDescriptors.containsKey(descriptor.getOverridesId())) {
 				overriddenDescriptor = rootDescriptors
 						.get(descriptor.getOverridesId());
 				overriddenDescriptor.addOverridingDescriptor(descriptor);
 			} else if (dependentDescriptors.containsKey(descriptor
 					.getOverridesId())) {
 				overriddenDescriptor = dependentDescriptors
 						.get(descriptor.getOverridesId());
 				overriddenDescriptor.addOverridingDescriptor(descriptor);
 			}

 		}

 		Collection<CommonActionProviderDescriptor> unresolvedDependentDescriptors = new ArrayList<CommonActionProviderDescriptor>(
 				dependentDescriptors.values());

 		for (Iterator<CommonActionProviderDescriptor> iter = dependentDescriptors.values().iterator(); iter
 				.hasNext();) {
 			dependentDescriptor = iter.next();
 			requiredDescriptor = rootDescriptors
 					.get(dependentDescriptor.getDependsOnId());
 			if (requiredDescriptor == null) {
 				requiredDescriptor = dependentDescriptors
 						.get(dependentDescriptor.getDependsOnId());
 			}
 			if (requiredDescriptor != null) {
 				requiredDescriptor.addDependentDescriptor(dependentDescriptor);
 				unresolvedDependentDescriptors.remove(dependentDescriptor);
 			}

 		}

 		dependentDescriptors.clear();

 		if (!unresolvedDependentDescriptors.isEmpty()) {
 			StringBuffer errorMessage = new StringBuffer(
 					"There were unresolved dependencies for action provider extensions to a Common Navigator.\n" + //$NON-NLS-1$
 							"Verify that the \"dependsOn\" attribute for each <actionProvider /> element is valid."); //$NON-NLS-1$

 			CommonActionProviderDescriptor[] unresolvedDescriptors = unresolvedDependentDescriptors
 					.toArray(new CommonActionProviderDescriptor[unresolvedDependentDescriptors
 							.size()]);
 			for (CommonActionProviderDescriptor unresolvedDescriptor : unresolvedDescriptors) {
 				errorMessage.append("\nUnresolved dependency specified for actionProvider: ") //$NON-NLS-1$
 						.append(unresolvedDescriptor.getDefinedId());
 			}

 			NavigatorPlugin.log(IStatus.WARNING, 0, errorMessage.toString(),
 					null);

 		}
 		unresolvedDependentDescriptors.clear();

 	}

 	/**
 	 *
 	 * @param aContentService
 	 *            The content service to use when filtering action providers;
 	 *            only action providers bound directly or indirectly will be
 	 *            returned.
 	 * @param aContext
 	 *            The action context that contains a valid selection.
 	 * @return An array of visible, active, and enabled CommonActionProviders.
 	 *         See <b>org.eclipse.ui.navigator.navigatorContent</b> for the
 	 *         details of what each of these adjectives implies.
 	 */
 	public CommonActionProviderDescriptor[] findRelevantActionDescriptors(
 			INavigatorContentService aContentService, ActionContext aContext) {
 		Assert.isNotNull(aContext);
 		IStructuredSelection structuredSelection = null;
 		if (aContext.getSelection() instanceof IStructuredSelection) {
 			structuredSelection = (IStructuredSelection) aContext
 					.getSelection();
 		} else {
 			structuredSelection = StructuredSelection.EMPTY;
 		}

 		Set blockedProviders = new HashSet();
 		CommonActionProviderDescriptor actionDescriptor = null;
 		Set<CommonActionProviderDescriptor> providers = new LinkedHashSet<CommonActionProviderDescriptor>();
 		for (Iterator<CommonActionProviderDescriptor> providerItr = rootDescriptors.values().iterator(); providerItr
 				.hasNext();) {
 			actionDescriptor = providerItr
 					.next();
 			addProviderIfRelevant(aContentService, structuredSelection,
 					actionDescriptor, providers, blockedProviders);
 		}
 		if (providers.size() > 0) {
 			providers.removeAll(blockedProviders);
 			return providers
 					.toArray(new CommonActionProviderDescriptor[providers
 							.size()]);
 		}
 		return NO_DESCRIPTORS;
 	}

 	/**
 	 * @param aContentService
 	 * @param structuredSelection
 	 * @param actionDescriptor
 	 * @param providers
 	 */
 	private boolean addProviderIfRelevant(
 			INavigatorContentService aContentService,
 			IStructuredSelection structuredSelection,
 			CommonActionProviderDescriptor actionDescriptor, Set<CommonActionProviderDescriptor> providers, Set blockedProviders) {
 		if (isVisible(aContentService, actionDescriptor)
 				&& actionDescriptor.isEnabledFor(structuredSelection)) {

 			if(actionDescriptor.hasOverridingDescriptors()) {
 				for (Iterator iter = actionDescriptor.overridingDescriptors(); iter.hasNext();) {
 					CommonActionProviderDescriptor descriptor = (CommonActionProviderDescriptor) iter.next();
 					if(addProviderIfRelevant(aContentService, structuredSelection, descriptor, providers, blockedProviders)) {
 						while(iter.hasNext())
 							blockedProviders.add(iter.next());
 						return true;
 					}

 				}
 			}
 			providers.add(actionDescriptor);
 			if (actionDescriptor.hasDependentDescriptors()) {
 				for (Iterator iter = actionDescriptor.dependentDescriptors(); iter
 						.hasNext();) {
 					addProviderIfRelevant(aContentService, structuredSelection,
 							(CommonActionProviderDescriptor) iter.next(),
 							providers, blockedProviders);
 				}
 			}
 			return true;
 		}
 		return false;
 	}

 	private boolean isVisible(INavigatorContentService aContentService,
 			CommonActionProviderDescriptor descriptor) {
 		if (descriptor.isNested()) {
 			return aContentService.isActive(descriptor.getId())
 					&& aContentService.isVisible(descriptor.getId());
 		}
 		return aContentService.getViewerDescriptor().isVisibleActionExtension(
 				descriptor.getId());
 	}

 	private class ActionProviderRegistry extends NavigatorContentRegistryReader {

 		@Override
 		public void readRegistry() {
 			super.readRegistry();
 			computeOrdering();
 		}

 		@Override
 		protected boolean readElement(IConfigurationElement anElement) {
 			if (TAG_ACTION_PROVIDER.equals(anElement.getName())) {
 				addActionDescriptor(new CommonActionProviderDescriptor(
 						anElement));
 				return true;
 			} else if (TAG_NAVIGATOR_CONTENT.equals(anElement.getName())) {

 				IConfigurationElement[] actionProviders = anElement.getChildren(TAG_ACTION_PROVIDER);

 				if (actionProviders.length > 0) {

 					IConfigurationElement defaultEnablement = null;
 					IConfigurationElement[] inheritedEnablement = anElement.getChildren(TAG_ENABLEMENT);
 					if (inheritedEnablement.length == 0) {
 						inheritedEnablement = anElement.getChildren(TAG_POSSIBLE_CHILDREN);
 					}

 					defaultEnablement = inheritedEnablement.length == 1 ? inheritedEnablement[0] : null;

 					Priority defaultPriority = Priority.get(anElement.getAttribute(ATT_PRIORITY));


 					if(defaultEnablement == null) {
 						NavigatorPlugin.logError(0,
 							"An actionProvider has been defined as the child " + //$NON-NLS-1$
 							"of a navigatorContent extension that does not specify " + //$NON-NLS-1$
 							"an <enablement/> or <possibleChildren /> expression. Please " + //$NON-NLS-1$
 							"review the documentation and correct this error.", null); //$NON-NLS-1$
 					}
 					for (IConfigurationElement actionProvider : actionProviders) {
 						if(defaultEnablement == null) {
 							NavigatorPlugin.logError(0,
 									"Disabling actionProvider: " + actionProvider.getAttribute(ATT_ID), null); //$NON-NLS-1$
 						} else {
 							SafeRunner.run(new AddProviderSafeRunner(actionProvider, defaultEnablement, defaultPriority, anElement));
 						}
 					}
 				}
 				return true;
 			}
 			return super.readElement(anElement);
 		}

 		private class AddProviderSafeRunner implements ISafeRunnable {

 			private IConfigurationElement parentElement;
 			private IConfigurationElement defaultEnablement;
 			private IConfigurationElement actionProvider;
 			private Priority defaultPriority;

 			protected AddProviderSafeRunner(IConfigurationElement actionProvider,
 											 IConfigurationElement defaultEnablement,
 											 Priority defaultPriority,
 											 IConfigurationElement parentElement) {
 				this.actionProvider = actionProvider;
 				this.defaultEnablement = defaultEnablement;
 				this.defaultPriority = defaultPriority;
 				this.parentElement = parentElement;
 			}

 			@Override
 			public void run() throws Exception {
 				addActionDescriptor(new CommonActionProviderDescriptor(
 							actionProvider, defaultEnablement, defaultPriority, parentElement
 									.getAttribute(ATT_ID), true));
 			}

 			@Override
 			public void handleException(Throwable t) {
 				NavigatorPlugin.logError(0, "Recovering from error while parsing actionProviders.", t); //$NON-NLS-1$
 			}


 		}
 	}


 }
	/*******************************************************************************
	* Copyright (c) 2005, 2015 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.ui.internal.navigator.actions;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.LinkedHashMap;
	import java.util.LinkedHashSet;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import org.eclipse.core.runtime.Assert;
	import org.eclipse.core.runtime.IConfigurationElement;
	import org.eclipse.core.runtime.ISafeRunnable;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.SafeRunner;
	import org.eclipse.jface.viewers.IStructuredSelection;
	import org.eclipse.jface.viewers.StructuredSelection;
	import org.eclipse.ui.actions.ActionContext;
	import org.eclipse.ui.internal.navigator.NavigatorPlugin;
	import org.eclipse.ui.internal.navigator.extensions.NavigatorContentRegistryReader;
	import org.eclipse.ui.navigator.INavigatorContentService;
	import org.eclipse.ui.navigator.Priority;

	/**
	* Manages descriptors consumed from the 'actionProvider' elements of the
	* <b>org.eclipse.ui.navigator.navigatorContent</b> extension point.
	*
	* @since 3.2
	*
	*/
	public class CommonActionDescriptorManager {

	private static final CommonActionProviderDescriptor[] NO_DESCRIPTORS = new CommonActionProviderDescriptor[0];

	private static final CommonActionDescriptorManager INSTANCE = new CommonActionDescriptorManager();

	private CommonActionDescriptorManager() {

	new ActionProviderRegistry().readRegistry();
	}

	/**
	* @return the singleton instance of the registry
	*/
	public static CommonActionDescriptorManager getInstance() {
	return INSTANCE;
	}

	/* Provides a map of (ids, CommonActionProviderDescriptor)-pairs. */
	private final Map<String, CommonActionProviderDescriptor> dependentDescriptors = new LinkedHashMap<String, CommonActionProviderDescriptor>();

	/* Provides a map of (ids, CommonActionProviderDescriptor)-pairs. */
	private final Map<String, CommonActionProviderDescriptor> rootDescriptors = new LinkedHashMap<String, CommonActionProviderDescriptor>();

	/* Provides a map of (ids, CommonActionProviderDescriptor)-pairs. */
	private final Set<CommonActionProviderDescriptor> overridingDescriptors = new LinkedHashSet<CommonActionProviderDescriptor>();


	private final LinkedList<CommonActionProviderDescriptor> rootDescriptorsList = new LinkedList<CommonActionProviderDescriptor>();
	private final LinkedList<CommonActionProviderDescriptor> dependentDescriptorsList = new LinkedList<CommonActionProviderDescriptor>();


	/**
	*
	* @param aDescriptor
	* A valid descriptor to begin managing.
	*/
	protected void addActionDescriptor(
	CommonActionProviderDescriptor aDescriptor) {

	if (aDescriptor.getDependsOnId() == null) {
	rootDescriptorsList.add(aDescriptor);
	} else {
	dependentDescriptorsList.add(aDescriptor);
	}

	if (aDescriptor.getOverridesId() != null) {
	overridingDescriptors.add(aDescriptor);
	}
	}

	private int findId(List<CommonActionProviderDescriptor> list, String id) {
	for (int i= 0, len = list.size(); i< len; i++) {
	CommonActionProviderDescriptor desc = list.get(i);
	if (desc.getId().equals(id))
	return i;
	}
	return -1;
	}



	/**
	* Sorts the descriptors according to the appearsBefore property
	*/
	private void sortDescriptors(LinkedList<CommonActionProviderDescriptor> list, Map<String, CommonActionProviderDescriptor> outMap) {
	boolean changed = true;
	while (changed) {
	changed = false;
	for (int i = 0, len = list.size(); i < len; i++) {
	CommonActionProviderDescriptor desc = list.get(i);
	if (desc.getAppearsBeforeId() != null) {
	int beforeInd = findId(list, desc.getAppearsBeforeId());
	if (beforeInd < i) {
	list.add(beforeInd, desc);
	list.remove(i + 1);
	changed = true;
	}
	}
	}
	}
	for (int i = 0, len = list.size(); i < len; i++) {
	CommonActionProviderDescriptor desc = list.get(i);
	outMap.put(desc.getDefinedId(), desc);
	}
	}


	/**
	* Orders the set of available descriptors based on the order defined by the
	* <i>dependsOn</i> attribute from the <actionProvider /> element in
	* <b>org.eclipse.ui.navigator.navigatorContent</b>
	*
	*/
	protected void computeOrdering() {
	sortDescriptors(rootDescriptorsList, rootDescriptors);
	sortDescriptors(dependentDescriptorsList, dependentDescriptors);

	CommonActionProviderDescriptor dependentDescriptor;
	CommonActionProviderDescriptor requiredDescriptor;

	CommonActionProviderDescriptor descriptor;
	CommonActionProviderDescriptor overriddenDescriptor;
	for (Iterator<CommonActionProviderDescriptor> iter = overridingDescriptors.iterator(); iter.hasNext();) {
	descriptor = iter.next();
	if (rootDescriptors.containsKey(descriptor.getOverridesId())) {
	overriddenDescriptor = rootDescriptors
	.get(descriptor.getOverridesId());
	overriddenDescriptor.addOverridingDescriptor(descriptor);
	} else if (dependentDescriptors.containsKey(descriptor
	.getOverridesId())) {
	overriddenDescriptor = dependentDescriptors
	.get(descriptor.getOverridesId());
	overriddenDescriptor.addOverridingDescriptor(descriptor);
	}

	}

	Collection<CommonActionProviderDescriptor> unresolvedDependentDescriptors = new ArrayList<CommonActionProviderDescriptor>(
	dependentDescriptors.values());

	for (Iterator<CommonActionProviderDescriptor> iter = dependentDescriptors.values().iterator(); iter
	.hasNext();) {
	dependentDescriptor = iter.next();
	requiredDescriptor = rootDescriptors
	.get(dependentDescriptor.getDependsOnId());
	if (requiredDescriptor == null) {
	requiredDescriptor = dependentDescriptors
	.get(dependentDescriptor.getDependsOnId());
	}
	if (requiredDescriptor != null) {
	requiredDescriptor.addDependentDescriptor(dependentDescriptor);
	unresolvedDependentDescriptors.remove(dependentDescriptor);
	}

	}

	dependentDescriptors.clear();

	if (!unresolvedDependentDescriptors.isEmpty()) {
	StringBuffer errorMessage = new StringBuffer(
	"There were unresolved dependencies for action provider extensions to a Common Navigator.\n" + //$NON-NLS-1$
	"Verify that the \"dependsOn\" attribute for each <actionProvider /> element is valid."); //$NON-NLS-1$

	CommonActionProviderDescriptor[] unresolvedDescriptors = unresolvedDependentDescriptors
	.toArray(new CommonActionProviderDescriptor[unresolvedDependentDescriptors
	.size()]);
	for (CommonActionProviderDescriptor unresolvedDescriptor : unresolvedDescriptors) {
	errorMessage.append("\nUnresolved dependency specified for actionProvider: ") //$NON-NLS-1$
	.append(unresolvedDescriptor.getDefinedId());
	}

	NavigatorPlugin.log(IStatus.WARNING, 0, errorMessage.toString(),
	null);

	}
	unresolvedDependentDescriptors.clear();

	}

	/**
	*
	* @param aContentService
	* The content service to use when filtering action providers;
	* only action providers bound directly or indirectly will be
	* returned.
	* @param aContext
	* The action context that contains a valid selection.
	* @return An array of visible, active, and enabled CommonActionProviders.
	* See <b>org.eclipse.ui.navigator.navigatorContent</b> for the
	* details of what each of these adjectives implies.
	*/
	public CommonActionProviderDescriptor[] findRelevantActionDescriptors(
	INavigatorContentService aContentService, ActionContext aContext) {
	Assert.isNotNull(aContext);
	IStructuredSelection structuredSelection = null;
	if (aContext.getSelection() instanceof IStructuredSelection) {
	structuredSelection = (IStructuredSelection) aContext
	.getSelection();
	} else {
	structuredSelection = StructuredSelection.EMPTY;
	}

	Set blockedProviders = new HashSet();
	CommonActionProviderDescriptor actionDescriptor = null;
	Set<CommonActionProviderDescriptor> providers = new LinkedHashSet<CommonActionProviderDescriptor>();
	for (Iterator<CommonActionProviderDescriptor> providerItr = rootDescriptors.values().iterator(); providerItr
	.hasNext();) {
	actionDescriptor = providerItr
	.next();
	addProviderIfRelevant(aContentService, structuredSelection,
	actionDescriptor, providers, blockedProviders);
	}
	if (providers.size() > 0) {
	providers.removeAll(blockedProviders);
	return providers
	.toArray(new CommonActionProviderDescriptor[providers
	.size()]);
	}
	return NO_DESCRIPTORS;
	}

	/**
	* @param aContentService
	* @param structuredSelection
	* @param actionDescriptor
	* @param providers
	*/
	private boolean addProviderIfRelevant(
	INavigatorContentService aContentService,
	IStructuredSelection structuredSelection,
	CommonActionProviderDescriptor actionDescriptor, Set<CommonActionProviderDescriptor> providers, Set blockedProviders) {
	if (isVisible(aContentService, actionDescriptor)
	&& actionDescriptor.isEnabledFor(structuredSelection)) {

	if(actionDescriptor.hasOverridingDescriptors()) {
	for (Iterator iter = actionDescriptor.overridingDescriptors(); iter.hasNext();) {
	CommonActionProviderDescriptor descriptor = (CommonActionProviderDescriptor) iter.next();
	if(addProviderIfRelevant(aContentService, structuredSelection, descriptor, providers, blockedProviders)) {
	while(iter.hasNext())
	blockedProviders.add(iter.next());
	return true;
	}

	}
	}
	providers.add(actionDescriptor);
	if (actionDescriptor.hasDependentDescriptors()) {
	for (Iterator iter = actionDescriptor.dependentDescriptors(); iter
	.hasNext();) {
	addProviderIfRelevant(aContentService, structuredSelection,
	(CommonActionProviderDescriptor) iter.next(),
	providers, blockedProviders);
	}
	}
	return true;
	}
	return false;
	}

	private boolean isVisible(INavigatorContentService aContentService,
	CommonActionProviderDescriptor descriptor) {
	if (descriptor.isNested()) {
	return aContentService.isActive(descriptor.getId())
	&& aContentService.isVisible(descriptor.getId());
	}
	return aContentService.getViewerDescriptor().isVisibleActionExtension(
	descriptor.getId());
	}

	private class ActionProviderRegistry extends NavigatorContentRegistryReader {

	@Override
	public void readRegistry() {
	super.readRegistry();
	computeOrdering();
	}

	@Override
	protected boolean readElement(IConfigurationElement anElement) {
	if (TAG_ACTION_PROVIDER.equals(anElement.getName())) {
	addActionDescriptor(new CommonActionProviderDescriptor(
	anElement));
	return true;
	} else if (TAG_NAVIGATOR_CONTENT.equals(anElement.getName())) {

	IConfigurationElement[] actionProviders = anElement.getChildren(TAG_ACTION_PROVIDER);

	if (actionProviders.length > 0) {

	IConfigurationElement defaultEnablement = null;
	IConfigurationElement[] inheritedEnablement = anElement.getChildren(TAG_ENABLEMENT);
	if (inheritedEnablement.length == 0) {
	inheritedEnablement = anElement.getChildren(TAG_POSSIBLE_CHILDREN);
	}

	defaultEnablement = inheritedEnablement.length == 1 ? inheritedEnablement[0] : null;

	Priority defaultPriority = Priority.get(anElement.getAttribute(ATT_PRIORITY));


	if(defaultEnablement == null) {
	NavigatorPlugin.logError(0,
	"An actionProvider has been defined as the child " + //$NON-NLS-1$
	"of a navigatorContent extension that does not specify " + //$NON-NLS-1$
	"an <enablement/> or <possibleChildren /> expression. Please " + //$NON-NLS-1$
	"review the documentation and correct this error.", null); //$NON-NLS-1$
	}
	for (IConfigurationElement actionProvider : actionProviders) {
	if(defaultEnablement == null) {
	NavigatorPlugin.logError(0,
	"Disabling actionProvider: " + actionProvider.getAttribute(ATT_ID), null); //$NON-NLS-1$
	} else {
	SafeRunner.run(new AddProviderSafeRunner(actionProvider, defaultEnablement, defaultPriority, anElement));
	}
	}
	}
	return true;
	}
	return super.readElement(anElement);
	}

	private class AddProviderSafeRunner implements ISafeRunnable {

	private IConfigurationElement parentElement;
	private IConfigurationElement defaultEnablement;
	private IConfigurationElement actionProvider;
	private Priority defaultPriority;

	protected AddProviderSafeRunner(IConfigurationElement actionProvider,
	IConfigurationElement defaultEnablement,
	Priority defaultPriority,
	IConfigurationElement parentElement) {
	this.actionProvider = actionProvider;
	this.defaultEnablement = defaultEnablement;
	this.defaultPriority = defaultPriority;
	this.parentElement = parentElement;
	}

	@Override
	public void run() throws Exception {
	addActionDescriptor(new CommonActionProviderDescriptor(
	actionProvider, defaultEnablement, defaultPriority, parentElement
	.getAttribute(ATT_ID), true));
	}

	@Override
	public void handleException(Throwable t) {
	NavigatorPlugin.logError(0, "Recovering from error while parsing actionProviders.", t); //$NON-NLS-1$
	}


	}
	}


	}