Attachment #151032 for bug #293882

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

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




import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.SortedSet;
import java.util.TreeSet;

import org.eclipse.core.commands.common.EventManager;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.core.runtime.dynamichelpers.ExtensionTracker;
import org.eclipse.core.runtime.dynamichelpers.IExtensionChangeHandler;
import org.eclipse.core.runtime.dynamichelpers.IExtensionTracker;

import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;
import org.eclipse.ui.internal.registry.WorkingSetDescriptor;
import org.eclipse.ui.internal.registry.WorkingSetRegistry;
import org.eclipse.ui.progress.WorkbenchJob;
import org.eclipse.ui.statushandlers.StatusManager;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;

					((AbstractWorkingSet) o2).getUniqueId());
		}
	});

	class UpdateWorkingSetJob extends Job {
		private List names = new LinkedList();

		public UpdateWorkingSetJob() {
			super(
					NLS
							.bind(
									WorkbenchMessages.AbstractWorkingSetManager_updatersActivating,
									"")); //$NON-NLS-1$
			setSystem(true);
		}

		public void add(String name) {
			synchronized (names) {
				names.add(name);
			}
			schedule(100);
		}

		public String remove() {
			synchronized (names) {
				if (names.isEmpty())
					return null;
				return (String) names.remove(0);
			}
		}

		public int size() {
			synchronized (names) {
				return names.size();
			}
		}

		protected IStatus run(IProgressMonitor monitor) {
			SubMonitor mon = SubMonitor.convert(monitor);
			int sizeTracker = size();
			mon.beginTask("", sizeTracker); //$NON-NLS-1$
			String symbolicName = remove();
			while (symbolicName != null) {
				if (size() != sizeTracker) {
					sizeTracker = size();
					mon.setWorkRemaining(sizeTracker);
				}
				mon
						.subTask(NLS
								.bind(
										WorkbenchMessages.AbstractWorkingSetManager_updatersActivating,
										symbolicName));
				final WorkingSetDescriptor[] descriptors = WorkbenchPlugin
						.getDefault().getWorkingSetRegistry()
						.getUpdaterDescriptorsForNamespace(symbolicName);

				synchronized (updaters) {
					for (int i = 0; i < descriptors.length; i++) {
						WorkingSetDescriptor descriptor = descriptors[i];
						List workingSets = getWorkingSetsForId(descriptor
								.getId());
						if (workingSets.size() == 0) {
							continue;
						}
						final IWorkingSetUpdater updater = getUpdater(descriptor);
						for (Iterator iter = workingSets.iterator(); iter
								.hasNext();) {
							final IWorkingSet workingSet = (IWorkingSet) iter
									.next();
							SafeRunner.run(new WorkingSetRunnable() {

								public void run() throws Exception {
									if (!updater.contains(workingSet)) {
										updater.add(workingSet);
									}
								}
							});
						}
					}
				}
				sizeTracker--;
				mon.worked(1);
				symbolicName = remove();
			}
			monitor.done();
			return Status.OK_STATUS;
		}

	}
    /**
     * Size of the list of most recently used working sets.
     */

    private Map/*<String, IWorkingSetUpdater>*/ updaters= new HashMap();

	private Map/*<String, IWorkingSetElementAdapter>*/ elementAdapters = new HashMap();

	private UpdateWorkingSetJob updateWorkingSet = new UpdateWorkingSetJob();
    
    private static final IWorkingSetUpdater NULL_UPDATER= new IWorkingSetUpdater() {
		public void add(IWorkingSet workingSet) {

		}
		
		if (event.getBundle().getState() == Bundle.ACTIVE) {
			updateWorkingSet.add(symbolicName);
					.getWorkingSetRegistry().getUpdaterDescriptorsForNamespace(
							symbolicName);
			
			Job job = new WorkbenchJob(
					NLS
							.bind(
									WorkbenchMessages.AbstractWorkingSetManager_updatersActivating,
									symbolicName)) {

				public IStatus runInUIThread(IProgressMonitor monitor) {
					synchronized (updaters) {
						for (int i = 0; i < descriptors.length; i++) {
							WorkingSetDescriptor descriptor = descriptors[i];
							List workingSets = getWorkingSetsForId(descriptor
									.getId());
							if (workingSets.size() == 0) {
								continue;
							}
							final IWorkingSetUpdater updater = getUpdater(descriptor);
							for (Iterator iter = workingSets.iterator(); iter
									.hasNext();) {
								final IWorkingSet workingSet = (IWorkingSet) iter
										.next();
								SafeRunner.run(new WorkingSetRunnable() {

									public void run() throws Exception {
										if (!updater.contains(workingSet)) {
											updater.add(workingSet);
										}
									}
								});
							}
						}
					}
					return Status.OK_STATUS;
				}
			};
			job.setSystem(true);
			job.schedule();
		}
	}


Return to bug 293882

Lines 19-29 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/AbstractWorkingSetManager.java (-43 / +91 lines)
19	import java.util.Comparator;	19	import java.util.Comparator;
20	import java.util.HashMap;	20	import java.util.HashMap;
21	import java.util.Iterator;	21	import java.util.Iterator;
		22	import java.util.LinkedList;
22	import java.util.List;	23	import java.util.List;
23	import java.util.Map;	24	import java.util.Map;
24	import java.util.SortedSet;	25	import java.util.SortedSet;
25	import java.util.TreeSet;	26	import java.util.TreeSet;
26
27	import org.eclipse.core.commands.common.EventManager;	27	import org.eclipse.core.commands.common.EventManager;
28	import org.eclipse.core.runtime.Assert;	28	import org.eclipse.core.runtime.Assert;
29	import org.eclipse.core.runtime.IAdaptable;	29	import org.eclipse.core.runtime.IAdaptable;
Lines 35-40 Link Here
35	import org.eclipse.core.runtime.Platform;	35	import org.eclipse.core.runtime.Platform;
36	import org.eclipse.core.runtime.SafeRunner;	36	import org.eclipse.core.runtime.SafeRunner;
37	import org.eclipse.core.runtime.Status;	37	import org.eclipse.core.runtime.Status;
		38	import org.eclipse.core.runtime.SubMonitor;
38	import org.eclipse.core.runtime.dynamichelpers.ExtensionTracker;	39	import org.eclipse.core.runtime.dynamichelpers.ExtensionTracker;
39	import org.eclipse.core.runtime.dynamichelpers.IExtensionChangeHandler;	40	import org.eclipse.core.runtime.dynamichelpers.IExtensionChangeHandler;
40	import org.eclipse.core.runtime.dynamichelpers.IExtensionTracker;	41	import org.eclipse.core.runtime.dynamichelpers.IExtensionTracker;
Lines 64-70 Link Here
64	import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;	65	import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;
65	import org.eclipse.ui.internal.registry.WorkingSetDescriptor;	66	import org.eclipse.ui.internal.registry.WorkingSetDescriptor;
66	import org.eclipse.ui.internal.registry.WorkingSetRegistry;	67	import org.eclipse.ui.internal.registry.WorkingSetRegistry;
67	import org.eclipse.ui.progress.WorkbenchJob;
68	import org.eclipse.ui.statushandlers.StatusManager;	68	import org.eclipse.ui.statushandlers.StatusManager;
69	import org.osgi.framework.Bundle;	69	import org.osgi.framework.Bundle;
70	import org.osgi.framework.BundleContext;	70	import org.osgi.framework.BundleContext;
Lines 96-102 Link Here
96	((AbstractWorkingSet) o2).getUniqueId());	96	((AbstractWorkingSet) o2).getUniqueId());
97	}	97	}
98	});	98	});
99		99
		100	class UpdateWorkingSetJob extends Job {
		101	private List names = new LinkedList();
		102
		103	public UpdateWorkingSetJob() {
		104	super(
		105	NLS
		106	.bind(
		107	WorkbenchMessages.AbstractWorkingSetManager_updatersActivating,
		108	"")); //$NON-NLS-1$
		109	setSystem(true);
		110	}
		111
		112	public void add(String name) {
		113	synchronized (names) {
		114	names.add(name);
		115	}
		116	schedule(100);
		117	}
		118
		119	public String remove() {
		120	synchronized (names) {
		121	if (names.isEmpty())
		122	return null;
		123	return (String) names.remove(0);
		124	}
		125	}
		126
		127	public int size() {
		128	synchronized (names) {
		129	return names.size();
		130	}
		131	}
		132
		133	protected IStatus run(IProgressMonitor monitor) {
		134	SubMonitor mon = SubMonitor.convert(monitor);
		135	int sizeTracker = size();
		136	mon.beginTask("", sizeTracker); //$NON-NLS-1$
		137	String symbolicName = remove();
		138	while (symbolicName != null) {
		139	if (size() != sizeTracker) {
		140	sizeTracker = size();
		141	mon.setWorkRemaining(sizeTracker);
		142	}
		143	mon
		144	.subTask(NLS
		145	.bind(
		146	WorkbenchMessages.AbstractWorkingSetManager_updatersActivating,
		147	symbolicName));
		148	final WorkingSetDescriptor[] descriptors = WorkbenchPlugin
		149	.getDefault().getWorkingSetRegistry()
		150	.getUpdaterDescriptorsForNamespace(symbolicName);
		151
		152	synchronized (updaters) {
		153	for (int i = 0; i < descriptors.length; i++) {
		154	WorkingSetDescriptor descriptor = descriptors[i];
		155	List workingSets = getWorkingSetsForId(descriptor
		156	.getId());
		157	if (workingSets.size() == 0) {
		158	continue;
		159	}
		160	final IWorkingSetUpdater updater = getUpdater(descriptor);
		161	for (Iterator iter = workingSets.iterator(); iter
		162	.hasNext();) {
		163	final IWorkingSet workingSet = (IWorkingSet) iter
164	.next();
165	SafeRunner.run(new WorkingSetRunnable() {
166
167	public void run() throws Exception {
168	if (!updater.contains(workingSet)) {
169	updater.add(workingSet);
170	}
171	}
172	});
173	}
174	}
175	}
176	sizeTracker--;
177	mon.worked(1);
178	symbolicName = remove();
179	}
180	monitor.done();
181	return Status.OK_STATUS;
182	}
183
184	}
100	/**	185	/**
101	* Size of the list of most recently used working sets.	186	* Size of the list of most recently used working sets.
102	*/	187	*/
Lines 107-112 Link Here
107	private Map/<String, IWorkingSetUpdater>/ updaters= new HashMap();	192	private Map/<String, IWorkingSetUpdater>/ updaters= new HashMap();
108		193
109	private Map/<String, IWorkingSetElementAdapter>/ elementAdapters = new HashMap();	194	private Map/<String, IWorkingSetElementAdapter>/ elementAdapters = new HashMap();
		195
		196	private UpdateWorkingSetJob updateWorkingSet = new UpdateWorkingSetJob();
110		197
111	private static final IWorkingSetUpdater NULL_UPDATER= new IWorkingSetUpdater() {	198	private static final IWorkingSetUpdater NULL_UPDATER= new IWorkingSetUpdater() {
112	public void add(IWorkingSet workingSet) {	199	public void add(IWorkingSet workingSet) {
Lines 671-716 Link Here
671	}	758	}
672		759
673	if (event.getBundle().getState() == Bundle.ACTIVE) {	760	if (event.getBundle().getState() == Bundle.ACTIVE) {
674	final WorkingSetDescriptor[] descriptors = WorkbenchPlugin.getDefault()	761	updateWorkingSet.add(symbolicName);
675	.getWorkingSetRegistry().getUpdaterDescriptorsForNamespace(
676	symbolicName);
677
678	Job job = new WorkbenchJob(
679	NLS
680	.bind(
681	WorkbenchMessages.AbstractWorkingSetManager_updatersActivating,
682	symbolicName)) {
683
684	public IStatus runInUIThread(IProgressMonitor monitor) {
685	synchronized (updaters) {
686	for (int i = 0; i < descriptors.length; i++) {
687	WorkingSetDescriptor descriptor = descriptors[i];
688	List workingSets = getWorkingSetsForId(descriptor
689	.getId());
690	if (workingSets.size() == 0) {
691	continue;
692	}
693	final IWorkingSetUpdater updater = getUpdater(descriptor);
694	for (Iterator iter = workingSets.iterator(); iter
695	.hasNext();) {
696	final IWorkingSet workingSet = (IWorkingSet) iter
697	.next();
698	SafeRunner.run(new WorkingSetRunnable() {
699
700	public void run() throws Exception {
701	if (!updater.contains(workingSet)) {
702	updater.add(workingSet);
703	}
704	}
705	});
706	}
707	}
708	}
709	return Status.OK_STATUS;
710	}
711	};
712	job.setSystem(true);
713	job.schedule();
714	}	762	}
715	}	763	}
716		764