Java tutorial
/****************************************************************************** * 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 Corporation - initial API and implementation ****************************************************************************/ package net.enilink.komma.edit.ui.action; import org.eclipse.core.commands.operations.IOperationHistory; import org.eclipse.core.commands.operations.IOperationHistoryListener; import org.eclipse.core.commands.operations.IUndoContext; import org.eclipse.core.commands.operations.IUndoableOperation; import org.eclipse.core.commands.operations.OperationHistoryEvent; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.Status; import org.eclipse.jface.action.Action; import org.eclipse.jface.dialogs.ErrorDialog; import org.eclipse.jface.viewers.ISelection; import org.eclipse.jface.viewers.ISelectionChangedListener; import org.eclipse.jface.viewers.ISelectionProvider; import org.eclipse.jface.viewers.IStructuredSelection; import org.eclipse.jface.viewers.SelectionChangedEvent; import org.eclipse.jface.viewers.StructuredSelection; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Event; import org.eclipse.ui.IPartListener; import org.eclipse.ui.IPropertyListener; import org.eclipse.ui.ISelectionService; import org.eclipse.ui.IWorkbenchPage; import org.eclipse.ui.IWorkbenchPart; import org.eclipse.ui.PlatformUI; import net.enilink.komma.common.util.Log; import net.enilink.komma.common.util.StringStatics; import net.enilink.komma.common.util.Trace; import net.enilink.komma.edit.ui.KommaEditUIPlugin; import net.enilink.komma.edit.ui.internal.EditUIDebugOptions; import net.enilink.komma.edit.ui.internal.EditUIStatusCodes; import net.enilink.komma.edit.ui.util.IPartSelector; import net.enilink.komma.edit.ui.util.PartListenerAdapter; import net.enilink.komma.edit.ui.util.StatusLineUtil; /** * The abstract parent of all concrete action handlers that execute commands. * Logging and exception handling are done in a uniform way in the * <code>run()</code> method. Concrete subclasses must provide a definition of * the <code>doRun()</code> method to gather any required input and execute a * command. As an implementer of the <code>IRepeatableAction</code> interface, * this class implements the <code>isRepeatable()</code> method to return * <code>true</code> if it is enabled, and implements the <code>repeat()</code> * method to run itself. Subclasses that aren't repeatable or require special * repeat behavior must override the default implementations of these interface * methods. * * This action handler supports life cycle methods by implementing the * <code>IDisposableAction</code> interface. Therefore, clients need to call the * <code>init()</code> method to initialize the action, and the * <code>dispose()</code> method when the action is no longer needed. * * @author khussey */ public abstract class AbstractActionHandler extends Action implements IDisposableAction, IActionWithProgress, ISelectionChangedListener, IOperationHistoryListener, IPropertyListener { /** * Flag to indicate whether or not this action has been set up. */ private boolean setup; /** * My disposed state. */ private boolean disposed; /** * The workbench part to which this action handler applies. */ private IWorkbenchPart workbenchPart; /** * The workbench page this action is associated to */ private IWorkbenchPage workbenchPage; /** * The part listener of this action */ private IPartListener partListener; /** * Selects workbench parts that match the part criteria with which I was * contributed. I will refresh myself when the selection changes on parts * that match this criteria, and when such parts are activated. */ private IPartSelector partSelector; /** * A static selection this action operates on. */ private ISelection selection; /** * Constructs a new action handler for the specified workbench part. * * @param workbenchPart * The workbench part to which this action handler applies. */ protected AbstractActionHandler(IWorkbenchPart workbenchPart) { setWorkbenchPart(workbenchPart); if (workbenchPart != null) { this.workbenchPage = workbenchPart.getSite().getPage(); } } /** * Constructs a new action handler that gets its workbench part by listening * to the given workbench page * * @param workbenchPage * The workbench page associated with this action handler */ protected AbstractActionHandler(final IWorkbenchPage workbenchPage) { this.workbenchPage = workbenchPage; if (workbenchPage != null) { this.partListener = new PartListenerAdapter() { /** * Listens to part activation and updates the active workbench */ public void partActivated(IWorkbenchPart part) { setWorkbenchPart(part); if (part != null && contributedToPart(part) && !isDisposed()) refresh(); } /** * Listens to part deactivation and disables the action Could be * improved to only consider toolbar actions */ public void partDeactivated(IWorkbenchPart part) { if (part != null && contributedToPart(part)) { setEnabled(false); } } }; workbenchPage.addPartListener(partListener); } } /** * Constructs a new action handler for the specified workbench part. * * @param workbenchPart * The workbench part to which this action handler applies. */ protected AbstractActionHandler(IWorkbenchPart workbenchPart, ISelection selection) { setWorkbenchPart(workbenchPart); if (workbenchPart != null) { this.workbenchPage = workbenchPart.getSite().getPage(); } this.selection = selection; } /** * The basic implementation sets the workbenchpart if not already set and * refreshes the action if the current part is not null. * <P> * Any subclass that overrided this method should ensure that the disposed * state of this action is maintained by calling * <code>setDisposed(false)</code> or calling <code>super.init()</code>. */ public void init() { setDisposed(false); if (getWorkbenchPart() == null && getWorkbenchPage() != null) { setWorkbenchPart(getWorkbenchPage().getActivePart()); } refresh(); } /** * Default implementation of dispose. Any subclass that overrided this * method should ensure that the disposed state of this action is maintained * by calling <code>setDisposed(true)</code> or calling * <code>super.dispose()</code>. */ public void dispose() { setWorkbenchPart(null); if (partListener != null && workbenchPage != null) { workbenchPage.removePartListener(partListener); workbenchPage = null; partListener = null; } setDisposed(true); } /** * Sets the current workbencgPart * * @param workbenchPart * The current workbenchPart */ protected void setWorkbenchPart(IWorkbenchPart workbenchPart) { if (getWorkbenchPart() == workbenchPart) return; if (getWorkbenchPart() != null) { if (isSelectionListener()) { ISelectionProvider provider = getWorkbenchPart().getSite().getSelectionProvider(); if (provider != null) { provider.removeSelectionChangedListener(this); } } if (isPropertyListener()) { getWorkbenchPart().removePropertyListener(this); } if (isOperationHistoryListener()) { getOperationHistory().removeOperationHistoryListener(this); } } this.workbenchPart = workbenchPart; if (workbenchPart != null) { if (contributedToPart(workbenchPart)) { if (isSelectionListener()) { ISelectionProvider provider = getWorkbenchPart().getSite().getSelectionProvider(); if (provider != null) { provider.addSelectionChangedListener(this); } } if (isPropertyListener()) { getWorkbenchPart().addPropertyListener(this); } if (isOperationHistoryListener()) { getOperationHistory().addOperationHistoryListener(this); } } } } /** * Answers whether or not I am contributed to <code>part</code>. * * @param part * the workbench part to be tested * @return <code>true</code> if I am contributed to this part, * <code>false</code> otherwise. */ protected boolean contributedToPart(IWorkbenchPart part) { return partSelector == null || partSelector.selects(part); } /** * Sets my part selector. If my current workbench part doesn't match the * part selector, I stop listening to selection, property and operation * history changes on that part. * * @param partSelector * my new part selector */ public final void setPartSelector(IPartSelector partSelector) { if (this.partSelector == partSelector) { return; } this.partSelector = partSelector; IWorkbenchPart part = getWorkbenchPart(); if (part != null && !partSelector.selects(part)) { if (isSelectionListener()) { ISelectionProvider provider = getWorkbenchPart().getSite().getSelectionProvider(); if (provider != null) { provider.removeSelectionChangedListener(this); } } if (isPropertyListener()) { getWorkbenchPart().removePropertyListener(this); } if (isOperationHistoryListener()) { getOperationHistory().removeOperationHistoryListener(this); } } } /** * Retrieves the value of the <code>workbenchPart</code> instance variable. * * @return The value of the <code>workbenchPart</code> instance variable. */ protected final IWorkbenchPart getWorkbenchPart() { return workbenchPart; } /** * Retrieves the action manager for this action handler from its workbench * part. * * @return The action manager for this action handler. */ protected ActionManager getActionManager() { ActionManager manager = null; IWorkbenchPart wbPart = getWorkbenchPart(); if (wbPart != null) { manager = (ActionManager) wbPart.getAdapter(ActionManager.class); } return null == manager ? ActionManager.getDefault() : manager; } /** * Returns the operation history for this action handler from its action * manager. * * @return the operation history */ protected IOperationHistory getOperationHistory() { return getActionManager().getOperationHistory(); } /* * (non-Javadoc) * * @see org.eclipse.jface.action.IAction#run() */ public void run() { getActionManager().run(this); } /** * Runs this action handler. */ public void run(IProgressMonitor progressMonitor) { if (isSetup() || !needsSetup()) { try { StatusLineUtil.outputErrorMessage(getWorkbenchPart(), StringStatics.BLANK); doRun(progressMonitor); } catch (Exception e) { handle(e); } setSetup(false); } else { throw new IllegalStateException("action must be setup before it is run"); //$NON-NLS-1$ } } /** * Runs this action handler, passing the triggering SWT event. * * @param event * The SWT event which triggered this action being run. */ public void runWithEvent(Event event) { getActionManager().run(this); } /** * Notifies this action handler that the selection has changed. * * @param event * Event object describing the change. */ public final void selectionChanged(SelectionChangedEvent event) { refresh(); } /** * Property change event handler; does nothing by default. Subclasses should * override if they are interested in handling property change events. */ public void propertyChanged(Object source, int propId) { // Do nothing by default } /** * Retrieves the label for this action handler. * * @return The label for this action handler. */ public String getLabel() { return getText(); } /** * Retrieves the current selection. * * @return The current selection. */ protected ISelection getSelection() { if (this.selection != null) { return this.selection; } ISelection selection = null; ISelectionService selectionService = null; if (getWorkbenchPart() != null && getWorkbenchPart().getSite().getWorkbenchWindow() != null) { selectionService = getWorkbenchPart().getSite().getWorkbenchWindow().getSelectionService(); } if (selectionService != null) { selection = selectionService.getSelection(); } return (selection != null) ? selection : StructuredSelection.EMPTY; } /** * Retrieves the current structured selection. * * @return The current structured selection. */ protected IStructuredSelection getStructuredSelection() { ISelection selection = getSelection(); return (selection instanceof StructuredSelection) ? (StructuredSelection) selection : StructuredSelection.EMPTY; } /** * Retrieves a Boolean indicating whether this action handler can be run. * * @return <code>true</code> if this action handler is enabled; * <code>false</code> otherwise. */ public boolean isRunnable() { return isEnabled(); } /** * Retrieves a Boolean indicating whether this action handler is interested * in selection events. * * @return <code>true</code> if this action handler is interested; * <code>false</code> otherwise. */ protected boolean isSelectionListener() { return false; } /** * Answers whether of not this action handler is interested in property * change events. * <P> * This default implementation always returns <code>false</code>. Subclasses * must override if they are interested in property change events. * * @return <code>true</code> if this action handler is interested; * <code>false</code> otherwise. */ protected boolean isPropertyListener() { return false; } /** * Retrieves a Boolean indicating whether this action handler is interested * in operation history changed events. * * @return <code>true</code> if this action handler is interested; * <code>false</code> otherwise. */ protected boolean isOperationHistoryListener() { return false; } /** * Handles the specified exception. * * @param exception * The exception to be handled. */ protected void handle(Exception exception) { Trace.catching(KommaEditUIPlugin.getPlugin(), EditUIDebugOptions.EXCEPTIONS_CATCHING, getClass(), "handle", //$NON-NLS-1$ exception); IStatus status = new Status(IStatus.ERROR, KommaEditUIPlugin.PLUGIN_ID, EditUIStatusCodes.ACTION_FAILURE, String.valueOf(exception.getMessage()), exception); Log.log(KommaEditUIPlugin.getPlugin(), status); openErrorDialog(status); } /** * Opens an error dialog for the specified status object. * * @param status * The status object for which to open an error dialog. * */ protected void openErrorDialog(final IStatus status) { final Display display = getDisplay(); if (display.getThread() == Thread.currentThread()) { // we're already on the UI thread ErrorDialog.openError(display.getActiveShell(), removeMnemonics(getLabel()), null, status); } else { // we're not on the UI thread display.asyncExec(new Runnable() { public void run() { ErrorDialog.openError(display.getActiveShell(), removeMnemonics(getLabel()), null, status); } }); } } private Display getDisplay() { Display display = Display.getCurrent(); if (display == null && PlatformUI.isWorkbenchRunning()) { display = PlatformUI.getWorkbench().getDisplay(); } return display; } /** * Performs the actual work when this action handler is run. Subclasses must * override this method to do some work. * * @param progressMonitor * the progress monitor for tracking the progress of this action * when it is run. */ protected abstract void doRun(IProgressMonitor progressMonitor); /* * (non-Javadoc) * * @seeorg.eclipse.gmf.runtime.common.ui.action.IRepeatableAction# * getWorkIndicatorType() */ public WorkIndicatorType getWorkIndicatorType() { return WorkIndicatorType.BUSY; } /** * Returns the part listener * * @return The part listener */ protected IPartListener getPartListener() { return partListener; } /** * Returns the workbench page * * @return The workbench page */ protected IWorkbenchPage getWorkbenchPage() { return workbenchPage; } /** * Refreshes me if the history event has my workbench part's context, and * the event is one of: * <UL> * <LI>{@link OperationHistoryEvent#UNDONE}</LI> * <LI>{@link OperationHistoryEvent#REDONE}</LI> * <LI>{@link OperationHistoryEvent#OPERATION_ADDED}</LI> * <LI>{@link OperationHistoryEvent#OPERATION_CHANGED}</LI> * <LI>{@link OperationHistoryEvent#OPERATION_NOT_OK}</LI> * <LI>{@link OperationHistoryEvent#OPERATION_REMOVED}</LI> * </UL> * The other operation history events are ignored because they are * intermediate events that will be followed by one of those listed above. * We only want to refresh the action handler once for each change to the * operation history. */ public void historyNotification(OperationHistoryEvent event) { int type = event.getEventType(); if (type == OperationHistoryEvent.UNDONE || type == OperationHistoryEvent.REDONE || type == OperationHistoryEvent.DONE || type == OperationHistoryEvent.OPERATION_ADDED || type == OperationHistoryEvent.OPERATION_CHANGED || type == OperationHistoryEvent.OPERATION_NOT_OK || type == OperationHistoryEvent.OPERATION_REMOVED) { IUndoableOperation operation = event.getOperation(); if (operation != null) { IUndoContext partContext = getUndoContext(); if (partContext != null && operation.hasContext(partContext)) { refresh(); } } } } /** * Gets the undo context from my workbench part. * * @return the undo context */ protected IUndoContext getUndoContext() { IWorkbenchPart part = getWorkbenchPart(); if (part != null) { return (IUndoContext) part.getAdapter(IUndoContext.class); } return null; } /* * (non-Javadoc) * * @see * org.eclipse.gmf.runtime.common.ui.action.IDisposableAction#isDisposed() */ public boolean isDisposed() { return disposed; } /** * Sets my disposed state. * * @param b * <code>true</code> if I am disposed, <code>false</code> * otherwise. */ protected void setDisposed(boolean b) { disposed = b; } /* * (non-Javadoc) * * @see org.eclipse.gmf.runtime.common.ui.action.IRepeatableAction#setup() */ public boolean setup() { setSetup(true); return true; } /** * Returns the setup state of this action. * * @return <code>true</code> if the action has been setup, * <code>false</code> otherwise. */ public boolean isSetup() { return setup; } /** * Sets the setup state of this action. * * @param setup * <code>true</code> if the action has been setup, * <code>false</code> otherwise. */ protected void setSetup(boolean setup) { this.setup = setup; } /** * Answers whether or not this action should be setup before it is run. * Subclasses should override if they provide vital behaviour in the setup * method. * * @return <code>true</code> if the action has a setup, <code>false</code> * otherwise. */ protected boolean needsSetup() { return false; } }