Skip to content

Content of file StaticSelectionCommandAction.java

/**
 * Copyright (c) 2002-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 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 * IBM - Initial API and implementation
 */
// REUSED CLASS
package org.eclipse.emf.edit.ui.action.emfforms;

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

import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.UnexecutableCommand;
import org.eclipse.emf.edit.command.CommandActionDelegate;
import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;

/**
 * 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 Command}, 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 CommandActionDelegate}, 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 Action {
/** * 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 EditingDomain editingDomain; /** * This records the command. */ protected Command command; /** * This constructs an instance for a command to be executed via the given editing domain. * * @since 2.4.0 */ public StaticSelectionCommandAction(EditingDomain editingDomain) { this.editingDomain = editingDomain; } /** * This constructs an instance without a specified workbenchPart. */ public StaticSelectionCommandAction() { super(); } /** * This should be implemented to create a command that performs the action. */ protected abstract Command createActionCommand(EditingDomain editingDomain, Collection<?> collection); /** * This extracts the objects from selection, invokes createActionCommand * to create the command, and then configures the action based on the * result. */ public void configureAction(ISelection selection) { // only handle structured selections if (!(selection instanceof IStructuredSelection)) { disable(); } else { // convert the selection to a collection of the selected objects final IStructuredSelection sselection = (IStructuredSelection) selection; final List<?> list = sselection.toList(); final 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 (final 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 CommandActionDelegate)) { if (getDefaultImageDescriptor() != null) { setImageDescriptor(getDefaultImageDescriptor()); } } else { final CommandActionDelegate commandActionDelegate = (CommandActionDelegate) command; final 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()); } } /** * This executes the command. */ @Override public void run() { // this guard is for extra security, but should not be necessary if (editingDomain != null && command != null) { // use up the command editingDomain.getCommandStack().execute(command); } } /** * If necessary, this converts any image representation into an image * descriptor. */ protected ImageDescriptor objectToImageDescriptor(Object object) { return ExtendedImageRegistry.getInstance().getImageDescriptor(object); } }