| /******************************************************************************* |
| * Copyright (c) 2004, 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.commands; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.core.commands.ExecutionEvent; |
| import org.eclipse.core.commands.ExecutionException; |
| import org.eclipse.core.commands.HandlerEvent; |
| import org.eclipse.core.commands.IHandlerAttributes; |
| import org.eclipse.core.commands.IHandlerListener; |
| |
| /** |
| * This class is a partial implementation of <code>IHandler</code>. This |
| * abstract implementation provides support for handler listeners. You should |
| * subclass from this method unless you want to implement your own listener |
| * support. Subclasses should call |
| * {@link AbstractHandler#fireHandlerChanged(HandlerEvent)}when the handler |
| * changes. Subclasses should also override |
| * {@link AbstractHandler#getAttributeValuesByName()}if they have any |
| * attributes. |
| * |
| * @since 3.0 |
| * @deprecated Please use the "org.eclipse.core.commands" plug-in instead. |
| * @see org.eclipse.core.commands.AbstractHandler |
| */ |
| public abstract class AbstractHandler extends |
| org.eclipse.core.commands.AbstractHandler implements IHandler { |
| |
| /** |
| * Those interested in hearing about changes to this instance of |
| * <code>IHandler</code>. This member is null iff there are |
| * no listeners attached to this handler. (Most handlers don't |
| * have any listeners, and this optimization saves some memory.) |
| */ |
| private List handlerListeners; |
| |
| /** |
| * @see IHandler#addHandlerListener(IHandlerListener) |
| */ |
| public void addHandlerListener( |
| org.eclipse.ui.commands.IHandlerListener handlerListener) { |
| if (handlerListener == null) { |
| throw new NullPointerException(); |
| } |
| if (handlerListeners == null) { |
| handlerListeners = new ArrayList(); |
| } |
| if (!handlerListeners.contains(handlerListener)) { |
| handlerListeners.add(handlerListener); |
| } |
| } |
| |
| /** |
| * The default implementation does nothing. Subclasses who attach listeners |
| * to other objects are encouraged to detach them in this method. |
| * |
| * @see org.eclipse.ui.commands.IHandler#dispose() |
| */ |
| public void dispose() { |
| // Do nothing. |
| } |
| |
| public Object execute(final ExecutionEvent event) throws ExecutionException { |
| try { |
| return execute(event.getParameters()); |
| } catch (final org.eclipse.ui.commands.ExecutionException e) { |
| throw new ExecutionException(e.getMessage(), e.getCause()); |
| } |
| } |
| |
| /** |
| * Fires an event to all registered listeners describing changes to this |
| * instance. |
| * |
| * @param handlerEvent |
| * the event describing changes to this instance. Must not be |
| * <code>null</code>. |
| */ |
| protected void fireHandlerChanged(HandlerEvent handlerEvent) { |
| super.fireHandlerChanged(handlerEvent); |
| |
| if (handlerListeners != null) { |
| final boolean attributesChanged = handlerEvent.isEnabledChanged() |
| || handlerEvent.isHandledChanged(); |
| final Map previousAttributes; |
| if (attributesChanged) { |
| previousAttributes = new HashMap(); |
| previousAttributes.putAll(getAttributeValuesByName()); |
| if (handlerEvent.isEnabledChanged()) { |
| Boolean disabled = !isEnabled() ? Boolean.TRUE: Boolean.FALSE; |
| previousAttributes |
| .put("enabled", disabled); //$NON-NLS-1$ |
| } |
| if (handlerEvent.isHandledChanged()) { |
| Boolean notHandled = !isHandled() ? Boolean.TRUE: Boolean.FALSE; |
| previousAttributes.put( |
| IHandlerAttributes.ATTRIBUTE_HANDLED, notHandled); |
| } |
| } else { |
| previousAttributes = null; |
| } |
| final org.eclipse.ui.commands.HandlerEvent legacyEvent = new org.eclipse.ui.commands.HandlerEvent( |
| this, attributesChanged, previousAttributes); |
| |
| for (int i = 0; i < handlerListeners.size(); i++) { |
| ((org.eclipse.ui.commands.IHandlerListener) handlerListeners |
| .get(i)).handlerChanged(legacyEvent); |
| } |
| } |
| } |
| |
| protected void fireHandlerChanged( |
| final org.eclipse.ui.commands.HandlerEvent handlerEvent) { |
| if (handlerEvent == null) { |
| throw new NullPointerException(); |
| } |
| |
| if (handlerListeners != null) { |
| for (int i = 0; i < handlerListeners.size(); i++) { |
| ((org.eclipse.ui.commands.IHandlerListener) handlerListeners |
| .get(i)).handlerChanged(handlerEvent); |
| } |
| } |
| |
| if (super.hasListeners()) { |
| final boolean enabledChanged; |
| final boolean handledChanged; |
| if (handlerEvent.haveAttributeValuesByNameChanged()) { |
| Map previousAttributes = handlerEvent |
| .getPreviousAttributeValuesByName(); |
| |
| Object attribute = previousAttributes.get("enabled"); //$NON-NLS-1$ |
| if (attribute instanceof Boolean) { |
| enabledChanged = ((Boolean) attribute).booleanValue(); |
| } else { |
| enabledChanged = false; |
| } |
| |
| attribute = previousAttributes |
| .get(IHandlerAttributes.ATTRIBUTE_HANDLED); |
| if (attribute instanceof Boolean) { |
| handledChanged = ((Boolean) attribute).booleanValue(); |
| } else { |
| handledChanged = false; |
| } |
| } else { |
| enabledChanged = false; |
| handledChanged = true; |
| } |
| final HandlerEvent newEvent = new HandlerEvent(this, |
| enabledChanged, handledChanged); |
| super.fireHandlerChanged(newEvent); |
| } |
| } |
| |
| /** |
| * This simply return an empty map. The default implementation has no |
| * attributes. |
| * |
| * @see IHandler#getAttributeValuesByName() |
| */ |
| public Map getAttributeValuesByName() { |
| return Collections.EMPTY_MAP; |
| } |
| |
| /** |
| * Returns true iff there is one or more IHandlerListeners attached to this |
| * AbstractHandler. |
| * |
| * @return true iff there is one or more IHandlerListeners attached to this |
| * AbstractHandler |
| * @since 3.1 |
| */ |
| protected final boolean hasListeners() { |
| return super.hasListeners() || handlerListeners != null; |
| } |
| |
| public boolean isEnabled() { |
| final Object handled = getAttributeValuesByName().get("enabled"); //$NON-NLS-1$ |
| if (handled instanceof Boolean) { |
| return ((Boolean) handled).booleanValue(); |
| } |
| |
| return false; |
| } |
| |
| public boolean isHandled() { |
| final Object handled = getAttributeValuesByName().get( |
| IHandlerAttributes.ATTRIBUTE_HANDLED); |
| if (handled instanceof Boolean) { |
| return ((Boolean) handled).booleanValue(); |
| } |
| |
| return false; |
| } |
| |
| /** |
| * @see IHandler#removeHandlerListener(IHandlerListener) |
| */ |
| public void removeHandlerListener( |
| org.eclipse.ui.commands.IHandlerListener handlerListener) { |
| if (handlerListener == null) { |
| throw new NullPointerException(); |
| } |
| if (handlerListeners == null) { |
| return; |
| } |
| |
| if (handlerListeners != null) { |
| handlerListeners.remove(handlerListener); |
| } |
| if (handlerListeners.isEmpty()) { |
| handlerListeners = null; |
| } |
| } |
| } |