Attachment #155343 for bug #293098

View | Details | Raw Unified | Return to bug 293098
Collapse All | Expand All




	 *            and <code>false</code> if it should be disabled
	 * @return the saved UI state
	 */
	private Map aboutToStart(boolean enableCancelButton) {
		Map savedState = null;
		if (getShell() != null) {
			// Save focus control

		// The operation can only be canceled if it is executed in a separate
		// thread.
		// Otherwise the UI is blocked anyway.
		Map state = startOperation(fork && cancelable);
		
			state = aboutToStart(fork && cancelable);
		}
		activeRunningOperations++;
		try {
			if (!fork) {
				lockedUI = true;

					.getDisplay());
			lockedUI = false;
		} finally {
			stopOperation(state);
		}
	}

	/**
	 * @param state
	 * @since 3.6
	 * @nooverride This method is not intended to be re-implemented or extended by clients.
	 */
	protected synchronized void stopOperation(final Map state) {
		
		getContents().getDisplay().syncExec(new Runnable() {

			public void run() {
				// explicitly invoke done() on our progress monitor so that its
				// label does not spill over to the next invocation, see bug 271530
				if (getProgressMonitor() != null) {
					getProgressMonitor().done();
				}
				activeRunningOperations--;
				// Stop if this is the last one
				if (state != null) {
					stopped(state);
				}
			}
			
		});
	}

	/**
	 * @param enableCancelButton
	 * @return state
	 * @since 3.6
	 * @nooverride This method is not intended to be re-implemented or extended by clients.
	 */
	protected synchronized Map startOperation(final boolean enableCancelButton) {
		final Map state[] = new Map[1];
		if (activeRunningOperations == 0) {
			getContents().getDisplay().syncExec(new Runnable() {
				
				public void run() {
					state[0] = aboutToStart(enableCancelButton);
				}
			});
		}
		activeRunningOperations++;
		return state[0];
	}

	/**

			});
		}
	}

}





import org.eclipse.jface.viewers.AbstractTreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.IWorkbenchPartSite;
import org.eclipse.ui.model.BaseWorkbenchContentProvider;
import org.eclipse.ui.progress.DeferredTreeContentManager;

public class DeferredContentProvider extends BaseWorkbenchContentProvider {

	private DeferredTreeContentManager manager;
	private final IWorkbenchPartSite site;
	
	public DeferredContentProvider(IWorkbenchPartSite site) {
		this.site = site;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
	 */
	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
		if (viewer instanceof AbstractTreeViewer) {
			manager = new MyDeferredTreeContentManager((AbstractTreeViewer) viewer, site);
		}
		super.inputChanged(viewer, oldInput, newInput);
	}

Lines 62-68 Link Here

(-)src/org/eclipse/ui/examples/jobs/views/LazyTreeView.java (-1 / +1 lines)
62	});	62	});
63	batchButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));	63	batchButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
64	viewer = new TreeViewer(parent, SWT.MULTI \| SWT.H_SCROLL \| SWT.V_SCROLL);	64	viewer = new TreeViewer(parent, SWT.MULTI \| SWT.H_SCROLL \| SWT.V_SCROLL);
65	viewer.setContentProvider(new DeferredContentProvider());	65	viewer.setContentProvider(new DeferredContentProvider(getSite()));
66	viewer.setLabelProvider(new WorkbenchLabelProvider());	66	viewer.setLabelProvider(new WorkbenchLabelProvider());
67	viewer.setInput(new SlowElement("root")); //$NON-NLS-1$	67	viewer.setInput(new SlowElement("root")); //$NON-NLS-1$
68	viewer.getTree().setLayoutData(new GridData(GridData.FILL_BOTH));	68	viewer.getTree().setLayoutData(new GridData(GridData.FILL_BOTH));




package org.eclipse.ui.examples.jobs.views;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jface.viewers.AbstractTreeViewer;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IWorkbenchPartSite;
import org.eclipse.ui.progress.DeferredTreeContentManager;
import org.eclipse.ui.progress.PendingUpdateAdapter;

public class MyDeferredTreeContentManager extends DeferredTreeContentManager {

	private final AbstractTreeViewer viewer;
	private PendingUpdateAdapter updateAdapter;

	public MyDeferredTreeContentManager(AbstractTreeViewer viewer, IWorkbenchPartSite site) {
		super(viewer, site);
		this.viewer = viewer;
	}
	
	int total;
	int worked;
	
	public IProgressMonitor getProgressMonitorForUpdateJob() {
		return new MyProgressMonitor();
	};

	protected void updateStatus() {
		Display.getDefault().syncExec(new Runnable() {
			
			public void run() {
				viewer.update(updateAdapter, new String[] {"label"});
			}
		});
	}

	protected PendingUpdateAdapter createPendingUpdateAdapter() {

		updateAdapter = new PendingUpdateAdapter() {
			public String getLabel(Object o) {
				if(total <= 0)
					return super.getLabel(o);
				int percent = ((worked*100)/total);
				return super.getLabel(o)+" ("+percent+"% done)";
			};
		};
		return updateAdapter;
	};
	
	
	class MyProgressMonitor extends NullProgressMonitor{
		@Override
		public void internalWorked(double work) {
			worked+=work;
			updateStatus();
		}
		
		public void beginTask(String name, int totalWork) {
			total = totalWork;
			worked = 0;
			updateStatus();
		}
	}

}




		if (object instanceof SlowElement) {
			Object[] children = ((SlowElement) object).getChildren();
			if (isBatchFetchedChildren()) {
				monitor.beginTask("updating children", 4);
				for(int i=0;i<4;i++) {
					sleep(1000);
					monitor.worked(1);
				}
				collector.add(children, monitor);
			} else {
				monitor.beginTask("updating children", children.length);
				for (int i = 0; i < children.length; i++) {
					if (monitor.isCanceled()) {
						return;
					}
					collector.add(children[i], monitor);
					sleep(1000);
					monitor.worked(1);
				}
			}
		}
		monitor.done();
	}

	private void sleep(long mills) {




	 * The JobMonitor is the inner class that handles the IProgressMonitor
	 * integration with the ProgressMonitor.
	 */
	public class JobMonitor implements IProgressMonitorWithBlocking {
		Job job;

		String currentTaskName;

		IProgressMonitor listener;

		/**
		 * Create a monitor on the supplied job.

		 * 
		 * @param monitor
		 */
		public void addProgressListener(IProgressMonitor monitor) {
			listener = monitor;
			JobInfo info = getJobInfo(job);
			final TaskInfo currentTask = info.getTaskInfo();
			if (currentTask != null) {
				listener.beginTask(currentTaskName, currentTask.totalWork);
				runInUIThread(new Runnable() {

					public void run() {
						listener.internalWorked(currentTask.preWork);
					}
				});
			}
		}


		 * @see org.eclipse.core.runtime.IProgressMonitor#beginTask(java.lang.String,
		 *      int)
		 */
		public void beginTask(final String taskName, final int totalWork) {
			JobInfo info = getJobInfo(job);
			info.beginTask(taskName, totalWork);
			refreshJobInfo(info);
			currentTaskName = taskName;
			if (listener != null) {
				Display.getDefault().asyncExec(new Runnable() {

					public void run() {
						listener.beginTask(taskName, totalWork);
					}
				});

			}
		}


			info.clearChildren();
			runnableMonitors.remove(job);
			if (listener != null) {
				runInUIThread(new Runnable() {

					public void run() {
						listener.done();
					}
				});
			}
		}


		 * 
		 * @see org.eclipse.core.runtime.IProgressMonitor#internalWorked(double)
		 */
		public void internalWorked(final double work) {
			JobInfo info = getJobInfo(job);
			if (info.hasTaskInfo()) {
				info.addWork(work);
				refreshJobInfo(info);
			}
			if (listener != null) {

				runInUIThread(new Runnable() {

					public void run() {
						listener.internalWorked(work);
					}
				});

			}
		}


			JobInfo info = getJobInfo(job);
			info.setBlockedStatus(null);
			refreshJobInfo(info);
			if (listener instanceof IProgressMonitorWithBlocking) {
				((IProgressMonitorWithBlocking) listener).clearBlocked();
			}
		}


			JobInfo info = getJobInfo(job);
			info.setBlockedStatus(reason);
			refreshJobInfo(info);
			if (listener instanceof IProgressMonitorWithBlocking) {
				((IProgressMonitorWithBlocking) listener).setBlocked(reason);
			}
		}
	}

		synchronized (runnableMonitors) {
			JobMonitor monitor = (JobMonitor) runnableMonitors.get(job);
			if (monitor == null) {
				monitor = (JobMonitor) jobMonitors.get(job);
				if (monitor == null) {
					monitor = new JobMonitor(job);
				}
				runnableMonitors.put(job, monitor);
			}
			


	}

	private void runInUIThread(Runnable runnable) {
		Display display = Display.getDefault();
		if (display.isDisposed())
			return;
		if (display.getThread() == Thread.currentThread()) {
			runnable.run();
		} else {
			display.asyncExec(runnable);
		}
	}

	private class RunnableWithStatus implements Runnable {

		IStatus status = Status.OK_STATUS;

		}

	}

	Map jobMonitors = new HashMap();

	public void registerMonitorForJob(Job job, IProgressMonitor monitor) {
		jobMonitors.put(job, monitor);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.ui.progress.IProgressService#addProgressListenerForJob(org
	 * .eclipse.core.runtime.jobs.Job,
	 * org.eclipse.core.runtime.IProgressMonitor)
	 */
	public void addProgressMonitorForJob(Job job, IProgressMonitor monitor) {
		progressFor(job).addProgressListener(monitor);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.ui.progress.IProgressService#removeProgressListenerForJob
	 * (org.eclipse.core.runtime.jobs.Job,
	 * org.eclipse.core.runtime.IProgressMonitor)
	 */
	public void removeProgressMonitorForJob(Job job, IProgressMonitor monitor) {
		// TODO
	}
}

Lines 424-427 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/progress/WorkbenchSiteProgressService.java (+8 lines)
424	public SiteUpdateJob getUpdateJob() {	424	public SiteUpdateJob getUpdateJob() {
425	return updateJob;	425	return updateJob;
426	}	426	}
		427
		428	public void addProgressMonitorForJob(Job job, IProgressMonitor monitor) {
		429	getWorkbenchProgressService().addProgressMonitorForJob(job, monitor);
		430	}
		431
		432	public void removeProgressMonitorForJob(Job job, IProgressMonitor monitor) {
		433	getWorkbenchProgressService().removeProgressMonitorForJob(job, monitor);
		434	}
427	}	435	}

Lines 308-313 Link Here

(-)Eclipse UI/org/eclipse/ui/progress/DeferredTreeContentManager.java (+11 lines)
308	if (progressService == null) {	308	if (progressService == null) {
309	job.schedule();	309	job.schedule();
310	} else {	310	} else {
		311	IProgressMonitor progressMonitor = getProgressMonitorForUpdateJob();
		312	if (progressMonitor != null)
		313	progressService.addProgressMonitorForJob(job, progressMonitor);
311	progressService.schedule(job);	314	progressService.schedule(job);
312	}	315	}
313	}	316	}
Lines 527-530 Link Here
527	}	530	}
528	}	531	}
529		532
		533	/**
		534	* @return monitor
		535	* @since 3.6
		536	*/
		537	public IProgressMonitor getProgressMonitorForUpdateJob() {
		538	return null;
		539	}
		540
530	}	541	}




package org.eclipse.ui.progress;

import java.lang.reflect.InvocationTargetException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.jobs.IJobManager;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;

     */
    public void showInDialog(Shell shell, Job job);

	/**
	 * @param job
	 * @param monitor
	 * @since 3.6
	 */
	public void addProgressMonitorForJob(Job job, IProgressMonitor monitor);

	/**
	 * @param job
	 * @param monitor
	 * @since 3.6
	 */
	public void removeProgressMonitorForJob(Job job, IProgressMonitor monitor);

}

Return to bug 293098

Lines 305-311 Link Here

(-)src/org/eclipse/jface/wizard/WizardDialog.java (-15 / +49 lines)
305	* and <code>false</code> if it should be disabled	305	* and <code>false</code> if it should be disabled
306	* @return the saved UI state	306	* @return the saved UI state
307	*/	307	*/
308	private Object aboutToStart(boolean enableCancelButton) {	308	private Map aboutToStart(boolean enableCancelButton) {
309	Map savedState = null;	309	Map savedState = null;
310	if (getShell() != null) {	310	if (getShell() != null) {
311	// Save focus control	311	// Save focus control
Lines 932-942 Link Here
932	// The operation can only be canceled if it is executed in a separate	932	// The operation can only be canceled if it is executed in a separate
933	// thread.	933	// thread.
934	// Otherwise the UI is blocked anyway.	934	// Otherwise the UI is blocked anyway.
935	Object state = null;	935	Map state = startOperation(fork && cancelable);
936	if (activeRunningOperations == 0) {	936
937	state = aboutToStart(fork && cancelable);
938	}
939	activeRunningOperations++;
940	try {	937	try {
941	if (!fork) {	938	if (!fork) {
942	lockedUI = true;	939	lockedUI = true;
Lines 945-961 Link Here
945	.getDisplay());	942	.getDisplay());
946	lockedUI = false;	943	lockedUI = false;
947	} finally {	944	} finally {
948	// explicitly invoke done() on our progress monitor so that its	945	stopOperation(state);
949	// label does not spill over to the next invocation, see bug 271530	946	}
950	if (getProgressMonitor() != null) {	947	}
951	getProgressMonitor().done();	948
952	}	949	/**
953	activeRunningOperations--;	950	* @param state
954	// Stop if this is the last one	951	* @since 3.6
955	if (state != null) {	952	* @nooverride This method is not intended to be re-implemented or extended by clients.
956	stopped(state);	953	*/
		954	protected synchronized void stopOperation(final Map state) {
		955
		956	getContents().getDisplay().syncExec(new Runnable() {
		957
		958	public void run() {
		959	// explicitly invoke done() on our progress monitor so that its
		960	// label does not spill over to the next invocation, see bug 271530
		961	if (getProgressMonitor() != null) {
		962	getProgressMonitor().done();
		963	}
		964	activeRunningOperations--;
		965	// Stop if this is the last one
		966	if (state != null) {
		967	stopped(state);
		968	}
957	}	969	}
		970
		971	});
		972	}
		973
		974	/**
		975	* @param enableCancelButton
		976	* @return state
		977	* @since 3.6
		978	* @nooverride This method is not intended to be re-implemented or extended by clients.
		979	*/
		980	protected synchronized Map startOperation(final boolean enableCancelButton) {
		981	final Map state[] = new Map[1];
		982	if (activeRunningOperations == 0) {
		983	getContents().getDisplay().syncExec(new Runnable() {
		984
		985	public void run() {
		986	state[0] = aboutToStart(enableCancelButton);
		987	}
		988	});
958	}	989	}
		990	activeRunningOperations++;
		991	return state[0];
959	}	992	}
960		993
961	/**	994	/**
Lines 1517-1520 Link Here
1517	});	1550	});
1518	}	1551	}
1519	}	1552	}
		1553
1520	}	1554	}

Lines 167-178 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/progress/ProgressManager.java (-15 / +82 lines)
167	* The JobMonitor is the inner class that handles the IProgressMonitor	167	* The JobMonitor is the inner class that handles the IProgressMonitor
168	* integration with the ProgressMonitor.	168	* integration with the ProgressMonitor.
169	*/	169	*/
170	class JobMonitor implements IProgressMonitorWithBlocking {	170	public class JobMonitor implements IProgressMonitorWithBlocking {
171	Job job;	171	Job job;
172		172
173	String currentTaskName;	173	String currentTaskName;
174		174
175	IProgressMonitorWithBlocking listener;	175	IProgressMonitor listener;
176		176
177	/**	177	/**
178	* Create a monitor on the supplied job.	178	* Create a monitor on the supplied job.
Lines 188-200 Link Here
188	*	188	*
189	* @param monitor	189	* @param monitor
190	*/	190	*/
191	void addProgressListener(IProgressMonitorWithBlocking monitor) {	191	public void addProgressListener(IProgressMonitor monitor) {
192	listener = monitor;	192	listener = monitor;
193	JobInfo info = getJobInfo(job);	193	JobInfo info = getJobInfo(job);
194	TaskInfo currentTask = info.getTaskInfo();	194	final TaskInfo currentTask = info.getTaskInfo();
195	if (currentTask != null) {	195	if (currentTask != null) {
196	listener.beginTask(currentTaskName, currentTask.totalWork);	196	listener.beginTask(currentTaskName, currentTask.totalWork);
197	listener.internalWorked(currentTask.preWork);	197	runInUIThread(new Runnable() {
		198
		199	public void run() {
		200	listener.internalWorked(currentTask.preWork);
		201	}
		202	});
198	}	203	}
199	}	204	}
200		205
Lines 204-216 Link Here
204	* @see org.eclipse.core.runtime.IProgressMonitor#beginTask(java.lang.String,	209	* @see org.eclipse.core.runtime.IProgressMonitor#beginTask(java.lang.String,
205	* int)	210	* int)
206	*/	211	*/
207	public void beginTask(String taskName, int totalWork) {	212	public void beginTask(final String taskName, final int totalWork) {
208	JobInfo info = getJobInfo(job);	213	JobInfo info = getJobInfo(job);
209	info.beginTask(taskName, totalWork);	214	info.beginTask(taskName, totalWork);
210	refreshJobInfo(info);	215	refreshJobInfo(info);
211	currentTaskName = taskName;	216	currentTaskName = taskName;
212	if (listener != null) {	217	if (listener != null) {
213	listener.beginTask(taskName, totalWork);	218	Display.getDefault().asyncExec(new Runnable() {
		219
		220	public void run() {
		221	listener.beginTask(taskName, totalWork);
		222	}
		223	});
		224
214	}	225	}
215	}	226	}
216		227
Lines 225-231 Link Here
225	info.clearChildren();	236	info.clearChildren();
226	runnableMonitors.remove(job);	237	runnableMonitors.remove(job);
227	if (listener != null) {	238	if (listener != null) {
228	listener.done();	239	runInUIThread(new Runnable() {
		240
		241	public void run() {
		242	listener.done();
		243	}
		244	});
229	}	245	}
230	}	246	}
231		247
Lines 234-247 Link Here
234	*	250	*
235	* @see org.eclipse.core.runtime.IProgressMonitor#internalWorked(double)	251	* @see org.eclipse.core.runtime.IProgressMonitor#internalWorked(double)
236	*/	252	*/
237	public void internalWorked(double work) {	253	public void internalWorked(final double work) {
238	JobInfo info = getJobInfo(job);	254	JobInfo info = getJobInfo(job);
239	if (info.hasTaskInfo()) {	255	if (info.hasTaskInfo()) {
240	info.addWork(work);	256	info.addWork(work);
241	refreshJobInfo(info);	257	refreshJobInfo(info);
242	}	258	}
243	if (listener != null) {	259	if (listener != null) {
244	listener.internalWorked(work);	260
		261	runInUIThread(new Runnable() {
		262
		263	public void run() {
		264	listener.internalWorked(work);
		265	}
		266	});
		267
245	}	268	}
246	}	269	}
247		270
Lines 333-340 Link Here
333	JobInfo info = getJobInfo(job);	356	JobInfo info = getJobInfo(job);
334	info.setBlockedStatus(null);	357	info.setBlockedStatus(null);
335	refreshJobInfo(info);	358	refreshJobInfo(info);
336	if (listener != null) {	359	if (listener instanceof IProgressMonitorWithBlocking) {
337	listener.clearBlocked();	360	((IProgressMonitorWithBlocking) listener).clearBlocked();
338	}	361	}
339	}	362	}
340		363
Lines 347-354 Link Here
347	JobInfo info = getJobInfo(job);	370	JobInfo info = getJobInfo(job);
348	info.setBlockedStatus(reason);	371	info.setBlockedStatus(reason);
349	refreshJobInfo(info);	372	refreshJobInfo(info);
350	if (listener != null) {	373	if (listener instanceof IProgressMonitorWithBlocking) {
351	listener.setBlocked(reason);	374	((IProgressMonitorWithBlocking) listener).setBlocked(reason);
352	}	375	}
353	}	376	}
354	}	377	}
Lines 641-647 Link Here
641	synchronized (runnableMonitors) {	664	synchronized (runnableMonitors) {
642	JobMonitor monitor = (JobMonitor) runnableMonitors.get(job);	665	JobMonitor monitor = (JobMonitor) runnableMonitors.get(job);
643	if (monitor == null) {	666	if (monitor == null) {
644	monitor = new JobMonitor(job);	667	monitor = (JobMonitor) jobMonitors.get(job);
		668	if (monitor == null) {
		669	monitor = new JobMonitor(job);
		670	}
645	runnableMonitors.put(job, monitor);	671	runnableMonitors.put(job, monitor);
646	}	672	}
647		673
Lines 1326-1331 Link Here
1326		1352
1327	}	1353	}
1328		1354
		1355	private void runInUIThread(Runnable runnable) {
		1356	Display display = Display.getDefault();
		1357	if (display.isDisposed())
		1358	return;
		1359	if (display.getThread() == Thread.currentThread()) {
		1360	runnable.run();
		1361	} else {
		1362	display.asyncExec(runnable);
		1363	}
		1364	}
		1365
1329	private class RunnableWithStatus implements Runnable {	1366	private class RunnableWithStatus implements Runnable {
1330		1367
1331	IStatus status = Status.OK_STATUS;	1368	IStatus status = Status.OK_STATUS;
Lines 1388-1391 Link Here
1388	}	1425	}
1389		1426
1390	}	1427	}
		1428
		1429	Map jobMonitors = new HashMap();
		1430
		1431	public void registerMonitorForJob(Job job, IProgressMonitor monitor) {
		1432	jobMonitors.put(job, monitor);
		1433	}
		1434
		1435	/*
		1436	* (non-Javadoc)
		1437	*
		1438	* @see
		1439	* org.eclipse.ui.progress.IProgressService#addProgressListenerForJob(org
		1440	* .eclipse.core.runtime.jobs.Job,
		1441	* org.eclipse.core.runtime.IProgressMonitor)
		1442	*/
		1443	public void addProgressMonitorForJob(Job job, IProgressMonitor monitor) {
		1444	progressFor(job).addProgressListener(monitor);
		1445	}
		1446
		1447	/*
		1448	* (non-Javadoc)
		1449	*
		1450	* @see
		1451	* org.eclipse.ui.progress.IProgressService#removeProgressListenerForJob
		1452	* (org.eclipse.core.runtime.jobs.Job,
		1453	* org.eclipse.core.runtime.IProgressMonitor)
		1454	*/
		1455	public void removeProgressMonitorForJob(Job job, IProgressMonitor monitor) {
		1456	// TODO
		1457	}
1391	}	1458	}

Lines 12-30 Link Here

(-)src/org/eclipse/ui/examples/jobs/views/DeferredContentProvider.java (-1 / +7 lines)
12		12
13	import org.eclipse.jface.viewers.AbstractTreeViewer;	13	import org.eclipse.jface.viewers.AbstractTreeViewer;
14	import org.eclipse.jface.viewers.Viewer;	14	import org.eclipse.jface.viewers.Viewer;
		15	import org.eclipse.ui.IWorkbenchPartSite;
15	import org.eclipse.ui.model.BaseWorkbenchContentProvider;	16	import org.eclipse.ui.model.BaseWorkbenchContentProvider;
16	import org.eclipse.ui.progress.DeferredTreeContentManager;	17	import org.eclipse.ui.progress.DeferredTreeContentManager;
17		18
18	public class DeferredContentProvider extends BaseWorkbenchContentProvider {	19	public class DeferredContentProvider extends BaseWorkbenchContentProvider {
19		20
20	private DeferredTreeContentManager manager;	21	private DeferredTreeContentManager manager;
		22	private final IWorkbenchPartSite site;
		23
		24	public DeferredContentProvider(IWorkbenchPartSite site) {
		25	this.site = site;
		26	}
21		27
22	/* (non-Javadoc)	28	/* (non-Javadoc)
23	* @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)	29	* @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
24	*/	30	*/
25	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {	31	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
26	if (viewer instanceof AbstractTreeViewer) {	32	if (viewer instanceof AbstractTreeViewer) {
27	manager = new DeferredTreeContentManager(this, (AbstractTreeViewer) viewer);	33	manager = new MyDeferredTreeContentManager((AbstractTreeViewer) viewer, site);
28	}	34	}
29	super.inputChanged(viewer, oldInput, newInput);	35	super.inputChanged(viewer, oldInput, newInput);
30	}	36	}

Added Link Here

(-)src/org/eclipse/ui/examples/jobs/views/MyDeferredTreeContentManager.java (+65 lines)
1	package org.eclipse.ui.examples.jobs.views;
2
3	import org.eclipse.core.runtime.IProgressMonitor;
4	import org.eclipse.core.runtime.NullProgressMonitor;
5	import org.eclipse.jface.viewers.AbstractTreeViewer;
6	import org.eclipse.swt.widgets.Display;
7	import org.eclipse.ui.IWorkbenchPartSite;
8	import org.eclipse.ui.progress.DeferredTreeContentManager;
9	import org.eclipse.ui.progress.PendingUpdateAdapter;
10
11	public class MyDeferredTreeContentManager extends DeferredTreeContentManager {
12
13	private final AbstractTreeViewer viewer;
14	private PendingUpdateAdapter updateAdapter;
15
16	public MyDeferredTreeContentManager(AbstractTreeViewer viewer, IWorkbenchPartSite site) {
17	super(viewer, site);
18	this.viewer = viewer;
19	}
20
21	int total;
22	int worked;
23
24	public IProgressMonitor getProgressMonitorForUpdateJob() {
25	return new MyProgressMonitor();
26	};
27
28	protected void updateStatus() {
29	Display.getDefault().syncExec(new Runnable() {
30
31	public void run() {
32	viewer.update(updateAdapter, new String[] {"label"});
33	}
34	});
35	}
36
37	protected PendingUpdateAdapter createPendingUpdateAdapter() {
38
39	updateAdapter = new PendingUpdateAdapter() {
40	public String getLabel(Object o) {
41	if(total <= 0)
42	return super.getLabel(o);
43	int percent = ((worked*100)/total);
44	return super.getLabel(o)+" ("+percent+"% done)";
45	};
46	};
47	return updateAdapter;
48	};
49
50
51	class MyProgressMonitor extends NullProgressMonitor{
52	@Override
53	public void internalWorked(double work) {
54	worked+=work;
55	updateStatus();
56	}
57
58	public void beginTask(String name, int totalWork) {
59	total = totalWork;
60	worked = 0;
61	updateStatus();
62	}
63	}
64
65	}

Lines 41-58 Link Here

(-)src/org/eclipse/ui/examples/jobs/views/SlowElementAdapter.java (-2 / +9 lines)
41	if (object instanceof SlowElement) {	41	if (object instanceof SlowElement) {
42	Object[] children = ((SlowElement) object).getChildren();	42	Object[] children = ((SlowElement) object).getChildren();
43	if (isBatchFetchedChildren()) {	43	if (isBatchFetchedChildren()) {
44	sleep(4000);	44	monitor.beginTask("updating children", 4);
		45	for(int i=0;i<4;i++) {
		46	sleep(1000);
		47	monitor.worked(1);
		48	}
45	collector.add(children, monitor);	49	collector.add(children, monitor);
46	} else {	50	} else {
		51	monitor.beginTask("updating children", children.length);
47	for (int i = 0; i < children.length; i++) {	52	for (int i = 0; i < children.length; i++) {
48	if (monitor.isCanceled()) {	53	if (monitor.isCanceled()) {
49	return;	54	return;
50	}	55	}
51	collector.add(children[i], monitor);	56	collector.add(children[i], monitor);
52	sleep(4000);	57	sleep(1000);
		58	monitor.worked(1);
53	}	59	}
54	}	60	}
55	}	61	}
		62	monitor.done();
56	}	63	}
57		64
58	private void sleep(long mills) {	65	private void sleep(long mills) {

Lines 11-17 Link Here

(-)Eclipse UI/org/eclipse/ui/progress/IProgressService.java (-1 / +15 lines)
11	package org.eclipse.ui.progress;	11	package org.eclipse.ui.progress;
12		12
13	import java.lang.reflect.InvocationTargetException;	13	import java.lang.reflect.InvocationTargetException;
14		14	import org.eclipse.core.runtime.IProgressMonitor;
15	import org.eclipse.core.runtime.jobs.IJobManager;	15	import org.eclipse.core.runtime.jobs.IJobManager;
16	import org.eclipse.core.runtime.jobs.ISchedulingRule;	16	import org.eclipse.core.runtime.jobs.ISchedulingRule;
17	import org.eclipse.core.runtime.jobs.Job;	17	import org.eclipse.core.runtime.jobs.Job;
Lines 161-164 Link Here
161	*/	161	*/
162	public void showInDialog(Shell shell, Job job);	162	public void showInDialog(Shell shell, Job job);
163		163
		164	/**
		165	* @param job
		166	* @param monitor
		167	* @since 3.6
		168	*/
		169	public void addProgressMonitorForJob(Job job, IProgressMonitor monitor);
		170
		171	/**
		172	* @param job
		173	* @param monitor
		174	* @since 3.6
		175	*/
		176	public void removeProgressMonitorForJob(Job job, IProgressMonitor monitor);
		177
164	}	178	}