Attachment 79536 Details for Bug 205158 – The class implementing the DeferredTableContentManager

The class implementing the DeferredTableContentManager

DeferredTableContentManager.java (text/plain), 10.39 KB, created by Fabio Mancinelli

on 2007-10-02 05:17:58 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Fabio Mancinelli

Created: 2007-10-02 05:17:58 EDT

Size: 10.39 KB

patch

obsolete

>package org.eclipse.jface.fm;
>
>import org.eclipse.core.runtime.Assert;
>import org.eclipse.core.runtime.IAdaptable;
>import org.eclipse.core.runtime.IProgressMonitor;
>import org.eclipse.core.runtime.IStatus;
>import org.eclipse.core.runtime.Platform;
>import org.eclipse.core.runtime.PlatformObject;
>import org.eclipse.core.runtime.Status;
>import org.eclipse.core.runtime.jobs.IJobChangeEvent;
>import org.eclipse.core.runtime.jobs.Job;
>import org.eclipse.core.runtime.jobs.JobChangeAdapter;
>import org.eclipse.jface.resource.ImageDescriptor;
>import org.eclipse.jface.viewers.AbstractTableViewer;
>import org.eclipse.swt.widgets.Control;
>import org.eclipse.ui.IWorkbenchPartSite;
>import org.eclipse.ui.PlatformUI;
>import org.eclipse.ui.model.IWorkbenchAdapter;
>import org.eclipse.ui.progress.IDeferredWorkbenchAdapter;
>import org.eclipse.ui.progress.IElementCollector;
>import org.eclipse.ui.progress.IWorkbenchSiteProgressService;
>import org.eclipse.ui.progress.WorkbenchJob;
>
>/**
> * The DeferredTableContentManager is a class that helps an IStructuredContentProvider get
> * its deferred input for a table viewer.
> * 
> * This is basically a patch of {@DeferredTreeContentManager} that is used to fetch elements instead o children.
> * 
> * @author Fabio Mancinelli &lt;fm@fabiomancinelli.org&gt;, &lt;fabio.mancinelli@xwiki.com&gt;
> * @see DeferredTreeContentManager
> * @since 3.0
> */
>public class DeferredTableContentManager {
>	IDeferredStructuredContentProvider contentProvider;
>	AbstractTableViewer tableViewer;
>	IWorkbenchSiteProgressService progressService;
>
>	/**
>	 * The DeferredContentFamily is a class used to keep track of a
>	 * manager-object pair so that only jobs scheduled by the receiver are
>	 * cancelled by the receiver.
>	 * 
>	 * @since 3.1
>	 * 
>	 */
>	class DeferredContentFamily {
>		protected DeferredTableContentManager manager;
>
>		/**
>		 * Create a new instance of the receiver to define a family for object
>		 * in a particular scheduling manager.
>		 * 
>		 * @param schedulingManager
>		 * @param object
>		 */
>		DeferredContentFamily(DeferredTableContentManager schedulingManager) {
>			this.manager = schedulingManager;
>		}
>	}
>
>	/**
>	 * Create a new instance of the receiver using the supplied content provider
>	 * and viewer. Run any jobs using the site.
>	 * 
>	 * @param provider
>	 * @param viewer
>	 * @param site
>	 */
>	public DeferredTableContentManager(IDeferredStructuredContentProvider provider, AbstractTableViewer viewer,
>			IWorkbenchPartSite site) {
>		this(provider, viewer);
>		Object siteService = getAdapter(site, IWorkbenchSiteProgressService.class);
>		if(siteService != null) {
>			progressService = (IWorkbenchSiteProgressService)siteService;
>		}
>	}
>
>	/**
>	 * Create a new instance of the receiver using the supplied content provider
>	 * and viewer.
>	 * 
>	 * @param provider
>	 *            The content provider that will be updated
>	 * @param viewer
>	 *            The tree viewer that the results are added to
>	 */
>	public DeferredTableContentManager(IDeferredStructuredContentProvider provider, AbstractTableViewer viewer) {
>		contentProvider = provider;
>		tableViewer = viewer;
>	}
>	
>	/**
>	 * Returns the elements of the given input element, or in the case of a
>	 * deferred element, returns a placeholder. If a deferred element is used, a
>	 * job is created to fetch the children in the background.
>	 * 
>	 * @param inputElement
>	 *            The input element.
>	 * @return Object[] or <code>null</code> if parent is not an instance of
>	 *         IDeferredWorkbenchAdapter.
>	 */
>	public Object[] getElements(final Object inputElement) {		
>		if(inputElement == null) {
>			return null;
>		}
>		PendingUpdateAdapter placeholder = createPendingUpdateAdapter();
>		startFetchingDeferredElements(inputElement, placeholder);
>		return new Object[] { placeholder };
>	}
>
>	/**
>	 * Factory method for creating the pending update adapter representing the
>	 * placeholder node. Subclasses may override.
>	 * 
>	 * @return a pending update adapter
>	 * @since 3.2
>	 */
>	protected PendingUpdateAdapter createPendingUpdateAdapter() {
>		return new PendingUpdateAdapter();
>	}
>
>	/**
>	 * Return the IDeferredWorkbenchAdapter for element or the element if it is
>	 * an instance of IDeferredWorkbenchAdapter. If it does not exist return
>	 * null.
>	 * 
>	 * @param element
>	 * @return IDeferredWorkbenchAdapter or <code>null</code>
>	 */
>	protected IDeferredStructuredContentProvider getAdapter(Object element) {
>		return (IDeferredStructuredContentProvider)getAdapter(element, IDeferredStructuredContentProvider.class);
>	}
>
>	public Object getAdapter(Object sourceObject, Class adapterType) {
>		Assert.isNotNull(adapterType);
>		if(sourceObject == null) {
>			return null;
>		}
>		if(adapterType.isInstance(sourceObject)) {
>			return sourceObject;
>		}
>
>		if(sourceObject instanceof IAdaptable) {
>			IAdaptable adaptable = (IAdaptable)sourceObject;
>
>			Object result = adaptable.getAdapter(adapterType);
>			if(result != null) {
>				// Sanity-check
>				Assert.isTrue(adapterType.isInstance(result));
>				return result;
>			}
>		}
>
>		if(!(sourceObject instanceof PlatformObject)) {
>			Object result = Platform.getAdapterManager().getAdapter(sourceObject, adapterType);
>			if(result != null) {
>				return result;
>			}
>		}
>
>		return null;
>	}
>
>	/**
>	 * Starts a job and creates a collector for fetching the elements of this
>	 * deferred content provider. If children are waiting to be retrieved for this parent
>	 * already, that job is cancelled and another is started.
>	 * 
>	 * @param inputElement
>	 *            The parent object being filled in,
>	 * @param contentProvider
>	 *            The content provider being used to fetch the elements.
>	 * @param placeholder
>	 *            The adapter that will be used to indicate that results are
>	 *            pending.
>	 */
>	protected void startFetchingDeferredElements(final Object inputElement,
>			final PendingUpdateAdapter placeholder) {
>		final IElementCollector collector = createElementCollector(placeholder);
>		
>		Platform.getJobManager().cancel(new DeferredContentFamily(this));
>		String jobName = getFetchJobName(inputElement, contentProvider);
>		Job job = new Job(jobName) {
>			/*
>			 * (non-Javadoc)
>			 * 
>			 * @see org.eclipse.core.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
>			 */
>			public IStatus run(IProgressMonitor monitor) {
>				contentProvider.fetchDeferredElements(inputElement, collector, monitor);
>				if(monitor.isCanceled()) {
>					return Status.CANCEL_STATUS;
>				}
>				return Status.OK_STATUS;
>			}
>
>			/*
>			 * (non-Javadoc)
>			 * 
>			 * @see org.eclipse.core.jobs.Job#belongsTo(java.lang.Object)
>			 */
>			public boolean belongsTo(Object family) {												
>				if(family instanceof DeferredContentFamily) {
>					DeferredContentFamily contentFamily = (DeferredContentFamily)family;
>					return contentFamily.manager == DeferredTableContentManager.this;
>				}
>
>				return false;
>			}
>		};
>		job.addJobChangeListener(new JobChangeAdapter() {
>			/*
>			 * (non-Javadoc)
>			 * 
>			 * @see org.eclipse.core.runtime.jobs.JobChangeAdapter#done(org.eclipse.core.runtime.jobs.IJobChangeEvent)
>			 */
>			public void done(IJobChangeEvent event) {
>				runClearPlaceholderJob(placeholder);
>			}
>		});
>		job.setRule(contentProvider.getRule(inputElement));
>		if(progressService == null) {
>			job.schedule();
>		} else {
>			progressService.schedule(job);
>		}
>	}
>
>	/**
>	 * Returns a name to use for the job that fetches children of the given
>	 * parent. Subclasses may override. Default job name is parent's label.
>	 * 
>	 * @param parent
>	 *            parent that children are to be fetched for
>	 * @param adapter
>	 *            parent's deferred adapter
>	 * @return job name
>	 */
>	protected String getFetchJobName(Object parent, IDeferredStructuredContentProvider adapter) {
>		return "Fetching elements";
>	}
>
>	/**
>	 * Create a UIJob to add the elements to the table viewer.
>	 * 
>	 * @param elements
>	 * @param monitor
>	 */
>	protected void addElements(final Object[] elements, IProgressMonitor monitor) {
>		WorkbenchJob updateJob = new WorkbenchJob("Fetching elements") {
>			/*
>			 * (non-Javadoc)
>			 * 
>			 * @see org.eclipse.ui.progress.UIJob#runInUIThread(org.eclipse.core.runtime.IProgressMonitor)
>			 */
>			public IStatus runInUIThread(IProgressMonitor updateMonitor) {
>				// Cancel the job if the tree viewer got closed
>				if(tableViewer.getControl().isDisposed() || updateMonitor.isCanceled()) {
>					return Status.CANCEL_STATUS;
>				}
>				tableViewer.add(elements);
>				return Status.OK_STATUS;
>			}
>		};
>		updateJob.setSystem(true);
>		updateJob.schedule();
>
>	}
>
>	/**
>	 * Run a job to clear the placeholder. This is used when the update for the
>	 * table is complete so that the user is aware that no more updates are
>	 * pending.
>	 * 
>	 * @param placeholder
>	 */
>	protected void runClearPlaceholderJob(final PendingUpdateAdapter placeholder) {
>		if(placeholder.isRemoved() || !PlatformUI.isWorkbenchRunning()) {
>			return;
>		}
>		// Clear the placeholder if it is still there
>		WorkbenchJob clearJob = new WorkbenchJob("Clearing placeholder") {
>			/*
>			 * (non-Javadoc)
>			 * 
>			 * @see org.eclipse.ui.progress.UIJob#runInUIThread(org.eclipse.core.runtime.IProgressMonitor)
>			 */
>			public IStatus runInUIThread(IProgressMonitor monitor) {
>				if(!placeholder.isRemoved()) {
>					Control control = tableViewer.getControl();
>					if(control.isDisposed()) {
>						return Status.CANCEL_STATUS;
>					}
>					tableViewer.remove(placeholder);
>					placeholder.setRemoved(true);
>				}
>				return Status.OK_STATUS;
>			}
>		};
>		clearJob.setSystem(true);
>		clearJob.schedule();
>	}
>	
>	/**
>	 * Create the element collector for the receiver.
>	 * 
>	 * @param placeholder
>	 *            The adapter that will be used to indicate that results are
>	 *            pending.
>	 * @return IElementCollector
>	 */
>	protected IElementCollector createElementCollector(final PendingUpdateAdapter placeholder) {
>		return new IElementCollector() {
>			/*
>			 * (non-Javadoc)
>			 * 
>			 * @see org.eclipse.jface.progress.IElementCollector#add(java.lang.Object,
>			 *      org.eclipse.core.runtime.IProgressMonitor)
>			 */
>			public void add(Object element, IProgressMonitor monitor) {
>				add(new Object[] { element }, monitor);
>			}
>
>			/*
>			 * (non-Javadoc)
>			 * 
>			 * @see org.eclipse.jface.progress.IElementCollector#add(java.lang.Object[],
>			 *      org.eclipse.core.runtime.IProgressMonitor)
>			 */
>			public void add(Object[] elements, IProgressMonitor monitor) {
>				addElements(elements, monitor);
>			}
>
>			/*
>			 * (non-Javadoc)
>			 * 
>			 * @see org.eclipse.jface.progress.IElementCollector#done()
>			 */
>			public void done() {
>				runClearPlaceholderJob(placeholder);
>			}
>		};
>	}
>}

Actions: View

Attachments on bug 205158: 79536 | 79537 | 79684