diff options
Diffstat (limited to 'org.eclipse.mylyn.commons.ui/src/org/eclipse/mylyn/commons/ui/ProgressContainer.java')
| -rw-r--r-- | org.eclipse.mylyn.commons.ui/src/org/eclipse/mylyn/commons/ui/ProgressContainer.java | 257 |
1 files changed, 257 insertions, 0 deletions
diff --git a/org.eclipse.mylyn.commons.ui/src/org/eclipse/mylyn/commons/ui/ProgressContainer.java b/org.eclipse.mylyn.commons.ui/src/org/eclipse/mylyn/commons/ui/ProgressContainer.java new file mode 100644 index 00000000..31c7e3e5 --- /dev/null +++ b/org.eclipse.mylyn.commons.ui/src/org/eclipse/mylyn/commons/ui/ProgressContainer.java @@ -0,0 +1,257 @@ +/******************************************************************************* + * Copyright (c) 2000, 2010 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 + * Chris Gross (schtoo@schtoo.com) - patch for bug 16179 + * Tasktop Technologies - extracted code for Mylyn + *******************************************************************************/ + +package org.eclipse.mylyn.commons.ui; + +import java.lang.reflect.InvocationTargetException; +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.core.runtime.Assert; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.ProgressMonitorWrapper; +import org.eclipse.jface.operation.IRunnableContext; +import org.eclipse.jface.operation.IRunnableWithProgress; +import org.eclipse.jface.operation.ModalContext; +import org.eclipse.jface.wizard.ProgressMonitorPart; +import org.eclipse.jface.wizard.WizardDialog; +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.DisposeEvent; +import org.eclipse.swt.events.DisposeListener; +import org.eclipse.swt.graphics.Cursor; +import org.eclipse.swt.widgets.Button; +import org.eclipse.swt.widgets.Control; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Shell; + +/** + * A helper class for running operations in dialogs. Based on {@link WizardDialog}. + * + * @author Steffen Pingel + * @since 3.7 + */ +public class ProgressContainer implements IRunnableContext { + + private static final String FOCUS_CONTROL = "focusControl"; //$NON-NLS-1$ + + // The number of long running operation executed from the dialog. + private long activeRunningOperations = 0; + + private Cursor arrowCursor; + + private Button cancelButton; + + private boolean lockedUI = false; + + // The progress monitor + private final ProgressMonitorPart progressMonitorPart; + + private final Shell shell; + + private Cursor waitCursor; + + private boolean useWaitCursor; + + public ProgressContainer(Shell shell, ProgressMonitorPart progressMonitorPart) { + Assert.isNotNull(shell); + Assert.isNotNull(progressMonitorPart); + this.shell = shell; + this.progressMonitorPart = progressMonitorPart; + init(); + } + + private void init() { + this.shell.addDisposeListener(new DisposeListener() { + public void widgetDisposed(DisposeEvent e) { + progressMonitorPart.setCanceled(true); + } + }); + } + + public boolean useWaitCursor() { + return useWaitCursor; + } + + public void setUseWaitCursor(boolean useWaitCursor) { + this.useWaitCursor = useWaitCursor; + } + + /** + * About to start a long running operation triggered through the wizard. Shows the progress monitor and disables the + * wizard's buttons and controls. + * + * @param enableCancelButton + * <code>true</code> if the Cancel button should be enabled, and <code>false</code> if it should be + * disabled + * @return the saved UI state + */ + private Object aboutToStart(boolean enableCancelButton) { + Map<Object, Object> savedState = null; + if (getShell() != null) { + // Save focus control + Control focusControl = getShell().getDisplay().getFocusControl(); + if (focusControl != null && focusControl.getShell() != getShell()) { + focusControl = null; + } + // Set the busy cursor to all shells. + Display d = getShell().getDisplay(); + if (useWaitCursor()) { + waitCursor = new Cursor(d, SWT.CURSOR_WAIT); + setDisplayCursor(waitCursor); + // Set the arrow cursor to the cancel component. + arrowCursor = new Cursor(d, SWT.CURSOR_ARROW); + if (cancelButton != null) { + cancelButton.setCursor(arrowCursor); + } + } + // Deactivate shell + savedState = new HashMap<Object, Object>(10); + saveUiState(savedState); + if (focusControl != null) { + savedState.put(FOCUS_CONTROL, focusControl); + } + // Attach the progress monitor part to the cancel button + if (cancelButton != null) { + progressMonitorPart.attachToCancelComponent(cancelButton); + } + progressMonitorPart.setVisible(true); + } + return savedState; + } + + public Button getCancelButton() { + return cancelButton; + } + + private IProgressMonitor getProgressMonitor() { + return new ProgressMonitorWrapper(progressMonitorPart) { + @Override + public void internalWorked(double work) { + if (progressMonitorPart.isDisposed()) { + this.setCanceled(true); + return; + } + super.internalWorked(work); + } + }; + } + + public Shell getShell() { + return shell; + } + + public boolean isActive() { + return activeRunningOperations > 0; + } + + public boolean isLockedUI() { + return lockedUI; + } + + protected void restoreUiState(Map<Object, Object> state) { + // ignore + + } + + /** + * This implementation of IRunnableContext#run(boolean, boolean, IRunnableWithProgress) blocks until the runnable + * has been run, regardless of the value of <code>fork</code>. It is recommended that <code>fork</code> is set to + * true in most cases. If <code>fork</code> is set to <code>false</code>, the runnable will run in the UI thread and + * it is the runnable's responsibility to call <code>Display.readAndDispatch()</code> to ensure UI responsiveness. + * UI state is saved prior to executing the long-running operation and is restored after the long-running operation + * completes executing. Any attempt to change the UI state of the wizard in the long-running operation will be + * nullified when original UI state is restored. + */ + public void run(boolean fork, boolean cancelable, IRunnableWithProgress runnable) throws InvocationTargetException, + InterruptedException { + // The operation can only be canceled if it is executed in a separate + // thread. + // Otherwise the UI is blocked anyway. + Object state = null; + if (activeRunningOperations == 0) { + state = aboutToStart(fork && cancelable); + } + activeRunningOperations++; + try { + if (!fork) { + lockedUI = true; + } + ModalContext.run(runnable, fork, getProgressMonitor(), getShell().getDisplay()); + lockedUI = false; + } finally { + activeRunningOperations--; + // Stop if this is the last one + if (state != null) { + stopped(state); + } + } + } + + protected void saveUiState(Map<Object, Object> savedState) { + // ignore + + } + + public void setCancelButton(Button cancelButton) { + this.cancelButton = cancelButton; + } + + /** + * Sets the given cursor for all shells currently active for this window's display. + * + * @param c + * the cursor + */ + private void setDisplayCursor(Cursor c) { + Shell[] shells = getShell().getDisplay().getShells(); + for (Shell shell2 : shells) { + shell2.setCursor(c); + } + } + + /** + * A long running operation triggered through the wizard was stopped either by user input or by normal end. Hides + * the progress monitor and restores the enable state wizard's buttons and controls. + * + * @param savedState + * the saved UI state as returned by <code>aboutToStart</code> + * @see #aboutToStart + */ + @SuppressWarnings("unchecked") + private void stopped(Object savedState) { + if (getShell() != null && !getShell().isDisposed()) { + progressMonitorPart.setVisible(false); + if (cancelButton != null) { + progressMonitorPart.removeFromCancelComponent(cancelButton); + } + + Map<Object, Object> state = (Map<Object, Object>) savedState; + restoreUiState(state); + if (waitCursor != null) { + setDisplayCursor(null); + if (cancelButton != null) { + cancelButton.setCursor(null); + } + waitCursor.dispose(); + waitCursor = null; + arrowCursor.dispose(); + arrowCursor = null; + } + Control focusControl = (Control) state.get(FOCUS_CONTROL); + if (focusControl != null && !focusControl.isDisposed()) { + focusControl.setFocus(); + } + } + } + +}
\ No newline at end of file |