Attachment #98634 for bug #229294

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 43-50 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/progress/DetailedProgressViewer.java (-39 / +98 lines)
43	*/	43	*/
44	public class DetailedProgressViewer extends AbstractProgressViewer {	44	public class DetailedProgressViewer extends AbstractProgressViewer {
45		45
46	//Maximum number of entries to display so that the view does not flood the UI with events	46	// Maximum number of entries to display so that the view does not flood the
47	private static final int MAX_DISPLAYED = 20;	47	// UI with events
		48	private static final int MAX_DISPLAYED = 100;
48		49
49	Composite control;	50	Composite control;
50		51
Lines 52-57 Link Here
52		53
53	private Composite noEntryArea;	54	private Composite noEntryArea;
54		55
		56	private Composite currentlyActiveControl;
		57
55	/**	58	/**
56	* Create a new instance of the receiver with a control that is a child of	59	* Create a new instance of the receiver with a control that is a child of
57	* parent with style style.	60	* parent with style style.
Lines 61-79 Link Here
61	*/	64	*/
62	public DetailedProgressViewer(Composite parent, int style) {	65	public DetailedProgressViewer(Composite parent, int style) {
63	scrolled = new ScrolledComposite(parent, SWT.V_SCROLL \| style);	66	scrolled = new ScrolledComposite(parent, SWT.V_SCROLL \| style);
64	int height = JFaceResources.getDefaultFont().getFontData()[0]	67	int height = JFaceResources.getDefaultFont().getFontData()[0].getHeight();
65	.getHeight();
66	scrolled.getVerticalBar().setIncrement(height * 2);	68	scrolled.getVerticalBar().setIncrement(height * 2);
67	scrolled.setExpandHorizontal(true);	69	scrolled.setExpandHorizontal(true);
68	scrolled.setExpandVertical(true);	70	scrolled.setExpandVertical(true);
69		71
70	control = new Composite(scrolled, SWT.NONE);	72	control = new Composite(scrolled, SWT.BORDER);
71	GridLayout layout = new GridLayout();	73	GridLayout layout = new GridLayout();
72	layout.marginHeight = 0;	74	layout.marginHeight = 0;
73	layout.marginWidth = 0;	75	layout.marginWidth = 0;
74	control.setLayout(layout);	76	control.setLayout(layout);
75	control.setBackground(parent.getDisplay().getSystemColor(	77	control.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
76	SWT.COLOR_LIST_BACKGROUND));
77		78
78	control.addFocusListener(new FocusAdapter() {	79	control.addFocusListener(new FocusAdapter() {
79		80
Lines 95-109 Link Here
95	}	96	}
96	});	97	});
97		98
98	control.addControlListener(new ControlListener() {	99	scrolled.addControlListener(new ControlListener() {
		100
		101
99	/*	102	/*
100	* (non-Javadoc)	103	* (non-Javadoc)
101	*	104	*
102	* @see org.eclipse.swt.events.ControlListener#controlMoved(org.eclipse.swt.events.ControlEvent)	105	* @see org.eclipse.swt.events.ControlListener#controlMoved(org.eclipse.swt.events.ControlEvent)
103	*/	106	*/
104	public void controlMoved(ControlEvent e) {	107	public void controlMoved(ControlEvent e) {
105	updateVisibleItems();	108	updateSizes();
106
107	}	109	}
108		110
109	/*	111	/*
Lines 112-125 Link Here
112	* @see org.eclipse.swt.events.ControlListener#controlResized(org.eclipse.swt.events.ControlEvent)	114	* @see org.eclipse.swt.events.ControlListener#controlResized(org.eclipse.swt.events.ControlEvent)
113	*/	115	*/
114	public void controlResized(ControlEvent e) {	116	public void controlResized(ControlEvent e) {
115	updateVisibleItems();	117	updateSizes();
116	}	118	}
117	});	119	});
118		120
		121
		122
119	PlatformUI.getWorkbench().getHelpSystem().setHelp(control,	123	PlatformUI.getWorkbench().getHelpSystem().setHelp(control,
120	IWorkbenchHelpContextIds.RESPONSIVE_UI);	124	IWorkbenchHelpContextIds.RESPONSIVE_UI);
121		125
122	scrolled.setContent(control);
123	hookControl(control);	126	hookControl(control);
124		127
125	noEntryArea = new Composite(scrolled, SWT.NONE);	128	noEntryArea = new Composite(scrolled, SWT.NONE);
Lines 136-141 Link Here
136	PlatformUI.getWorkbench().getHelpSystem().setHelp(noEntryLabel,	139	PlatformUI.getWorkbench().getHelpSystem().setHelp(noEntryLabel,
137	IWorkbenchHelpContextIds.RESPONSIVE_UI);	140	IWorkbenchHelpContextIds.RESPONSIVE_UI);
138		141
		142	updateForShowingProgress();
		143	}
		144
		145	int doit = 0;
		146
		147	void updateSizes() {
		148	if (doit == 0) {
		149	doit--;
		150	scrolled.setRedraw(false);
		151
		152	updateVisibleItems();
		153
		154	if (currentlyActiveControl != null) {
		155	Point size = currentlyActiveControl.computeSize(scrolled.getClientArea().width,
		156	SWT.DEFAULT);
		157	size.x -= IDialogConstants.HORIZONTAL_SPACING;
		158	size.y -= IDialogConstants.VERTICAL_SPACING;
		159	// Rectangle r = currentlyActiveControl.getBounds();
		160	// r.getClass();
		161	scrolled.setMinHeight(size.y);
		162	// scrolled.setMinSize(size);
		163
		164	scrolled.layout(true);
		165	}
		166
		167
		168	scrolled.setRedraw(true);
		169	doit++;
		170	}
139	}	171	}
140		172
141	/*	173	/*
Lines 167-172 Link Here
167	sorter.sort(this, infos);	199	sorter.sort(this, infos);
168	}	200	}
169		201
		202	control.setRedraw(false);
170	// Update with the new elements to prevent flash	203	// Update with the new elements to prevent flash
171	for (int i = 0; i < existingChildren.length; i++) {	204	for (int i = 0; i < existingChildren.length; i++) {
172	((ProgressInfoItem) existingChildren[i]).dispose();	205	((ProgressInfoItem) existingChildren[i]).dispose();
Lines 174-196 Link Here
174		207
175	int totalSize = Math.min(newItems.size(), MAX_DISPLAYED);	208	int totalSize = Math.min(newItems.size(), MAX_DISPLAYED);
176		209
		210	List newInfoItems = new ArrayList();
177	for (int i = 0; i < totalSize; i++) {	211	for (int i = 0; i < totalSize; i++) {
178	ProgressInfoItem item = createNewItem(infos[i]);	212	ProgressInfoItem item = createNewItem(infos[i]);
179	item.setColor(i);	213	item.setColor(i);
		214	newInfoItems.add(item);
180	}	215	}
181		216
182	control.layout(true);
183	updateForShowingProgress();	217	updateForShowingProgress();
		218
		219	updateSizes();
		220
		221	updateVisibleItems();
		222
		223	control.setRedraw(true);
184	}	224	}
185		225
186	/**	226	/**
187	* Update for the progress being displayed.	227	* Update for the progress being displayed.
188	*/	228	*/
189	private void updateForShowingProgress() {	229	private void updateForShowingProgress() {
		230	Composite oldActive = currentlyActiveControl;
190	if (control.getChildren().length > 0) {	231	if (control.getChildren().length > 0) {
191	scrolled.setContent(control);	232	currentlyActiveControl = control;
192	} else {	233	}
193	scrolled.setContent(noEntryArea);	234	else {
		235	currentlyActiveControl = noEntryArea;
		236	}
		237	if (oldActive != currentlyActiveControl) {
		238	scrolled.setContent(currentlyActiveControl);
194	}	239	}
195	}	240	}
196		241
Lines 201-208 Link Here
201	* @return ProgressInfoItem	246	* @return ProgressInfoItem
202	*/	247	*/
203	private ProgressInfoItem createNewItem(JobTreeElement info) {	248	private ProgressInfoItem createNewItem(JobTreeElement info) {
204	final ProgressInfoItem item = new ProgressInfoItem(control, SWT.NONE,	249	final ProgressInfoItem item = new ProgressInfoItem(control, SWT.NONE, info);
205	info);
206		250
207	item.setIndexListener(new ProgressInfoItem.IndexListener() {	251	item.setIndexListener(new ProgressInfoItem.IndexListener() {
208	/*	252	/*
Lines 244-251 Link Here
244	}	288	}
245	});	289	});
246		290
247	// Refresh to populate with the current tasks
248	item.refresh();
249	return item;	291	return item;
250	}	292	}
251		293
Lines 262-268 Link Here
262	ProgressInfoItem previous;	304	ProgressInfoItem previous;
263	if (i == 0) {	305	if (i == 0) {
264	previous = (ProgressInfoItem) children[children.length - 1];	306	previous = (ProgressInfoItem) children[children.length - 1];
265	} else {	307	}
		308	else {
266	previous = (ProgressInfoItem) children[i - 1];	309	previous = (ProgressInfoItem) children[i - 1];
267	}	310	}
268		311
Lines 286-292 Link Here
286	ProgressInfoItem next;	329	ProgressInfoItem next;
287	if (i == children.length - 1) {	330	if (i == children.length - 1) {
288	next = (ProgressInfoItem) children[0];	331	next = (ProgressInfoItem) children[0];
289	} else {	332	}
		333	else {
290	next = (ProgressInfoItem) children[i + 1];	334	next = (ProgressInfoItem) children[i + 1];
291	}	335	}
292	item.selectWidgets(false);	336	item.selectWidgets(false);
Lines 315-322 Link Here
315	protected Widget doFindItem(Object element) {	359	protected Widget doFindItem(Object element) {
316	Control[] existingChildren = control.getChildren();	360	Control[] existingChildren = control.getChildren();
317	for (int i = 0; i < existingChildren.length; i++) {	361	for (int i = 0; i < existingChildren.length; i++) {
318	if (existingChildren[i].isDisposed()	362	if (existingChildren[i].isDisposed() \|\| existingChildren[i].getData() == null) {
319	\|\| existingChildren[i].getData() == null) {
320	continue;	363	continue;
321	}	364	}
322	if (existingChildren[i].getData().equals(element)) {	365	if (existingChildren[i].getData().equals(element)) {
Lines 337-343 Link Here
337	unmapElement(item);	380	unmapElement(item);
338	}	381	}
339	item.dispose();	382	item.dispose();
340	add(new Object[] { element });	383	add(new Object[] {
		384	element
		385	});
341	}	386	}
342		387
343	/*	388	/*
Lines 376-381 Link Here
376	* @see org.eclipse.jface.viewers.StructuredViewer#internalRefresh(java.lang.Object)	421	* @see org.eclipse.jface.viewers.StructuredViewer#internalRefresh(java.lang.Object)
377	*/	422	*/
378	protected void internalRefresh(Object element) {	423	protected void internalRefresh(Object element) {
		424
379	if (element == null) {	425	if (element == null) {
380	return;	426	return;
381	}	427	}
Lines 386-402 Link Here
386	}	432	}
387	Widget widget = findItem(element);	433	Widget widget = findItem(element);
388	if (widget == null) {	434	if (widget == null) {
389	add(new Object[] { element });	435	add(new Object[] {
		436	element
		437	});
390	return;	438	return;
391	}	439	}
392	((ProgressInfoItem) widget).refresh();	440
393		441
394	// Update the minimum size	442	// Update the minimum size
395	Point size = control.computeSize(SWT.DEFAULT, SWT.DEFAULT);	443	updateSizes();
396	size.x += IDialogConstants.HORIZONTAL_SPACING;
397	size.y += IDialogConstants.VERTICAL_SPACING;
398		444
399	scrolled.setMinSize(size);	445	((ProgressInfoItem) widget).refresh();
		446
		447	updateVisibleItems();
400	}	448	}
401		449
402	/*	450	/*
Lines 406-411 Link Here
406	*/	454	*/
407	public void remove(Object[] elements) {	455	public void remove(Object[] elements) {
408		456
		457	control.setRedraw(false);
409	for (int i = 0; i < elements.length; i++) {	458	for (int i = 0; i < elements.length; i++) {
410	JobTreeElement treeElement = (JobTreeElement) elements[i];	459	JobTreeElement treeElement = (JobTreeElement) elements[i];
411	// Make sure we are not keeping this one	460	// Make sure we are not keeping this one
Lines 415-421 Link Here
415	((ProgressInfoItem) item).refresh();	464	((ProgressInfoItem) item).refresh();
416	}	465	}
417		466
418	} else {	467	}
		468	else {
419	Widget item = doFindItem(treeElement);	469	Widget item = doFindItem(treeElement);
420	if (item == null) {	470	if (item == null) {
421	// Is the parent showing?	471	// Is the parent showing?
Lines 435-442 Link Here
435	ProgressInfoItem item = (ProgressInfoItem) existingChildren[i];	485	ProgressInfoItem item = (ProgressInfoItem) existingChildren[i];
436	item.setColor(i);	486	item.setColor(i);
437	}	487	}
438	control.layout(true);
439	updateForShowingProgress();	488	updateForShowingProgress();
		489	control.layout(true);
		490
		491	control.setRedraw(true);
440	}	492	}
441		493
442	/*	494	/*
Lines 478-484 Link Here
478	item.setButtonFocus();	530	item.setButtonFocus();
479	return;	531	return;
480	}	532	}
481	} else	533	}
		534	else
482	noEntryArea.setFocus();	535	noEntryArea.setFocus();
483	}	536	}
484		537
Lines 487-510 Link Here
487	*/	540	*/
488	private void refreshAll() {	541	private void refreshAll() {
489		542
		543	control.setRedraw(false);
490	Object[] infos = getSortedChildren(getRoot());	544	Object[] infos = getSortedChildren(getRoot());
491	Control[] existingChildren = control.getChildren();	545	Control[] existingChildren = control.getChildren();
492		546
493	for (int i = 0; i < existingChildren.length; i++) {	547	for (int i = 0; i < existingChildren.length; i++) {
494	existingChildren[i].dispose();	548	existingChildren[i].dispose();
495
496	}	549	}
497		550
498	int maxLength = Math.min(infos.length,MAX_DISPLAYED);	551	int maxLength = Math.min(infos.length, MAX_DISPLAYED);
499	// Create new ones if required	552	// Create new ones if required
500	for (int i = 0; i < maxLength; i++) {	553	for (int i = 0; i < maxLength; i++) {
501	ProgressInfoItem item = createNewItem((JobTreeElement) infos[i]);	554	ProgressInfoItem item = createNewItem((JobTreeElement) infos[i]);
502	item.setColor(i);	555	item.setColor(i);
503	}	556	}
504		557
505	control.layout(true);
506	updateForShowingProgress();
507		558
		559	// updateForShowingProgress();
		560	scrolled.setContent(currentlyActiveControl);
		561
		562	updateSizes();
		563
		564	updateVisibleItems();
		565
		566	control.setRedraw(true);
508	}	567	}
509		568
510	/**	569	/**




 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
import java.net.URL;
import com.ibm.icu.text.DateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.resource.LocalResourceManager;

import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;

import org.eclipse.ui.internal.WorkbenchImages;
import org.eclipse.ui.progress.IProgressConstants;

import com.ibm.icu.text.DateFormat;

/**
 * ProgressInfoItem is the item used to show jobs.
 * 


	ToolItem actionButton;

	LinkedList taskEntries = new LinkedList();

	private ProgressBar progressBar;



	static final int MIN_ICON_SIZE = 16;

	private static final int DIRECTION = SWT.VERTICAL;

	private static final String TEXT_KEY = "Text"; //$NON-NLS-1$

	private static final String ACTION_KEY = "Action";//$NON-NLS-1$

	private static final String JOB = "Job";//$NON-NLS-1$

	interface IndexListener {
		/**
		 * Select the item previous to the receiver.


	private ResourceManager resourceManager;

	private Composite linkComposite;

	static {
		JFaceResources.getImageRegistry().put(STOP_IMAGE_KEY,
				WorkbenchImages.getWorkbenchImageDescriptor("elcl16/progress_stop.gif"));//$NON-NLS-1$

		JFaceResources.getImageRegistry().put(DISABLED_STOP_IMAGE_KEY,
				WorkbenchImages.getWorkbenchImageDescriptor("dlcl16/progress_stop.gif"));//$NON-NLS-1$

		JFaceResources.getImageRegistry().put(DEFAULT_JOB_KEY,
				WorkbenchImages.getWorkbenchImageDescriptor("progress/progress_task.gif")); //$NON-NLS-1$

		JFaceResources.getImageRegistry().put(CLEAR_FINISHED_JOB_KEY,
				WorkbenchImages.getWorkbenchImageDescriptor("elcl16/progress_rem.gif")); //$NON-NLS-1$

		JFaceResources.getImageRegistry().put(DISABLED_CLEAR_FINISHED_JOB_KEY,
				WorkbenchImages.getWorkbenchImageDescriptor("dlcl16/progress_rem.gif")); //$NON-NLS-1$
		JFaceResources
				.getImageRegistry()
				.put(
						DEFAULT_JOB_KEY,
						WorkbenchImages
								.getWorkbenchImageDescriptor("progress/progress_task.gif")); //$NON-NLS-1$

		JFaceResources
				.getImageRegistry()
				.put(
						CLEAR_FINISHED_JOB_KEY,
						WorkbenchImages
								.getWorkbenchImageDescriptor("elcl16/progress_rem.gif")); //$NON-NLS-1$

		JFaceResources
				.getImageRegistry()
				.put(
						DISABLED_CLEAR_FINISHED_JOB_KEY,
						WorkbenchImages
								.getWorkbenchImageDescriptor("dlcl16/progress_rem.gif")); //$NON-NLS-1$

		// Mac has different Gamma value
		int shift = "carbon".equals(SWT.getPlatform()) ? -25 : -10;//$NON-NLS-1$ 

		Color lightColor = PlatformUI.getWorkbench().getDisplay().getSystemColor(
				SWT.COLOR_LIST_BACKGROUND);

		// Determine a dark color by shifting the list color
		RGB darkRGB = new RGB(Math.max(0, lightColor.getRed() + shift), Math.max(0, lightColor
				.getGreen()
				+ shift), Math.max(0, lightColor.getBlue() + shift));
				+ shift));
		JFaceResources.getColorRegistry().put(DARK_COLOR_KEY, darkRGB);
	}


	 * @param style
	 * @param progressInfo
	 */
	public ProgressInfoItem(Composite parent, int style, JobTreeElement progressInfo) {
			JobTreeElement progressInfo) {
		super(parent, style);
		setBackgroundMode(SWT.INHERIT_FORCE);
		info = progressInfo;
		createChildren();
		setData(info);
		setLayoutData(new GridData(SWT.FILL, SWT.NONE, true, false));
		addListener(SWT.Resize, new Listener() {

			public void handleEvent(Event event) {

				refresh();

				Point p = new Point(SWT.DEFAULT, SWT.DEFAULT);
				if (linkComposite != null) {
					Rectangle area = linkComposite.getClientArea();
					p = new Point(area.width, area.height);
				}
				updateSizes(p, true);
			}
		});
	}

	private int doit = 0;

	private void updateSizes(Point contraints, boolean performLayout) {

		if (doit == 0) {
			setMainText();

			if (linkComposite != null) {

				if (DIRECTION == SWT.HORIZONTAL) {
					Point preferred = linkComposite.computeSize(contraints.x, SWT.DEFAULT);
					GridData data = (GridData) linkComposite.getLayoutData();
					data.heightHint = preferred.y;
				}
				else {
					Point preferred = linkComposite.computeSize(SWT.DEFAULT, contraints.y);
					GridData data = (GridData) linkComposite.getLayoutData();
					data.widthHint = preferred.x;
				}

			}

			doit--;
			if (performLayout) {
				layout(true);
			}
			doit++;
		}
	}

	/**

	 */
	protected void createChildren() {

		GridLayoutFactory.fillDefaults().numColumns(3).extendedMargins(
				IDialogConstants.HORIZONTAL_SPACING / 2, IDialogConstants.HORIZONTAL_SPACING / 2,
				IDialogConstants.VERTICAL_SPACING / 2, IDialogConstants.VERTICAL_SPACING / 2)
				.applyTo(this);

		jobImageLabel = new Label(this, SWT.NONE);
		jobImageLabel.setImage(getInfoImage());
		GridDataFactory.swtDefaults().align(SWT.CENTER, SWT.CENTER).span(1, 3).hint(20, 20)
				.applyTo(jobImageLabel);
		imageData.left = new FormAttachment(
				IDialogConstants.HORIZONTAL_SPACING / 2);
		jobImageLabel.setLayoutData(imageData);

		progressLabel = new Label(this, SWT.NONE);
		GridDataFactory.swtDefaults().align(SWT.FILL, SWT.CENTER).grab(true, false).applyTo(
				progressLabel);

		actionBar = new ToolBar(this, SWT.NONE);
		GridDataFactory.swtDefaults().align(SWT.CENTER, SWT.CENTER).span(1, 3).applyTo(actionBar);

		actionBar = new ToolBar(this, SWT.FLAT);
		actionBar.setCursor(getDisplay().getSystemCursor(SWT.CURSOR_ARROW)); // set
		// cursor to overwrite any busy
		// to
		// overwrite
		// any
		// busy

		// cursor we might have
		actionButton = new ToolItem(actionBar, SWT.NONE);
		actionButton.setToolTipText(ProgressMessages.NewProgressView_CancelJobToolTip);
				.setToolTipText(ProgressMessages.NewProgressView_CancelJobToolTip);
		actionButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				actionButton.setEnabled(false);

		});
		updateToolBarValues();

		FormData progressData = new FormData();
		progressData.top = new FormAttachment(IDialogConstants.VERTICAL_SPACING);
		progressData.left = new FormAttachment(jobImageLabel,
				IDialogConstants.HORIZONTAL_SPACING / 2);
		progressData.right = new FormAttachment(actionBar,
				IDialogConstants.HORIZONTAL_SPACING);
		progressLabel.setLayoutData(progressData);

		mouseListener = new MouseAdapter() {
			/*
			 * (non-Javadoc)

		jobImageLabel.addMouseListener(mouseListener);
		progressLabel.addMouseListener(mouseListener);

		setLayoutsForNoProgress();

		refresh();
	}


	 * Set the main text of the receiver. Truncate to fit the available space.
	 */
	private void setMainText() {
		progressLabel.setText(Dialog.shortenText(getMainTitle(), progressLabel));
				.setText(Dialog.shortenText(getMainTitle(), progressLabel));
	}

	/**
	 * Set the layout of the widgets for the no progress case.
	 * 
	 */
	private void setLayoutsForNoProgress() {

		FormData buttonData = new FormData();
		buttonData.top = new FormAttachment(progressLabel, 0, SWT.TOP);
		buttonData.right = new FormAttachment(100,
				IDialogConstants.HORIZONTAL_SPACING * -1);

		actionBar.setLayoutData(buttonData);
		if (taskEntries.size() > 0) {
			FormData linkData = new FormData();
			linkData.top = new FormAttachment(progressLabel,
					IDialogConstants.VERTICAL_SPACING);
			linkData.left = new FormAttachment(progressLabel, 0, SWT.LEFT);
			linkData.right = new FormAttachment(actionBar, 0, SWT.LEFT);
			((Link) taskEntries.get(0)).setLayoutData(linkData);

		}
	}

	/**

	 * 
	 */
	protected void cancelOrRemove() {
		JobInfo[] infos = getJobInfos();
		if (FinishedJobs.getInstance().isKept(info) && isCompleted(infos)) {
			FinishedJobs.getInstance().remove(info);
		}
		else {
			info.cancel();
		}


		JobInfo jobInfo = (JobInfo) info;

		ImageDescriptor descriptor = null;
		Object property = jobInfo.getJob().getProperty(IProgressConstants.ICON_PROPERTY);
				IProgressConstants.ICON_PROPERTY);

		if (property instanceof ImageDescriptor) {
			descriptor = (ImageDescriptor) property;
		}
		else if (property instanceof URL) {
			descriptor = ImageDescriptor.createFromURL((URL) property);
		}

		Image image = null;
		if (descriptor == null) {
			image = ProgressManager.getInstance().getIconFor(jobInfo.getJob());
		}
		else {
			image = getResourceManager().createImageWithDefault(descriptor);
		}


	 */
	private ResourceManager getResourceManager() {
		if (resourceManager == null)
			resourceManager = new LocalResourceManager(JFaceResources.getResources());
					.getResources());
		return resourceManager;
	}



		if (jobInfo.isCanceled()) {
			if (job.getState() == Job.RUNNING)
				return NLS.bind(ProgressMessages.JobInfo_Cancel_Requested, name);
						.bind(ProgressMessages.JobInfo_Cancel_Requested, name);
			return NLS.bind(ProgressMessages.JobInfo_Cancelled, name);
		}

		if (jobInfo.isBlocked()) {
			IStatus blockedStatus = jobInfo.getBlockedStatus();
			return NLS.bind(ProgressMessages.JobInfo_Blocked, name, blockedStatus.getMessage());
					blockedStatus.getMessage());
		}

		switch (job.getState()) {

			time = getTimeString();
		}
		if (time != null) {
			return NLS.bind(ProgressMessages.JobInfo_FinishedAt, job.getName(), time);
					time);
		}
		return NLS.bind(ProgressMessages.JobInfo_Finished, job.getName());
	}

		if (isDisposed() || !isShowing)
			return;

		setRedraw(false);

		jobImageLabel.setImage(getInfoImage());
		int percentDone = getPercentDone();


							break;
						}
					}
				}
				else {
					createProgressBar(SWT.NONE);
					progressBar.setMinimum(0);
					progressBar.setMaximum(100);

			}

			// Protect against bad counters
			if (percentDone >= 0 && percentDone <= 100 && percentDone != progressBar.getSelection()) {
					&& percentDone != progressBar.getSelection()) {
				progressBar.setSelection(percentDone);
			}
		}

		else if (isCompleted(infos)) {

			if (progressBar != null) {
				progressBar.dispose();
				progressBar = null;
			}
			setLayoutsForNoProgress();

		}


				String subTaskString = null;
				Object[] jobChildren = jobInfo.getChildren();
				if (jobChildren.length > 0) {
					subTaskString = ((JobTreeElement) jobChildren[0]).getDisplayString();
							.getDisplayString();
				}

				if (subTaskString != null) {
					if (taskString == null || taskString.length() == 0) {
						taskString = subTaskString;
					}
					else {
						taskString = NLS.bind(ProgressMessages.JobInfo_DoneNoProgressMessage,
								taskString, subTaskString);
					}
				}
				if (taskString != null) {
					setLinkText(infos[i].getJob(), taskString, i);
				}
			}
			else {// Check for the finished job state
				Job job = jobInfo.getJob();
				IStatus result = job.getResult();

				if (result == null || result.getMessage().length() == 0 && !info.isJobInfo()) {
					setLinkText(job, null, i);
				}
				else {
					setLinkText(job, result.getMessage(), i);

				}


			}
			if (infos.length > 1)
				taskEntries.subList(0, infos.length - 1).clear();
			else
				taskEntries.clear();
		}

		updateToolBarValues();

		setRedraw(true);
	}

	/**

	 * 
	 * @return boolean <code>true</code> if the state is Job#NONE.
	 */
	private boolean isCompleted(JobInfo[] infos) {

		JobInfo[] infos = getJobInfos();
		for (int i = 0; i < infos.length; i++) {
			if (infos[i].getJob().getState() != Job.NONE) {
				return false;

	 */
	private JobInfo[] getJobInfos() {
		if (info.isJobInfo()) {
			return new JobInfo[] {
				(JobInfo) info
			};
		}
		Object[] children = info.getChildren();
		JobInfo[] infos = new JobInfo[children.length];

	 * 
	 */
	private void updateToolBarValues() {
		JobInfo[] infos = getJobInfos();
		if (isCompleted(infos)) {
			actionButton.setImage(JFaceResources.getImage(CLEAR_FINISHED_JOB_KEY));
			actionButton.setDisabledImage(JFaceResources.getImage(DISABLED_CLEAR_FINISHED_JOB_KEY));
			actionButton.setToolTipText(ProgressMessages.NewProgressView_ClearJobToolTip);
		}
		else {
		} else {
			actionButton.setImage(JFaceResources.getImage(STOP_IMAGE_KEY));
			actionButton.setDisabledImage(JFaceResources.getImage(DISABLED_STOP_IMAGE_KEY));
					.getImage(DISABLED_STOP_IMAGE_KEY));

		}
		JobInfo[] infos = getJobInfos();

		for (int i = 0; i < infos.length; i++) {
			// Only disable if there is an unresponsive operation
			if (infos[i].isCanceled() && !isCompleted(infos)) {
				actionButton.setEnabled(false);
				return;
			}

	 */
	void createProgressBar(int style) {

		FormData buttonData = new FormData();
		buttonData.top = new FormAttachment(progressLabel, 0);
		buttonData.right = new FormAttachment(100,
				IDialogConstants.HORIZONTAL_SPACING * -1);

		actionBar.setLayoutData(buttonData);

		progressBar = new ProgressBar(this, SWT.HORIZONTAL | style);
		progressBar.addMouseListener(mouseListener);
		if (linkComposite != null) {
			progressBar.moveAbove(linkComposite);
		barData.left = new FormAttachment(progressLabel, 0, SWT.LEFT);
		barData.right = new FormAttachment(actionBar,
				IDialogConstants.HORIZONTAL_SPACING * -1);
		barData.height = MAX_PROGRESS_HEIGHT;
		barData.width = 0;// default is too large
		progressBar.setLayoutData(barData);

		if (taskEntries.size() > 0) {
			// Reattach the link label if there is one
			FormData linkData = new FormData();
			linkData.top = new FormAttachment(progressBar,
					IDialogConstants.VERTICAL_SPACING);
			linkData.left = new FormAttachment(
					IDialogConstants.HORIZONTAL_SPACING);
			linkData.right = new FormAttachment(progressBar, 0, SWT.RIGHT);
			// Give an initial value so as to constrain the link shortening
			linkData.width = IDialogConstants.INDENT;

			((Link) taskEntries.get(0)).setLayoutData(linkData);
		}
		GridDataFactory.swtDefaults().hint(SWT.DEFAULT, MAX_PROGRESS_HEIGHT).align(SWT.FILL,
				SWT.CENTER).applyTo(progressBar);

	}

	/**

	 */
	void setLinkText(Job linkJob, String taskString, int index) {

		Control subTaskControl = null;
		if (index >= taskEntries.size()) {// Is it new?
			link = new Link(this, SWT.NONE);

			if (needsLinkComposite(taskString, linkJob)) {
				if (linkComposite == null) {
					linkComposite = new Composite(this, SWT.NONE);
					linkComposite.addMouseListener(mouseListener);

					RowLayout layout = new RowLayout(DIRECTION);
//					layout.justify=true;
					layout.fill=true;
					layout.marginBottom = 0;
					layout.marginLeft = 0;
					layout.marginRight = 0;
					layout.marginTop = 0;
					linkComposite.setLayout(layout);

					GridDataFactory.swtDefaults().align(SWT.FILL, SWT.CENTER).grab(true, false)
							.applyTo(linkComposite);

				}
				if (getAction(linkJob) == null) {
					subTaskControl = new Label(linkComposite, SWT.NONE);
				}
				else {
					subTaskControl = new Link(linkComposite, SWT.NONE);
				}
				addControlListeners(subTaskControl);

				taskEntries.add(subTaskControl);
			}
		}
		else {
			subTaskControl = (Control) taskEntries.get(index);
		}

		if (subTaskControl != null) {
			if (taskString != null) {
				subTaskControl.setToolTipText(taskString);
			}
			subTaskControl.setData(TEXT_KEY, taskString);
			subTaskControl.setData(JOB, linkJob);

			// check for action property
			updateAction(linkJob, subTaskControl);

			updateText(taskString, subTaskControl);
		}

	}

	private void addControlListeners(final Control control) {
		control.addListener(SWT.Selection, new Listener() {
			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)
			 */
			public void handleEvent(Event e) {

				IAction action = (IAction) control.getData(ACTION_KEY);
				action.run();

				updateAction((Job) control.getData(JOB), control);

				Object text = control.getData(TEXT_KEY);
				if (text == null)
					return;

				// Refresh the text as enablement might have changed
				updateText((String) text, control);
			}
		});

		control.addListener(SWT.Resize, new Listener() {
			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event)
			 */
			public void handleEvent(Event event) {

				Object text = control.getData(TEXT_KEY);
				if (text == null)
					return;

				updateText((String) text, control);

			}
		});
	}

	/**

	 *            {@link Object} or <code>null</code>
	 * @param link
	 */
	private void updateAction(Job linkJob, Control link) {
		link.setData(ACTION_KEY, getAction(linkJob));
		if (action != null && action instanceof IAction
				&& ((IAction) action).isEnabled())
			link.setData(ACTION_KEY, action);
		else
			link.setData(ACTION_KEY, null);

	}

	/**

	 * @param taskString
	 * @param link
	 */
	private void updateText(String taskString, Control control) {
		 String processedString = Dialog.shortenText(taskString, control.getParent());

		// Put in a hyperlink if there is an action
		IAction action = (IAction) control.getData(ACTION_KEY);
		if (action != null) {
			if (processedString == null) {
				processedString = NLS.bind("<a>{0}</a>", action.getText());//$NON-NLS-1$
			}
			else {
				processedString = NLS.bind("<a>{0}</a>", processedString);//$NON-NLS-1$
			}
		}
		if (processedString != null) {
			if (control instanceof Link) {
				if (action == null) {
					Label label = new Label(linkComposite, SWT.NONE);
					label.moveAbove(control);
					control.dispose();
					label.setText(processedString);
					addControlListeners(label);
					for (ListIterator taskItr = taskEntries.listIterator(); taskItr.hasNext();) {
						Control c = (Control) taskItr.next();
						if (c == control) {
							taskItr.set(label);
							break;
						}
					}
				}
				else {
					((Link) control).setText(processedString);
					control.getParent().layout(true);
				}
			}
			else {
				if (action == null) {
					((Label) control).setText(processedString);
					control.getParent().layout(true);
				}
				else {
					Link link = new Link(linkComposite, SWT.NONE);
					link.moveAbove(control);
					control.dispose();
					link.setText(processedString);
					addControlListeners(link);
					for (ListIterator taskItr = taskEntries.listIterator(); taskItr.hasNext();) {
						Control c = (Control) taskItr.next();
						if (c == control) {
							taskItr.set(link);
							break;
						}
					}
				}
			}
		}
	}

	private IAction getAction(Job linkJob) {
		Object action = linkJob.getProperty(IProgressConstants.ACTION_PROPERTY);
		if (action != null && action instanceof IAction && ((IAction) action).isEnabled()) {
			return (IAction) action;
		}
		return null;
	}

	private boolean needsLinkComposite(String taskString, Job linkJob) {
		if (getAction(linkJob) != null)
			return true;
		return taskString != null;
	}

	/**

		currentIndex = i;

		if (selected) {
			setAllBackgrounds(getDisplay().getSystemColor(SWT.COLOR_LIST_SELECTION));
			setAllForegrounds(getDisplay().getSystemColor(SWT.COLOR_LIST_SELECTION_TEXT));
			setAllForegrounds(getDisplay().getSystemColor(
					SWT.COLOR_LIST_SELECTION_TEXT));
			return;
		}

		if (i % 2 == 0) {
			setAllBackgrounds(JFaceResources.getColorRegistry().get(DARK_COLOR_KEY));
					DARK_COLOR_KEY));
		} else {
			setAllBackgrounds(getDisplay().getSystemColor(
					SWT.COLOR_LIST_BACKGROUND));
		}
		else {
			setAllBackgrounds(getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
		}
		setAllForegrounds(getDisplay().getSystemColor(SWT.COLOR_LIST_FOREGROUND));
	}

	/**


		Iterator taskEntryIterator = taskEntries.iterator();
		while (taskEntryIterator.hasNext()) {
			((Control) taskEntryIterator.next()).setForeground(color);
		}

	}

	 * @param color
	 */
	private void setAllBackgrounds(Color color) {
		// backgrounds are inherited, so only do it once
		setBackground(color);
		progressLabel.setBackground(color);
		actionBar.setBackground(color);
		jobImageLabel.setBackground(color);

		Iterator taskEntryIterator = taskEntries.iterator();
		while (taskEntryIterator.hasNext()) {
			((Link) taskEntryIterator.next()).setBackground(color);
		}

	}

	/**

		if (refresh)
			refresh();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.swt.widgets.Widget#dispose()
	 */
	public void dispose() {
		super.dispose();
		if (resourceManager != null)
			resourceManager.dispose();
	}
}

Return to bug 229294