bundles/org.eclipse.jface/src/org/eclipse/jface/action/StatusLine.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2003 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Common Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/cpl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/

 package org.eclipse.jface.action;

 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.jface.dialogs.ProgressIndicator;
 import org.eclipse.jface.resource.*;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.CLabel;
 import org.eclipse.swt.events.*;
 import org.eclipse.swt.graphics.*;
 import org.eclipse.swt.layout.GridData;
 import org.eclipse.swt.layout.GridLayout;
 import org.eclipse.swt.widgets.*;

 /**
  * A StatusLine control is a SWT Composite with a horizontal layout which hosts
  * a number of status indication controls.
  * Typically it is situated below the content area of the window.
  * <p>
  * By default a StatusLine has two predefined status controls: a MessageLine and a
  * ProgressIndicator and it provides API for easy access.
  * </p>
  * <p>
  * This is an internal class, not intended to be used outside the JFace framework.
  * </p>
  */
 /* package */ class StatusLine extends Composite implements IProgressMonitor {

 	/** Horizontal gaps between items. */
 	public static final int GAP= 3;
 	/** Progress bar creation is delayed by this ms */
 	public static final int DELAY_PROGRESS= 500;

 	// state
 	protected boolean fProgressIsVisible= false;
 	protected boolean fCancelButtonIsVisible= false;
 	protected boolean fCancelEnabled= false;
 	protected String fTaskName;
 	protected boolean fIsCanceled;
 	protected long fStartTime;
 	private Cursor fStopButtonCursor;
 	protected String fMessageText;
 	protected Image fMessageImage;
 	protected String fErrorText;
 	protected Image fErrorImage;

 	// SWT widgets
 	protected CLabel fMessageLabel;
 	protected Composite fProgressBarComposite;
 	protected ProgressIndicator fProgressBar;
 	protected ToolBar fToolBar;
 	protected ToolItem fCancelButton;

 	protected static ImageDescriptor fgStopImage= ImageDescriptor.createFromFile(StatusLine.class, "images/stop.gif");//$NON-NLS-1$
 	static {
 		JFaceResources.getImageRegistry().put("org.eclipse.jface.parts.StatusLine.stopImage", fgStopImage);//$NON-NLS-1$
 	}

 	/**
 	 * Layout the contribution item controls on the status line.
 	 */
 	public class StatusLineLayout extends Layout {
 		private final StatusLineLayoutData DEFAULT_DATA = new StatusLineLayoutData();

 		public Point computeSize(Composite composite, int wHint, int hHint, boolean changed) {

 			if (wHint != SWT.DEFAULT && hHint != SWT.DEFAULT)
 				return new Point(wHint, hHint);

 			Control[] children= composite.getChildren();
 			int totalWidth= 0;
 			int maxHeight= 0;
 			int totalCnt= 0;
 			for (int i= 0; i < children.length; i++) {
 				boolean useWidth= true;
 				Control w= children[i];
 				if (w == fProgressBarComposite && !fProgressIsVisible)
 					useWidth= false;
 				else if (w == fToolBar && !fCancelButtonIsVisible)
 					useWidth= false;
 				StatusLineLayoutData data = (StatusLineLayoutData)w.getLayoutData();
 				if (data == null)
 					data = DEFAULT_DATA;
 				Point e= w.computeSize(data.widthHint, data.heightHint, changed);
 				if (useWidth) {
 					totalWidth+= e.x;
 					totalCnt++;
 				}
 				maxHeight= Math.max(maxHeight, e.y);
 			}
 			if (totalCnt > 0)
 				totalWidth+= (totalCnt-1) * GAP;
 			if (totalWidth <= 0)
 				totalWidth= maxHeight*4;
 			return new Point(totalWidth, maxHeight);
 		}

 		public void layout(Composite composite, boolean flushCache) {

 			if (composite == null)
 				return;

 			// StatusLineManager skips over the standard status line widgets
 			// in its update method. There is thus a dependency
 			// between the layout of the standard widgets and the update method.

 			// Make sure cancel button and progress bar are before contributions.
 			fMessageLabel.moveAbove(null);
 			fToolBar.moveBelow(fMessageLabel);
 			fProgressBarComposite.moveBelow(fToolBar);

 			Rectangle rect= composite.getClientArea();
 			Control[] children= composite.getChildren();
 			int count= children.length;

 			int ws[]= new int[count];

 			int h= rect.height;
 			int totalWidth= -GAP;
 			for (int i= 0; i < count; i++) {
 				Control w= children[i];
 				if (w == fProgressBarComposite && !fProgressIsVisible)
 					continue;
 				if (w == fToolBar && !fCancelButtonIsVisible)
 					continue;
 				StatusLineLayoutData data = (StatusLineLayoutData)w.getLayoutData();
 				if (data == null)
 					data = DEFAULT_DATA;
 				int width= w.computeSize(data.widthHint, h, flushCache).x;
 				ws[i]= width;
 				totalWidth+= width + GAP;
 			}

 			int diff= rect.width-totalWidth;
 			ws[0]+= diff;	// make the first StatusLabel wider

 			// Check against minimum recommended width
 			final int msgMinWidth = rect.width/3;
 			if (ws[0] < msgMinWidth) {
 				diff = ws[0] - msgMinWidth;
 				ws[0] = msgMinWidth;
 			} else {
 				diff = 0;
 			}

 			// Take space away from the contributions first.
 			for (int i = count -1; i >= 0 && diff < 0; --i) {
 				int min = Math.min(ws[i], -diff);
 				ws[i] -= min;
 				diff += min + GAP;
 			}

 			int x= rect.x;
 			int y= rect.y;
 			for (int i= 0; i < count; i++) {
 				Control w= children[i];
 				/*
 				 * Workaround for Linux Motif:
 				 * Even if the progress bar and cancel button are
 				 * not set to be visible ad of width 0, they still
 				 * draw over the first pixel of the editor
 				 * contributions.
 				 *
 				 * The fix here is to draw the progress bar and
 				 * cancel button off screen if they are not visible.
 				 */
 				if (w == fProgressBarComposite && !fProgressIsVisible ||
 					w == fToolBar && !fCancelButtonIsVisible) {
 					w.setBounds(x + rect.width, y, ws[i], h);
 					continue;
 				}
 				w.setBounds(x, y, ws[i], h);
 				if (ws[i] > 0) x+= ws[i] + GAP;
 			}
 		}
 	}


 	/**
 	 * Create a new StatusLine as a child of the given parent.
 	 */
 	public StatusLine(Composite parent) {
 		super(parent, SWT.NONE);

 		addDisposeListener(new DisposeListener() {
 			public void widgetDisposed(DisposeEvent e) {
 				handleDispose();
 			}
 		});

 		// StatusLineManager skips over the standard status line widgets
 		// in its update method. There is thus a dependency
 		// between this code defining the creation and layout of the standard
 		// widgets and the update method.

 		setLayout(new StatusLineLayout());

 		fMessageLabel= new CLabel(this, SWT.SHADOW_IN);

 		fProgressIsVisible= false;
 		fCancelEnabled= false;

 		fToolBar= new ToolBar(this, SWT.FLAT);
 		fCancelButton= new ToolItem(fToolBar, SWT.PUSH);
 		fCancelButton.setImage(fgStopImage.createImage());
 		fCancelButton.setToolTipText(JFaceResources.getString("Cancel_Current_Operation")); //$NON-NLS-1$
 		fCancelButton.addSelectionListener(
 			new SelectionAdapter() {
 				public void widgetSelected(SelectionEvent e) {
 					setCanceled(true);
 				}
 			}
 		);
 		fCancelButton.addDisposeListener(new DisposeListener(){
 			public void widgetDisposed(DisposeEvent e) {
 				Image i = fCancelButton.getImage();
 				if((i != null) && (!i.isDisposed()))
 					i.dispose();
 			}
 		});

 		// We create a composite to create the progress bar in
 		// so that it can be centered. See bug #32331
 		fProgressBarComposite = new Composite(this, SWT.NONE);
 		GridLayout layout = new GridLayout();
 		layout.horizontalSpacing = 0;
 		layout.verticalSpacing = 0;
 		layout.marginHeight = 0;
 		layout.marginWidth = 0;
 		fProgressBarComposite.setLayout(layout);
 		fProgressBar= new ProgressIndicator(fProgressBarComposite);
 		fProgressBar.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.GRAB_VERTICAL));

 		fStopButtonCursor= new Cursor(getDisplay(), SWT.CURSOR_ARROW);
 	}
 	/**
 	 * Notifies that the main task is beginning.
 	 *
 	 * @param name the name (or description) of the main task
 	 * @param totalWork the total number of work units into which
 	 * the main task is been subdivided. If the value is 0 or UNKNOWN the
 	 * implemenation is free to indicate progress in a way which doesn't
 	 * require the total number of work units in advance. In general users
 	 * should use the UNKNOWN value if they don't know the total amount of
 	 * work units.
 	 */
 	public void beginTask(String name, int totalWork) {
 		final long timestamp = System.currentTimeMillis();
 		fStartTime = timestamp;
 		final boolean animated = (totalWork == UNKNOWN || totalWork == 0);
 		// make sure the progress bar is made visible while
 		// the task is running. Fixes bug 32198 for the non-animated case.
 		Runnable timer = new Runnable() {
 			public void run() {
 				StatusLine.this.startTask(timestamp, animated);
 			}
 		};
 		fProgressBar.getDisplay().timerExec(DELAY_PROGRESS, timer);
 		if (!animated) {
 			fProgressBar.beginTask(totalWork);
 		}
 		if (name == null)
 			fTaskName= "";//$NON-NLS-1$
 		else
 			fTaskName= name;
 		setMessage(fTaskName);
 	}
 	/**
 	 * Notifies that the work is done; that is, either the main task is completed or the
 	 * user cancelled it.
 	 * Done() can be called more than once; an implementation should be prepared to handle
 	 * this case.
 	 */
 	public void done() {

 		fStartTime= 0;

 		if (fProgressBar != null) {
 			fProgressBar.sendRemainingWork();
 			fProgressBar.done();
 		}
 		setMessage("");//$NON-NLS-1$

 		hideProgress();
 	}
 	/**
 	 * Returns the status line's progress monitor
 	 */
 	public IProgressMonitor getProgressMonitor() {
 		return this;
 	}
 	/**
 	 * @private
 	 */
 	protected void handleDispose() {
 		fStopButtonCursor.dispose();
 		fStopButtonCursor= null;
 	}
 	/**
 	 * Hides the Cancel button and ProgressIndicator.
 	 * @private
 	 */
 	protected void hideProgress() {

 		if (fProgressIsVisible && !isDisposed()) {
 			fProgressIsVisible = false;
 			fCancelEnabled = false;
 			fCancelButtonIsVisible = false;
 			if (fToolBar != null && !fToolBar.isDisposed())
 				fToolBar.setVisible(false);
 			if (fProgressBarComposite != null && !fProgressBarComposite.isDisposed())
 				fProgressBarComposite.setVisible(false);
 			layout();
 		}
 	}
 	/**
 	 * @see IProgressMonitor#internalWorked(double)
 	 */
 	public void internalWorked(double work) {
 		if (! fProgressIsVisible) {
 			if (System.currentTimeMillis() - fStartTime > DELAY_PROGRESS)
 				showProgress();
 		}

 		if (fProgressBar != null) {
 			fProgressBar.worked(work);
 		}
 	}
 	/**
 	 * Returns true if the user does some UI action to cancel this operation.
 	 * (like hitting the Cancel button on the progress dialog).
 	 * The long running operation typically polls isCanceled().
 	 */
 	public boolean isCanceled() {
 		return fIsCanceled;
 	}
 	/**
 	 * Returns <code>true</true> if the ProgressIndication provides UI for canceling
 	 * a long running operation.
 	 */
 	public boolean isCancelEnabled() {
 		return fCancelEnabled;
 	}
 	/**
 	 * Sets the cancel status. This method is usually called with the
 	 * argument false if a client wants to abort a cancel action.
 	 */
 	public void setCanceled(boolean b) {
 		fIsCanceled = b;
 		if (fCancelButton != null)
 			fCancelButton.setEnabled(!b);
 	}
 	/**
 	 * Controls whether the ProgressIndication provides UI for canceling
 	 * a long running operation.
 	 * If the ProgressIndication is currently visible calling this method may have
 	 * a direct effect on the layout because it will make a cancel button visible.
 	 */
 	public void setCancelEnabled(boolean enabled) {
 		fCancelEnabled= enabled;
 		if (fProgressIsVisible && !fCancelButtonIsVisible && enabled) {
 			showButton();
 			layout();
 		}
 		if (fCancelButton != null && !fCancelButton.isDisposed())
 			fCancelButton.setEnabled(enabled);
 	}
 	/**
 	 * Sets the error message text to be displayed on the status line.
 	 * The image on the status line is cleared.
 	 *
 	 * @param message the error message, or <code>null</code> for no error message
 	 */
 	public void setErrorMessage(String message) {
 		setErrorMessage(null, message);
 	}
 	/**
 	 * Sets an image and error message text to be displayed on the status line.
 	 *
 	 * @param image the image to use, or <code>null</code> for no image
 	 * @param message the error message, or <code>null</code> for no error message
 	 */
 	public void setErrorMessage(Image image, String message) {
 		fErrorText = trim(message);
 		fErrorImage = image;
 		updateMessageLabel();
 	}
 	/**
 	 * Applies the given font to this status line.
 	 */
 	public void setFont(Font font) {
 		super.setFont(font);
 		Control[] children= getChildren();
 		for (int i= 0; i < children.length; i++) {
 			children[i].setFont(font);
 		}
 	}
 	/**
 	 * Sets the message text to be displayed on the status line.
 	 * The image on the status line is cleared.
 	 *
 	 * @param message the error message, or <code>null</code> for no error message
 	 */
 	public void setMessage(String message) {
 		setMessage(null, message);
 	}
 	/**
 	 * Sets an image and a message text to be displayed on the status line.
 	 *
 	 * @param image the image to use, or <code>null</code> for no image
 	 * @param message the message, or <code>null</code> for no message
 	 */
 	public void setMessage(Image image, String message) {
 		fMessageText = trim(message);
 		fMessageImage = image;
 		updateMessageLabel();
 	}
 	/**
 	 * @see IProgressMonitor#setTaskName(java.lang.String)
 	 */
 	public void setTaskName(String name) {
 		fTaskName= name;
 	}
 	/**
 	 * Makes the Cancel button visible.
 	 * @private
 	 */
 	protected void showButton() {
 		if (fToolBar != null && !fToolBar.isDisposed()) {
 			fToolBar.setVisible(true);
 			fToolBar.setEnabled(true);
 			fToolBar.setCursor(fStopButtonCursor);
 			fCancelButtonIsVisible= true;
 		}
 	}
 	/**
 	 * Shows the Cancel button and ProgressIndicator.
 	 * @private
  	 */
 	protected void showProgress() {
 		if (!fProgressIsVisible && !isDisposed()) {
 			fProgressIsVisible= true;
 			if (fCancelEnabled)
 				showButton();
 			if (fProgressBarComposite != null && !fProgressBarComposite.isDisposed())
 				fProgressBarComposite.setVisible(true);
 			layout();
 		}
 	}
 	/**
 	 * @private
 	 */
 	void startTask(final long timestamp, final boolean animated) {
 		if (!fProgressIsVisible && fStartTime == timestamp) {
 			showProgress();
 			if (animated) {
 				if (fProgressBar != null && !fProgressBar.isDisposed()) {
 					fProgressBar.beginAnimatedTask();
 				}
 			}
 		}
 	}
 	/**
 	 * Notifies that a subtask of the main task is beginning.
 	 * Subtasks are optional; the main task might not have subtasks.
 	 * @param name the name (or description) of the subtask
 	 * @see IProgressMonitor#subTask(String)
 	 */
 	public void subTask(String name) {
 		String text;
 		if (fTaskName.length() == 0)
 			text= name;
 		else
 			text = JFaceResources.format("Set_SubTask", new Object[] {fTaskName, name});//$NON-NLS-1$
 		setMessage(text);
 	}

 	/**
 	 * Trims the message to be displayable in the status line.
 	 * This just pulls out the first line of the message.
 	 * Allows null.
 	 */
 	String trim(String message) {
 		if (message == null)
 			return null;
 		int cr = message.indexOf('\r');
 		int lf = message.indexOf('\n');
 		if (cr == -1 && lf == -1)
 			return message;
 		int len;
 		if (cr == -1)
 			len = lf;
 		else if (lf == -1)
 			len = cr;
 		else
 			len = Math.min(cr, lf);
 		return message.substring(0, len);
 	}

 	/**
 	 * Updates the message label widget.
 	 */
 	protected void updateMessageLabel() {
 		if (fMessageLabel != null && !fMessageLabel.isDisposed()) {
 			Display display = fMessageLabel.getDisplay();
 			if ((fErrorText != null && fErrorText.length() > 0) || fErrorImage != null) {
 				fMessageLabel.setForeground(JFaceColors.getErrorText(display));
 				fMessageLabel.setText(fErrorText);
 				fMessageLabel.setImage(fErrorImage);
 			}
 			else {
 				fMessageLabel.setForeground(display.getSystemColor(SWT.COLOR_WIDGET_FOREGROUND));
 				fMessageLabel.setText(fMessageText == null ? "" : fMessageText); //$NON-NLS-1$
 				fMessageLabel.setImage(fMessageImage);
 			}
 		}
 	}
 	/**
 	 * @see IProgressMonitor#worked(int)
 	 */
 	public void worked(int work) {
 		internalWorked(work);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2003 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Common Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/cpl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/

	package org.eclipse.jface.action;

	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.jface.dialogs.ProgressIndicator;
	import org.eclipse.jface.resource.*;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.custom.CLabel;
	import org.eclipse.swt.events.*;
	import org.eclipse.swt.graphics.*;
	import org.eclipse.swt.layout.GridData;
	import org.eclipse.swt.layout.GridLayout;
	import org.eclipse.swt.widgets.*;

	/**
	* A StatusLine control is a SWT Composite with a horizontal layout which hosts
	* a number of status indication controls.
	* Typically it is situated below the content area of the window.
	* <p>
	* By default a StatusLine has two predefined status controls: a MessageLine and a
	* ProgressIndicator and it provides API for easy access.
	* </p>
	* <p>
	* This is an internal class, not intended to be used outside the JFace framework.
	* </p>
	*/
	/* package */ class StatusLine extends Composite implements IProgressMonitor {

	/** Horizontal gaps between items. */
	public static final int GAP= 3;
	/** Progress bar creation is delayed by this ms */
	public static final int DELAY_PROGRESS= 500;

	// state
	protected boolean fProgressIsVisible= false;
	protected boolean fCancelButtonIsVisible= false;
	protected boolean fCancelEnabled= false;
	protected String fTaskName;
	protected boolean fIsCanceled;
	protected long fStartTime;
	private Cursor fStopButtonCursor;
	protected String fMessageText;
	protected Image fMessageImage;
	protected String fErrorText;
	protected Image fErrorImage;

	// SWT widgets
	protected CLabel fMessageLabel;
	protected Composite fProgressBarComposite;
	protected ProgressIndicator fProgressBar;
	protected ToolBar fToolBar;
	protected ToolItem fCancelButton;

	protected static ImageDescriptor fgStopImage= ImageDescriptor.createFromFile(StatusLine.class, "images/stop.gif");//$NON-NLS-1$
	static {
	JFaceResources.getImageRegistry().put("org.eclipse.jface.parts.StatusLine.stopImage", fgStopImage);//$NON-NLS-1$
	}

	/**
	* Layout the contribution item controls on the status line.
	*/
	public class StatusLineLayout extends Layout {
	private final StatusLineLayoutData DEFAULT_DATA = new StatusLineLayoutData();

	public Point computeSize(Composite composite, int wHint, int hHint, boolean changed) {

	if (wHint != SWT.DEFAULT && hHint != SWT.DEFAULT)
	return new Point(wHint, hHint);

	Control[] children= composite.getChildren();
	int totalWidth= 0;
	int maxHeight= 0;
	int totalCnt= 0;
	for (int i= 0; i < children.length; i++) {
	boolean useWidth= true;
	Control w= children[i];
	if (w == fProgressBarComposite && !fProgressIsVisible)
	useWidth= false;
	else if (w == fToolBar && !fCancelButtonIsVisible)
	useWidth= false;
	StatusLineLayoutData data = (StatusLineLayoutData)w.getLayoutData();
	if (data == null)
	data = DEFAULT_DATA;
	Point e= w.computeSize(data.widthHint, data.heightHint, changed);
	if (useWidth) {
	totalWidth+= e.x;
	totalCnt++;
	}
	maxHeight= Math.max(maxHeight, e.y);
	}
	if (totalCnt > 0)
	totalWidth+= (totalCnt-1) * GAP;
	if (totalWidth <= 0)
	totalWidth= maxHeight*4;
	return new Point(totalWidth, maxHeight);
	}

	public void layout(Composite composite, boolean flushCache) {

	if (composite == null)
	return;

	// StatusLineManager skips over the standard status line widgets
	// in its update method. There is thus a dependency
	// between the layout of the standard widgets and the update method.

	// Make sure cancel button and progress bar are before contributions.
	fMessageLabel.moveAbove(null);
	fToolBar.moveBelow(fMessageLabel);
	fProgressBarComposite.moveBelow(fToolBar);

	Rectangle rect= composite.getClientArea();
	Control[] children= composite.getChildren();
	int count= children.length;

	int ws[]= new int[count];

	int h= rect.height;
	int totalWidth= -GAP;
	for (int i= 0; i < count; i++) {
	Control w= children[i];
	if (w == fProgressBarComposite && !fProgressIsVisible)
	continue;
	if (w == fToolBar && !fCancelButtonIsVisible)
	continue;
	StatusLineLayoutData data = (StatusLineLayoutData)w.getLayoutData();
	if (data == null)
	data = DEFAULT_DATA;
	int width= w.computeSize(data.widthHint, h, flushCache).x;
	ws[i]= width;
	totalWidth+= width + GAP;
	}

	int diff= rect.width-totalWidth;
	ws[0]+= diff; // make the first StatusLabel wider

	// Check against minimum recommended width
	final int msgMinWidth = rect.width/3;
	if (ws[0] < msgMinWidth) {
	diff = ws[0] - msgMinWidth;
	ws[0] = msgMinWidth;
	} else {
	diff = 0;
	}

	// Take space away from the contributions first.
	for (int i = count -1; i >= 0 && diff < 0; --i) {
	int min = Math.min(ws[i], -diff);
	ws[i] -= min;
	diff += min + GAP;
	}

	int x= rect.x;
	int y= rect.y;
	for (int i= 0; i < count; i++) {
	Control w= children[i];
	/*
	* Workaround for Linux Motif:
	* Even if the progress bar and cancel button are
	* not set to be visible ad of width 0, they still
	* draw over the first pixel of the editor
	* contributions.
	*
	* The fix here is to draw the progress bar and
	* cancel button off screen if they are not visible.
	*/
	if (w == fProgressBarComposite && !fProgressIsVisible \|\|
	w == fToolBar && !fCancelButtonIsVisible) {
	w.setBounds(x + rect.width, y, ws[i], h);
	continue;
	}
	w.setBounds(x, y, ws[i], h);
	if (ws[i] > 0) x+= ws[i] + GAP;
	}
	}
	}


	/**
	* Create a new StatusLine as a child of the given parent.
	*/
	public StatusLine(Composite parent) {
	super(parent, SWT.NONE);

	addDisposeListener(new DisposeListener() {
	public void widgetDisposed(DisposeEvent e) {
	handleDispose();
	}
	});

	// StatusLineManager skips over the standard status line widgets
	// in its update method. There is thus a dependency
	// between this code defining the creation and layout of the standard
	// widgets and the update method.

	setLayout(new StatusLineLayout());

	fMessageLabel= new CLabel(this, SWT.SHADOW_IN);

	fProgressIsVisible= false;
	fCancelEnabled= false;

	fToolBar= new ToolBar(this, SWT.FLAT);
	fCancelButton= new ToolItem(fToolBar, SWT.PUSH);
	fCancelButton.setImage(fgStopImage.createImage());
	fCancelButton.setToolTipText(JFaceResources.getString("Cancel_Current_Operation")); //$NON-NLS-1$
	fCancelButton.addSelectionListener(
	new SelectionAdapter() {
	public void widgetSelected(SelectionEvent e) {
	setCanceled(true);
	}
	}
	);
	fCancelButton.addDisposeListener(new DisposeListener(){
	public void widgetDisposed(DisposeEvent e) {
	Image i = fCancelButton.getImage();
	if((i != null) && (!i.isDisposed()))
	i.dispose();
	}
	});

	// We create a composite to create the progress bar in
	// so that it can be centered. See bug #32331
	fProgressBarComposite = new Composite(this, SWT.NONE);
	GridLayout layout = new GridLayout();
	layout.horizontalSpacing = 0;
	layout.verticalSpacing = 0;
	layout.marginHeight = 0;
	layout.marginWidth = 0;
	fProgressBarComposite.setLayout(layout);
	fProgressBar= new ProgressIndicator(fProgressBarComposite);
	fProgressBar.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL \| GridData.GRAB_VERTICAL));

	fStopButtonCursor= new Cursor(getDisplay(), SWT.CURSOR_ARROW);
	}
	/**
	* Notifies that the main task is beginning.
	*
	* @param name the name (or description) of the main task
	* @param totalWork the total number of work units into which
	* the main task is been subdivided. If the value is 0 or UNKNOWN the
	* implemenation is free to indicate progress in a way which doesn't
	* require the total number of work units in advance. In general users
	* should use the UNKNOWN value if they don't know the total amount of
	* work units.
	*/
	public void beginTask(String name, int totalWork) {
	final long timestamp = System.currentTimeMillis();
	fStartTime = timestamp;
	final boolean animated = (totalWork == UNKNOWN \|\| totalWork == 0);
	// make sure the progress bar is made visible while
	// the task is running. Fixes bug 32198 for the non-animated case.
	Runnable timer = new Runnable() {
	public void run() {
	StatusLine.this.startTask(timestamp, animated);
	}
	};
	fProgressBar.getDisplay().timerExec(DELAY_PROGRESS, timer);
	if (!animated) {
	fProgressBar.beginTask(totalWork);
	}
	if (name == null)
	fTaskName= "";//$NON-NLS-1$
	else
	fTaskName= name;
	setMessage(fTaskName);
	}
	/**
	* Notifies that the work is done; that is, either the main task is completed or the
	* user cancelled it.
	* Done() can be called more than once; an implementation should be prepared to handle
	* this case.
	*/
	public void done() {

	fStartTime= 0;

	if (fProgressBar != null) {
	fProgressBar.sendRemainingWork();
	fProgressBar.done();
	}
	setMessage("");//$NON-NLS-1$

	hideProgress();
	}
	/**
	* Returns the status line's progress monitor
	*/
	public IProgressMonitor getProgressMonitor() {
	return this;
	}
	/**
	* @private
	*/
	protected void handleDispose() {
	fStopButtonCursor.dispose();
	fStopButtonCursor= null;
	}
	/**
	* Hides the Cancel button and ProgressIndicator.
	* @private
	*/
	protected void hideProgress() {

	if (fProgressIsVisible && !isDisposed()) {
	fProgressIsVisible = false;
	fCancelEnabled = false;
	fCancelButtonIsVisible = false;
	if (fToolBar != null && !fToolBar.isDisposed())
	fToolBar.setVisible(false);
	if (fProgressBarComposite != null && !fProgressBarComposite.isDisposed())
	fProgressBarComposite.setVisible(false);
	layout();
	}
	}
	/**
	* @see IProgressMonitor#internalWorked(double)
	*/
	public void internalWorked(double work) {
	if (! fProgressIsVisible) {
	if (System.currentTimeMillis() - fStartTime > DELAY_PROGRESS)
	showProgress();
	}

	if (fProgressBar != null) {
	fProgressBar.worked(work);
	}
	}
	/**
	* Returns true if the user does some UI action to cancel this operation.
	* (like hitting the Cancel button on the progress dialog).
	* The long running operation typically polls isCanceled().
	*/
	public boolean isCanceled() {
	return fIsCanceled;
	}
	/**
	* Returns <code>true</true> if the ProgressIndication provides UI for canceling
	* a long running operation.
	*/
	public boolean isCancelEnabled() {
	return fCancelEnabled;
	}
	/**
	* Sets the cancel status. This method is usually called with the
	* argument false if a client wants to abort a cancel action.
	*/
	public void setCanceled(boolean b) {
	fIsCanceled = b;
	if (fCancelButton != null)
	fCancelButton.setEnabled(!b);
	}
	/**
	* Controls whether the ProgressIndication provides UI for canceling
	* a long running operation.
	* If the ProgressIndication is currently visible calling this method may have
	* a direct effect on the layout because it will make a cancel button visible.
	*/
	public void setCancelEnabled(boolean enabled) {
	fCancelEnabled= enabled;
	if (fProgressIsVisible && !fCancelButtonIsVisible && enabled) {
	showButton();
	layout();
	}
	if (fCancelButton != null && !fCancelButton.isDisposed())
	fCancelButton.setEnabled(enabled);
	}
	/**
	* Sets the error message text to be displayed on the status line.
	* The image on the status line is cleared.
	*
	* @param message the error message, or <code>null</code> for no error message
	*/
	public void setErrorMessage(String message) {
	setErrorMessage(null, message);
	}
	/**
	* Sets an image and error message text to be displayed on the status line.
	*
	* @param image the image to use, or <code>null</code> for no image
	* @param message the error message, or <code>null</code> for no error message
	*/
	public void setErrorMessage(Image image, String message) {
	fErrorText = trim(message);
	fErrorImage = image;
	updateMessageLabel();
	}
	/**
	* Applies the given font to this status line.
	*/
	public void setFont(Font font) {
	super.setFont(font);
	Control[] children= getChildren();
	for (int i= 0; i < children.length; i++) {
	children[i].setFont(font);
	}
	}
	/**
	* Sets the message text to be displayed on the status line.
	* The image on the status line is cleared.
	*
	* @param message the error message, or <code>null</code> for no error message
	*/
	public void setMessage(String message) {
	setMessage(null, message);
	}
	/**
	* Sets an image and a message text to be displayed on the status line.
	*
	* @param image the image to use, or <code>null</code> for no image
	* @param message the message, or <code>null</code> for no message
	*/
	public void setMessage(Image image, String message) {
	fMessageText = trim(message);
	fMessageImage = image;
	updateMessageLabel();
	}
	/**
	* @see IProgressMonitor#setTaskName(java.lang.String)
	*/
	public void setTaskName(String name) {
	fTaskName= name;
	}
	/**
	* Makes the Cancel button visible.
	* @private
	*/
	protected void showButton() {
	if (fToolBar != null && !fToolBar.isDisposed()) {
	fToolBar.setVisible(true);
	fToolBar.setEnabled(true);
	fToolBar.setCursor(fStopButtonCursor);
	fCancelButtonIsVisible= true;
	}
	}
	/**
	* Shows the Cancel button and ProgressIndicator.
	* @private
	*/
	protected void showProgress() {
	if (!fProgressIsVisible && !isDisposed()) {
	fProgressIsVisible= true;
	if (fCancelEnabled)
	showButton();
	if (fProgressBarComposite != null && !fProgressBarComposite.isDisposed())
	fProgressBarComposite.setVisible(true);
	layout();
	}
	}
	/**
	* @private
	*/
	void startTask(final long timestamp, final boolean animated) {
	if (!fProgressIsVisible && fStartTime == timestamp) {
	showProgress();
	if (animated) {
	if (fProgressBar != null && !fProgressBar.isDisposed()) {
	fProgressBar.beginAnimatedTask();
	}
	}
	}
	}
	/**
	* Notifies that a subtask of the main task is beginning.
	* Subtasks are optional; the main task might not have subtasks.
	* @param name the name (or description) of the subtask
	* @see IProgressMonitor#subTask(String)
	*/
	public void subTask(String name) {
	String text;
	if (fTaskName.length() == 0)
	text= name;
	else
	text = JFaceResources.format("Set_SubTask", new Object[] {fTaskName, name});//$NON-NLS-1$
	setMessage(text);
	}

	/**
	* Trims the message to be displayable in the status line.
	* This just pulls out the first line of the message.
	* Allows null.
	*/
	String trim(String message) {
	if (message == null)
	return null;
	int cr = message.indexOf('\r');
	int lf = message.indexOf('\n');
	if (cr == -1 && lf == -1)
	return message;
	int len;
	if (cr == -1)
	len = lf;
	else if (lf == -1)
	len = cr;
	else
	len = Math.min(cr, lf);
	return message.substring(0, len);
	}

	/**
	* Updates the message label widget.
	*/
	protected void updateMessageLabel() {
	if (fMessageLabel != null && !fMessageLabel.isDisposed()) {
	Display display = fMessageLabel.getDisplay();
	if ((fErrorText != null && fErrorText.length() > 0) \|\| fErrorImage != null) {
	fMessageLabel.setForeground(JFaceColors.getErrorText(display));
	fMessageLabel.setText(fErrorText);
	fMessageLabel.setImage(fErrorImage);
	}
	else {
	fMessageLabel.setForeground(display.getSystemColor(SWT.COLOR_WIDGET_FOREGROUND));
	fMessageLabel.setText(fMessageText == null ? "" : fMessageText); //$NON-NLS-1$
	fMessageLabel.setImage(fMessageImage);
	}
	}
	}
	/**
	* @see IProgressMonitor#worked(int)
	*/
	public void worked(int work) {
	internalWorked(work);
	}
	}