Attachment #259749 for bug #487400




		
		fClasspathViewer = new RuntimeClasspathViewer(comp);
		fClasspathViewer.addEntriesChangedListener(this);
		fClasspathViewer.getTreeViewer().getControl().setFont(font);
		fClasspathViewer.getTreeViewer().setLabelProvider(new ClasspathLabelProvider());
		fClasspathViewer.getTreeViewer().setContentProvider(new ClasspathContentProvider(this));
		if (!isShowBootpath()) {
			fClasspathViewer.getTreeViewer().addFilter(new BootpathFilter());
		}

		Composite pathButtonComp = new Composite(comp, SWT.NONE);
		GridLayout pathButtonLayout = new GridLayout();
		pathButtonLayout.marginHeight = 0;

	@Override
	public void initializeFrom(ILaunchConfiguration configuration) {
		refresh(configuration);
		fClasspathViewer.getTreeViewer().expandToLevel(2);
	}
	
	/* (non-Javadoc)

					return;
				}
			}
			fClasspathViewer.getTreeViewer().refresh();
		} catch (CoreException e) {
		}
	}

	 * @param configuration the configuration
	 */
	private void refresh(ILaunchConfiguration configuration) {
		boolean useDefault = true;
		setErrorMessage(null);

			useDefault = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_DEFAULT_CLASSPATH, true);
		} catch (CoreException e) {
			JDIDebugUIPlugin.log(e);
		}
		
		if (configuration == getLaunchConfiguration()) {
			// no need to update if an explicit path is being used and this setting
			// has not changed (and viewing the same config as last time)
			if (!useDefault) {
				setDirty(false);
				return;			
			}
		}
		
		setLaunchConfiguration(configuration);
		try {
			createClasspathModel(configuration);

		}
		
		fClasspathViewer.setLaunchConfiguration(configuration);
		fClasspathViewer.getTreeViewer().setInput(fModel);
		setDirty(false);
	}
	

Lines 15-20 Link Here

(-)a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/classpath/RuntimeClasspathViewer.java (-18 / +106 lines)
15	import java.util.Iterator;	15	import java.util.Iterator;
16	import java.util.List;	16	import java.util.List;
17		17
		18	import org.eclipse.core.runtime.IProgressMonitor;
		19	import org.eclipse.core.runtime.IStatus;
18	import org.eclipse.core.runtime.ListenerList;	20	import org.eclipse.core.runtime.ListenerList;
19	import org.eclipse.core.runtime.preferences.IEclipsePreferences;	21	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
20	import org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener;	22	import org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener;
Lines 27-34 Link Here
27	import org.eclipse.jdt.internal.debug.ui.launcher.IEntriesChangedListener;	29	import org.eclipse.jdt.internal.debug.ui.launcher.IEntriesChangedListener;
28	import org.eclipse.jdt.internal.launching.LaunchingPlugin;	30	import org.eclipse.jdt.internal.launching.LaunchingPlugin;
29	import org.eclipse.jdt.launching.IRuntimeClasspathEntry;	31	import org.eclipse.jdt.launching.IRuntimeClasspathEntry;
30	import org.eclipse.jface.dialogs.IDialogConstants;
31	import org.eclipse.jface.viewers.ISelection;	32	import org.eclipse.jface.viewers.ISelection;
		33	import org.eclipse.jface.viewers.ISelectionChangedListener;
32	import org.eclipse.jface.viewers.IStructuredSelection;	34	import org.eclipse.jface.viewers.IStructuredSelection;
33	import org.eclipse.jface.viewers.StructuredSelection;	35	import org.eclipse.jface.viewers.StructuredSelection;
34	import org.eclipse.jface.viewers.TreeViewer;	36	import org.eclipse.jface.viewers.TreeViewer;
Lines 37-50 Link Here
37	import org.eclipse.swt.events.DisposeListener;	39	import org.eclipse.swt.events.DisposeListener;
38	import org.eclipse.swt.events.KeyAdapter;	40	import org.eclipse.swt.events.KeyAdapter;
39	import org.eclipse.swt.events.KeyEvent;	41	import org.eclipse.swt.events.KeyEvent;
40	import org.eclipse.swt.layout.GridData;
41	import org.eclipse.swt.widgets.Composite;	42	import org.eclipse.swt.widgets.Composite;
42	import org.eclipse.swt.widgets.Shell;	43	import org.eclipse.swt.widgets.Shell;
		44	import org.eclipse.ui.dialogs.FilteredTree;
		45	import org.eclipse.ui.dialogs.PatternFilter;
		46	import org.eclipse.ui.progress.WorkbenchJob;
43		47
44	/**	48	/**
45	* A viewer that displays and manipulates runtime classpath entries.	49	* A viewer that displays and manipulates runtime classpath entries.
46	*/	50	*/
47	public class RuntimeClasspathViewer extends TreeViewer implements IClasspathViewer {	51	public class RuntimeClasspathViewer implements IClasspathViewer {
48		52
49	/**	53	/**
50	* Entry changed listeners	54	* Entry changed listeners
Lines 70-100 Link Here
70		74
71	}	75	}
72	};	76	};
		77
		78	private static class RuntimeClasspathFilteredTree extends FilteredTree {
		79
		80	private boolean isFiltering;
		81
		82	private RuntimeClasspathFilteredTree(Composite parent, PatternFilter filter) {
		83	super(parent, 0, filter, true);
		84	}
		85
		86	private boolean hasFilterTextEntered() {
		87	return isFiltering;
		88	}
		89
		90	/**
		91	* Called by modify listener -> implicit change listener.
		92	*/
		93	@Override
		94	protected void textChanged() {
		95
		96	super.textChanged();
		97
		98	final String filterString = getFilterString();
		99	if (null != filterString) {
		100	// REVIEW: There are several different ways used to check for empty filter texts:
		101	// comparing with "", comparing with IInternalDebugCoreConstants.EMPTY_STRING and checking size of trimmed value.
		102	isFiltering = !filterString.trim().isEmpty();
		103	} else {
		104	isFiltering = false;
		105	}
		106	}
		107
		108	@Override
		109	protected WorkbenchJob doCreateRefreshJob() {
		110	final WorkbenchJob job = super.doCreateRefreshJob();
		111
		112	return new WorkbenchJob("Classpath filter refresh") { //$NON-NLS-1$
		113
		114	@Override
		115	public IStatus runInUIThread(IProgressMonitor monitor) {
		116	final IStatus status = job.runInUIThread(monitor);
		117
		118	if (!isFiltering) {
		119	getViewer().expandToLevel(2);
		120	}
		121
		122	return status;
		123	}
		124	};
		125	}
		126	}
		127
		128	private final RuntimeClasspathFilteredTree fTree;
73		129
		130	public TreeViewer getTreeViewer() {
		131	return fTree.getViewer();
		132	}
		133
74	/**	134	/**
75	* Creates a runtime classpath viewer with the given parent.	135	* Creates a runtime classpath viewer with the given parent.
76	*	136	*
77	* @param parent the parent control	137	* @param parent the parent control
78	*/	138	*/
79	public RuntimeClasspathViewer(Composite parent) {	139	public RuntimeClasspathViewer(Composite parent) {
80	super(parent);
81		140
82	GridData data = new GridData(GridData.FILL_BOTH);	141	final PatternFilter filter = new PatternFilter();
83	data.widthHint = IDialogConstants.ENTRY_FIELD_WIDTH;	142	filter.setIncludeLeadingWildcard(true);
84	data.heightHint = getTree().getItemHeight();	143	fTree = new RuntimeClasspathFilteredTree(parent, filter);
85	getTree().setLayoutData(data);
86		144
87	getTree().addKeyListener(new KeyAdapter() {	145	getTreeViewer().getTree().addKeyListener(new KeyAdapter() {
88	@Override	146	@Override
89	public void keyPressed(KeyEvent event) {	147	public void keyPressed(KeyEvent event) {
90	if (updateSelection(RuntimeClasspathAction.REMOVE, (IStructuredSelection)getSelection()) && event.character == SWT.DEL && event.stateMask == 0) {	148	if (updateSelection(RuntimeClasspathAction.REMOVE, (IStructuredSelection) getSelection()) && event.character == SWT.DEL
91	List<?> selection= getSelectionFromWidget();	149	&& event.stateMask == 0) {
92	getClasspathContentProvider().removeAll(selection);	150	getClasspathContentProvider().removeAll(((IStructuredSelection) getSelectedEntries()).toList());
93	notifyChanged();	151	notifyChanged();
94	}	152	}
95	}	153	}
96	});	154	});
97	getTree().addDisposeListener(new DisposeListener() {	155
		156	fTree.addDisposeListener(new DisposeListener() {
98	@Override	157	@Override
99	public void widgetDisposed(DisposeEvent e) {	158	public void widgetDisposed(DisposeEvent e) {
100	IEclipsePreferences prefs = InstanceScope.INSTANCE.getNode(LaunchingPlugin.ID_PLUGIN);	159	IEclipsePreferences prefs = InstanceScope.INSTANCE.getNode(LaunchingPlugin.ID_PLUGIN);
Lines 190-197 Link Here
190	* @param configuration the backing {@link ILaunchConfiguration}	249	* @param configuration the backing {@link ILaunchConfiguration}
191	*/	250	*/
192	public void setLaunchConfiguration(ILaunchConfiguration configuration) {	251	public void setLaunchConfiguration(ILaunchConfiguration configuration) {
193	if (getLabelProvider() != null) {	252	if (getTreeViewer().getLabelProvider() != null) {
194	((ClasspathLabelProvider)getLabelProvider()).setLaunchConfiguration(configuration);	253	((ClasspathLabelProvider) getTreeViewer().getLabelProvider()).setLaunchConfiguration(configuration);
195	}	254	}
196	}	255	}
197		256
Lines 242-252 Link Here
242	*/	301	*/
243	@Override	302	@Override
244	public Shell getShell() {	303	public Shell getShell() {
245	return getControl().getShell();	304	return getTreeViewer().getControl().getShell();
246	}	305	}
247		306
248	private ClasspathContentProvider getClasspathContentProvider() {	307	private ClasspathContentProvider getClasspathContentProvider() {
249	return (ClasspathContentProvider)super.getContentProvider();	308	return (ClasspathContentProvider) getTreeViewer().getContentProvider();
250	}	309	}
251		310
252	/* (non-Javadoc)	311	/* (non-Javadoc)
Lines 268-275 Link Here
268	}	327	}
269	}	328	}
270	return selection.size() > 0;	329	return selection.size() > 0;
		330	case RuntimeClasspathAction.MOVE:
		331	if (fTree.hasFilterTextEntered()) {
		332	return false;
		333	}
271	case RuntimeClasspathAction.REMOVE :	334	case RuntimeClasspathAction.REMOVE :
272	case RuntimeClasspathAction.MOVE :
273	selected= selection.iterator();	335	selected= selection.iterator();
274	while (selected.hasNext()) {	336	while (selected.hasNext()) {
275	IClasspathEntry entry = selected.next();	337	IClasspathEntry entry = selected.next();
Lines 303-306 Link Here
303		365
304	return new StructuredSelection(entries);	366	return new StructuredSelection(entries);
305	}	367	}
		368
		369	@Override
		370	public void addSelectionChangedListener(ISelectionChangedListener listener) {
		371	getTreeViewer().addSelectionChangedListener(listener);
		372	}
		373
		374	@Override
		375	public ISelection getSelection() {
		376	return getTreeViewer().getSelection();
		377	}
		378
		379	@Override
		380	public void removeSelectionChangedListener(ISelectionChangedListener listener) {
		381	getTreeViewer().removeSelectionChangedListener(listener);
		382	}
		383
		384	@Override
		385	public void setSelection(ISelection selection) {
		386	getTreeViewer().setSelection(selection);
		387	}
		388
		389	@Override
		390	public void refresh(Object entry) {
		391	getTreeViewer().refresh();
		392	}
		393
306	}	394	}

Return to bug 487400

Lines 121-133 Link Here

(-)a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/debug/ui/launchConfigurations/JavaClasspathTab.java (-24 / +9 lines)
121		121
122	fClasspathViewer = new RuntimeClasspathViewer(comp);	122	fClasspathViewer = new RuntimeClasspathViewer(comp);
123	fClasspathViewer.addEntriesChangedListener(this);	123	fClasspathViewer.addEntriesChangedListener(this);
124	fClasspathViewer.getControl().setFont(font);	124	fClasspathViewer.getTreeViewer().getControl().setFont(font);
125	fClasspathViewer.setLabelProvider(new ClasspathLabelProvider());	125	fClasspathViewer.getTreeViewer().setLabelProvider(new ClasspathLabelProvider());
126	fClasspathViewer.setContentProvider(new ClasspathContentProvider(this));	126	fClasspathViewer.getTreeViewer().setContentProvider(new ClasspathContentProvider(this));
127	if (!isShowBootpath()) {	127	if (!isShowBootpath()) {
128	fClasspathViewer.addFilter(new BootpathFilter());	128	fClasspathViewer.getTreeViewer().addFilter(new BootpathFilter());
129	}	129	}
130		130
131	Composite pathButtonComp = new Composite(comp, SWT.NONE);	131	Composite pathButtonComp = new Composite(comp, SWT.NONE);
132	GridLayout pathButtonLayout = new GridLayout();	132	GridLayout pathButtonLayout = new GridLayout();
133	pathButtonLayout.marginHeight = 0;	133	pathButtonLayout.marginHeight = 0;
Lines 208-214 Link Here
208	@Override	208	@Override
209	public void initializeFrom(ILaunchConfiguration configuration) {	209	public void initializeFrom(ILaunchConfiguration configuration) {
210	refresh(configuration);	210	refresh(configuration);
211	fClasspathViewer.expandToLevel(2);	211	fClasspathViewer.getTreeViewer().expandToLevel(2);
212	}	212	}
213		213
214	/* (non-Javadoc)	214	/* (non-Javadoc)
Lines 224-230 Link Here
224	return;	224	return;
225	}	225	}
226	}	226	}
227	fClasspathViewer.refresh();	227	fClasspathViewer.getTreeViewer().refresh();
228	} catch (CoreException e) {	228	} catch (CoreException e) {
229	}	229	}
230	}	230	}
Lines 235-257 Link Here
235	* @param configuration the configuration	235	* @param configuration the configuration
236	*/	236	*/
237	private void refresh(ILaunchConfiguration configuration) {	237	private void refresh(ILaunchConfiguration configuration) {
238	boolean useDefault = true;
239	setErrorMessage(null);	238	setErrorMessage(null);
240	try {	239
241	useDefault = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_DEFAULT_CLASSPATH, true);
242	} catch (CoreException e) {
243	JDIDebugUIPlugin.log(e);
244	}
245
246	if (configuration == getLaunchConfiguration()) {
247	// no need to update if an explicit path is being used and this setting
248	// has not changed (and viewing the same config as last time)
249	if (!useDefault) {
250	setDirty(false);
251	return;
252	}
253	}
254
255	setLaunchConfiguration(configuration);	240	setLaunchConfiguration(configuration);
256	try {	241	try {
257	createClasspathModel(configuration);	242	createClasspathModel(configuration);
Lines 260-266 Link Here
260	}	245	}
261		246
262	fClasspathViewer.setLaunchConfiguration(configuration);	247	fClasspathViewer.setLaunchConfiguration(configuration);
263	fClasspathViewer.setInput(fModel);	248	fClasspathViewer.getTreeViewer().setInput(fModel);
264	setDirty(false);	249	setDirty(false);
265	}	250	}
266		251