StaticSelectionCommandAction.java

/**
 * <copyright> 
 *
 * Copyright (c) 2002, 2009 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 - Initial API and implementation
 *
 * </copyright>
 *
 * $Id: StaticSelectionCommandAction.java,v 1.7 2007/09/30 10:31:30 emerks Exp $
 */
package net.enilink.komma.edit.ui.action;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWorkbenchPart;

import net.enilink.komma.common.command.ICommand;
import net.enilink.komma.common.command.UnexecutableCommand;
import net.enilink.komma.edit.command.ICommandActionDelegate;
import net.enilink.komma.edit.command.IInputCallback;
import net.enilink.komma.edit.domain.AdapterFactoryEditingDomain;
import net.enilink.komma.edit.domain.IEditingDomain;
import net.enilink.komma.edit.ui.editor.InputCallbackDialog;
import net.enilink.komma.edit.ui.provider.ExtendedImageRegistry;

/**
 * This class is used as a basis for implementing an
 * {@link org.eclipse.jface.action.IAction} on the menubar, the toolbar, or a
 * pop-up menu by delegating all required behaviour to a {@link ICommand}, only
 * when it is guaranteed that the selection will not change during the life of
 * the action. In other words, the action itself would be created based on the
 * selection, and destroyed when the selection changed. All possible aspects of
 * the action are delegated to the command, namely the enablement state and, if
 * it implements {@link ICommandActionDelegate}, the text, the toolbar icon, and
 * the tool tip text; however, this need only be done once, at the time the
 * action is created.
 * 
 * <p>
 * Subclasses must provide an implementation for {@link #createActionCommand}
 * that creates the command to perform this action. They may also override
 * {@link #getDefaultImageDescriptor} to provide a default icon and
 * {@link #disable} to set the action's state when a command cannot be created.
 */
public abstract class StaticSelectionCommandAction extends
		AbstractActionHandler {
	/**
	 * This records the editing domain of the current editor or viewer. For
	 * global popups, we try to determine the editing domain from the selected
	 * objects themselves.
	 */
	protected IEditingDomain editingDomain;

	/**
	 * This records the command.
	 */
	protected ICommand command;

	/**
	 * This constructs an instance for a command to be executed via
	 * workbenchPart's editing domain.
	 */
	public StaticSelectionCommandAction(IWorkbenchPart workbenchPart,
			ISelection selection) {
		super(workbenchPart, selection);
		editingDomain = AdapterFactoryEditingDomain.getEditingDomainFor(workbenchPart);
	}

	/**
	 * This constructs an instance for a command to be executed via the given
	 * editing domain.
	 */
	public StaticSelectionCommandAction(IWorkbenchPart workbenchPart,
			IEditingDomain editingDomain, ISelection selection) {
		super(workbenchPart, selection);
		this.editingDomain = editingDomain;
	}

	/**
	 * This should be implemented to create a command that performs the action.
	 */
	protected abstract ICommand createActionCommand(
			IEditingDomain editingDomain, Collection<?> collection);

	/**
	 * This extracts the objects from selection, invokes createActionCommand to
	 * create the command, and then configures the action based on the result.
	 */
	@Override
	public void refresh() {
		// only handle structured selections
		if (!(getSelection() instanceof IStructuredSelection)) {
			disable();
		} else {
			// convert the selection to a collection of the selected objects
			IStructuredSelection sselection = getStructuredSelection();
			List<?> list = sselection.toList();
			Collection<Object> collection = new ArrayList<Object>(list);

			// if the editing domain wasn't given by the workbench part, try to
			// get
			// it from the selection
			if (editingDomain == null) {
				for (Object o : collection) {
					editingDomain = AdapterFactoryEditingDomain
							.getEditingDomainFor(o);
					if (editingDomain != null) {
						break;
					}
				}
			}

			// if we found an editing domain, create command
			if (editingDomain != null) {
				command = createActionCommand(editingDomain, collection);
				setEnabled(command.canExecute());
			}

			// give up if we couldn't create the command; otherwise, use a
			// CommandActionDelegate to set the action's text, tool-tip, icon,
			// etc. or just use the default icon
			if (command == null || command == UnexecutableCommand.INSTANCE) {
				disable();
			} else if (!(command instanceof ICommandActionDelegate)) {
				if (getDefaultImageDescriptor() != null) {
					setImageDescriptor(getDefaultImageDescriptor());
				}
			} else {
				ICommandActionDelegate commandActionDelegate = (ICommandActionDelegate) command;

				ImageDescriptor imageDescriptor = objectToImageDescriptor(commandActionDelegate
						.getImage());
				if (imageDescriptor != null) {
					setImageDescriptor(imageDescriptor);
				} else if (getDefaultImageDescriptor() != null) {
					setImageDescriptor(getDefaultImageDescriptor());
				}

				if (commandActionDelegate.getText() != null) {
					setText(commandActionDelegate.getText());
				}

				if (commandActionDelegate.getDescription() != null) {
					setDescription(commandActionDelegate.getDescription());
				}

				if (commandActionDelegate.getToolTipText() != null) {
					setToolTipText(commandActionDelegate.getToolTipText());
				}
			}
		}
	}

	/**
	 * This can be overridden to provide the image descriptor used when the
	 * command does not provide one. This implementation simply returns null.
	 */
	protected ImageDescriptor getDefaultImageDescriptor() {
		return null;
	}

	/**
	 * This gets invoked when the selection is inappropriate or the command
	 * cannot be created. It puts the action in the correct state for such error
	 * conditions. This implementation disables the action and sets its icon to
	 * the default.
	 */
	protected void disable() {
		setEnabled(false);
		if (getDefaultImageDescriptor() != null) {
			setImageDescriptor(getDefaultImageDescriptor());
		}
	}

	@Override
	public void doRun(IProgressMonitor progressMonitor) {
		// this guard is for extra security, but should not be necessary
		if (editingDomain != null && command != null) {
			// use up the command
			try {
				editingDomain.getCommandStack().execute(command,
						progressMonitor, new IAdaptable() {
							@Override
							public Object getAdapter(Class adapter) {
								if (IInputCallback.class.equals(adapter)) {
									return new InputCallbackDialog(
											((AdapterFactoryEditingDomain) editingDomain)
													.getAdapterFactory());
								}
								return null;
							}
						});
			} catch (ExecutionException e) {
				handle(e);
			}
		}
	}

	/**
	 * If necessary, this converts any image representation into an image
	 * descriptor.
	 */
	protected ImageDescriptor objectToImageDescriptor(Object object) {
		return ExtendedImageRegistry.getInstance().getImageDescriptor(object);
	}
}