| /******************************************************************************* |
| * Copyright (c) 2005, 2006 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.contexts; |
| |
| import java.util.ArrayList; |
| import java.util.Comparator; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.SortedSet; |
| import java.util.TreeSet; |
| |
| import org.eclipse.core.commands.common.NotDefinedException; |
| import org.eclipse.core.commands.contexts.Context; |
| import org.eclipse.core.commands.contexts.ContextManager; |
| import org.eclipse.ui.contexts.ContextManagerEvent; |
| import org.eclipse.ui.contexts.IContext; |
| import org.eclipse.ui.contexts.IContextManager; |
| import org.eclipse.ui.contexts.IContextManagerListener; |
| |
| /** |
| * A wrapper around the new API that supports the old API. This manager also |
| * adds support for reading from the registry. |
| * |
| * @since 3.1 |
| */ |
| public final class ContextManagerLegacyWrapper implements |
| org.eclipse.core.commands.contexts.IContextManagerListener, |
| IContextManager { |
| |
| /** |
| * A comparator between context identifiers, that sorts them based on depth |
| * within the tree. Context identifiers representing deeper items (i.e., |
| * items with more ancestors), have lesser values (i.e., would appear |
| * earlier in a set). |
| * |
| * @since 3.0 |
| */ |
| private class ContextIdDepthComparator implements Comparator { |
| |
| /** |
| * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) |
| */ |
| public final int compare(final Object object1, final Object object2) { |
| final String contextId1 = (String) object1; |
| final String contextId2 = (String) object2; |
| Context context; |
| String parentId; |
| |
| // Get the depth of the first context. |
| int depth1 = 0; |
| context = contextManager.getContext(contextId1); |
| try { |
| parentId = context.getParentId(); |
| while (parentId != null) { |
| depth1++; |
| context = contextManager.getContext(parentId); |
| parentId = context.getParentId(); |
| } |
| } catch (final NotDefinedException e) { |
| // Do nothing. Stop ascending the ancestry. |
| } |
| |
| // Get the depth of the second context. |
| int depth2 = 0; |
| context = contextManager.getContext(contextId2); |
| try { |
| parentId = context.getParentId(); |
| while (parentId != null) { |
| depth2++; |
| context = contextManager.getContext(parentId); |
| parentId = context.getParentId(); |
| } |
| } catch (final NotDefinedException e) { |
| // Do nothing. Stop ascending the ancestry. |
| } |
| |
| // If the contexts are equal depth, then use their identifier. |
| int compare = depth2 - depth1; |
| if (compare == 0) { |
| compare = contextId1.compareTo(contextId2); |
| } |
| |
| return compare; |
| } |
| } |
| |
| /** |
| * A set that contains context identifiers (strings). The set is sorted |
| * based on how many ancestors the corresponding contexts have. Contexts |
| * with no parents appear last, while contexts with the most ancestors |
| * appear first. |
| * |
| * @since 3.0 |
| */ |
| private class DepthSortedContextIdSet extends TreeSet { |
| |
| /** |
| * Generated serial version UID for this class. |
| * |
| * @since 3.1 |
| */ |
| private static final long serialVersionUID = 3257291326872892465L; |
| |
| /** |
| * Constructs a new instance of <code>DepthSortedContextIdSet</code> |
| * with the set to be sorted. |
| * |
| * @param contextIds |
| * A set of context identifiers (strings); this may contain |
| * <code>null</code> values. The set may not be |
| * <code>null</code>, but may be empty. |
| */ |
| private DepthSortedContextIdSet(final Set contextIds) { |
| super(new ContextIdDepthComparator()); |
| addAll(contextIds); |
| } |
| } |
| |
| private final ContextManager contextManager; |
| |
| private List contextManagerListeners; |
| |
| /** |
| * Constructs a new instance of <code>MutableContextManager</code>. The |
| * registry is created on the platform's extension registry. |
| * |
| * @param contextManager |
| * The manager which will provided the real support; must not be |
| * <code>null</code>. |
| */ |
| public ContextManagerLegacyWrapper(ContextManager contextManager) { |
| |
| if (contextManager == null) { |
| throw new NullPointerException("The context manager cannot be null"); //$NON-NLS-1$ |
| } |
| |
| this.contextManager = contextManager; |
| this.contextManager.addContextManagerListener(this); |
| } |
| |
| public void addContextManagerListener( |
| IContextManagerListener contextManagerListener) { |
| if (contextManagerListener == null) { |
| throw new NullPointerException(); |
| } |
| |
| if (contextManagerListeners == null) { |
| contextManagerListeners = new ArrayList(); |
| } |
| |
| if (!contextManagerListeners.contains(contextManagerListener)) { |
| contextManagerListeners.add(contextManagerListener); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.core.commands.contexts.IContextManagerListener#contextManagerChanged(org.eclipse.core.commands.contexts.ContextManagerEvent) |
| */ |
| public void contextManagerChanged( |
| org.eclipse.core.commands.contexts.ContextManagerEvent contextManagerEvent) { |
| final String contextId = contextManagerEvent.getContextId(); |
| final boolean definedContextsChanged; |
| final Set previouslyDefinedContextIds; |
| if (contextId == null) { |
| definedContextsChanged = false; |
| previouslyDefinedContextIds = null; |
| } else { |
| definedContextsChanged = true; |
| previouslyDefinedContextIds = new HashSet(); |
| previouslyDefinedContextIds.addAll(contextManager |
| .getDefinedContextIds()); |
| if (contextManagerEvent.isContextDefined()) { |
| previouslyDefinedContextIds.remove(contextId); |
| } else { |
| previouslyDefinedContextIds.add(contextId); |
| } |
| } |
| |
| fireContextManagerChanged(new ContextManagerEvent(this, |
| definedContextsChanged, contextManagerEvent |
| .isActiveContextsChanged(), |
| previouslyDefinedContextIds, contextManagerEvent |
| .getPreviouslyActiveContextIds())); |
| |
| } |
| |
| protected void fireContextManagerChanged( |
| ContextManagerEvent contextManagerEvent) { |
| if (contextManagerEvent == null) { |
| throw new NullPointerException(); |
| } |
| |
| if (contextManagerListeners != null) { |
| for (int i = 0; i < contextManagerListeners.size(); i++) { |
| ((IContextManagerListener) contextManagerListeners.get(i)) |
| .contextManagerChanged(contextManagerEvent); |
| } |
| } |
| } |
| |
| public IContext getContext(String contextId) { |
| return new ContextLegacyWrapper(contextManager.getContext(contextId), |
| contextManager); |
| } |
| |
| public SortedSet getDefinedContextIds() { |
| return new DepthSortedContextIdSet(contextManager |
| .getDefinedContextIds()); |
| } |
| |
| public SortedSet getEnabledContextIds() { |
| return new DepthSortedContextIdSet(contextManager.getActiveContextIds()); |
| } |
| |
| public void removeContextManagerListener( |
| IContextManagerListener contextManagerListener) { |
| if (contextManagerListener == null) { |
| throw new NullPointerException(); |
| } |
| |
| if (contextManagerListeners != null) { |
| contextManagerListeners.remove(contextManagerListener); |
| } |
| } |
| |
| public void setEnabledContextIds(Set enabledContextIds) { |
| contextManager.setActiveContextIds(enabledContextIds); |
| } |
| } |