Attachment #27979 for bug #102081

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




import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.IFontProvider;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;

    private static final String STORE_SELECTED_VIEW_ID = DIALOG_SETTING_SECTION_NAME
            + ".STORE_SELECTED_VIEW_ID"; //$NON-NLS-1$    

    private FilteredTree filteredTree;

    private Button okButton;



    private IViewRegistry viewReg;

    private class ViewBoldLabelProvider extends ViewLabelProvider implements IFontProvider {
    	private FilteredTree filterTree;

    	ViewBoldLabelProvider(FilteredTree filterTree) {
    		this.filterTree = filterTree;
    	}
    	/**
    	 * Using "false" to construct the filter so that this filter can filter
    	 * supernodes of a matching node
    	 */
    	PatternItemFilter filterForBoldElements = new ViewPatternFilter(false);

    	public Font getFont(Object element) {
    		return FilteredTree.getElementFont(element, filterTree, filterForBoldElements);
    	}
    }
    /**
     * Constructs a new ShowViewDialog.
     * 

        Composite composite = (Composite) super.createDialogArea(parent);
        composite.setFont(parent.getFont());

        createFilteredTreeViewer(composite);

        layoutTopControl(filteredTree.getViewer().getControl());

        // Restore the last state
        restoreWidgetValues();

    }

    /**
     * Create a new filtered tree viewer in the parent.
     * 
     * @param parent the parent <code>Composite</code>.
     */
    private void createFilteredTreeViewer(Composite parent) {
    	PatternItemFilter filter = new ViewPatternFilter(true); 
    	int styleBits = SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER;
		filteredTree = new FilteredTree(parent, styleBits, filter);
		TreeViewer treeViewer = filteredTree.getViewer();
		treeViewer.setLabelProvider(new ViewBoldLabelProvider(filteredTree));
		treeViewer.setContentProvider(new ViewContentProvider());
		treeViewer.setSorter(new ViewSorter((ViewRegistry) viewReg));
		treeViewer.setInput(viewReg);
		treeViewer.addSelectionChangedListener(this);
		treeViewer.addDoubleClickListener(this);
		treeViewer.addFilter(new CapabilityFilter());
		
		filteredTree.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
		filteredTree.setInitialText(WorkbenchMessages.WorkbenchPreferenceDialog_FilterMessage);

		//if the tree has only one or zero views, make the combo area disable
		if(hasAtMostOneView(filteredTree.getViewer())){
			filteredTree.getFilterControl().setEnabled(false);
		}
		
		applyDialogFont(filteredTree);
    }

	/**
	 * Return whether or not there are less than two views in the list.
	 * @param tree
	 * @return <code>true</code> if there are less than two
	 * views in the list.
	 */
	private boolean hasAtMostOneView(TreeViewer tree){
		ITreeContentProvider contentProvider = (ITreeContentProvider ) tree.getContentProvider();
		Object[] children= contentProvider.getElements(tree.getInput());
		
		if(children.length <= 1){
			if(children.length == 0)
				return true;
			return !contentProvider.hasChildren(children[0]);				
		}
		return false;
	}

    /*
     * (non-Javadoc)

    public void doubleClick(DoubleClickEvent event) {
        IStructuredSelection s = (IStructuredSelection) event.getSelection();
        Object element = s.getFirstElement();
        if (filteredTree.getViewer().isExpandable(element)) {
            filteredTree.getViewer().setExpandedState(element, !filteredTree.getViewer().getExpandedState(element));
        } else if (viewDescs.length > 0) {
            saveWidgetValues();
            setReturnCode(OK);

        }

        if (!categoriesToExpand.isEmpty())
            filteredTree.getViewer().setExpandedElements(categoriesToExpand.toArray());
        
        String selectedViewId = settings.get(STORE_SELECTED_VIEW_ID);
        if (selectedViewId != null) {
            IViewDescriptor viewDesc = reg.find(selectedViewId);
            if (viewDesc != null) {
                filteredTree.getViewer().setSelection(new StructuredSelection(viewDesc), true);
            }
        }
    }

        IDialogSettings settings = getDialogSettings();

        // Collect the ids of the all expanded categories
        Object[] expandedElements = filteredTree.getViewer().getExpandedElements();
        String[] expandedCategoryIds = new String[expandedElements.length];
        for (int i = 0; i < expandedElements.length; ++i)
            expandedCategoryIds[i] = ((IViewCategory) expandedElements[i]).getId();




package org.eclipse.ui.internal.dialogs;

import java.text.BreakIterator;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.jface.preference.IPreferenceNode;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.internal.preferences.WorkbenchPreferenceExtensionNode;

/**
 * Abstract class that handles filtering items based on a supplied
 * matching string.
 * 
 * @since 3.1
 * 
 */
public abstract class PatternItemFilter extends PatternFilter {

	/**
	 * this cache is needed because
	 * WorkbenchPreferenceExtensionNode.getKeywordLabels() is expensive. When it
	 * tracks keyword changes effectivly than this cache can be removed.
	 */
	private Map keywordCache = new HashMap();

	protected boolean matchItem;

	/**

		super();
		matchItem = isMatchItem;
	}
	
	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
	 *      java.lang.Object, java.lang.Object)
	 */
	public boolean select(Viewer viewer, Object parentElement, Object element) {

		ITreeContentProvider contentProvider = (ITreeContentProvider) ((TreeViewer) viewer)
				.getContentProvider();

		IPreferenceNode node = (IPreferenceNode) element;
		Object[] children = contentProvider.getChildren(node);
		String text = node.getLabelText();

		if(wordMatches(text))
			return true;
		
		if (matchItem) {

			// Will return true if any subnode of the element matches the search
			if (filter(viewer, element, children).length > 0)
				return true;
		}

		if (node instanceof WorkbenchPreferenceExtensionNode) {
			WorkbenchPreferenceExtensionNode workbenchNode = (WorkbenchPreferenceExtensionNode) node;

			Collection keywordCollection = (Collection) keywordCache.get(node);
			if (keywordCollection == null) {
				keywordCollection = workbenchNode.getKeywordLabels();
				keywordCache.put(node, keywordCollection);
			}
			if (keywordCollection.isEmpty())
				return false;
			Iterator keywords = keywordCollection.iterator();
			while (keywords.hasNext()) {
				if (wordMatches((String) keywords.next()))
					return true;
			}
		}
		return false;

	}

	/**
	 * Return whether or not if any of the words in text satisfy the
	 * match critera.

	 * @return boolean <code>true</code> if one of the words in text 
	 * satisifes the match criteria.
	 */
	protected boolean wordMatches(String text) {
		
		//If the whole text matches we are all set
		if(match(text))




import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;

 */
public abstract class FilteredPreferenceDialog extends PreferenceDialog implements IWorkbenchPreferenceContainer{

	protected FilteredTree filteredTree;

	private Object pageData;
	

	 * @see org.eclipse.jface.preference.PreferenceDialog#createTreeViewer(org.eclipse.swt.widgets.Composite)
	 */
	protected TreeViewer createTreeViewer(Composite parent) {
		PatternFilter filter = new PreferencePatternFilter(true); 
		int styleBits = SWT.SINGLE | SWT.H_SCROLL;
		filteredTree = new FilteredTree(parent, styleBits, filter);
		GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true);
		gd.horizontalIndent = IDialogConstants.HORIZONTAL_MARGIN;
		filteredTree.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));

		
		//if the tree has only one or zero pages, make the combo area disable
		if(hasAtMostOnePage(tree)){
			filteredTree.getFilterControl().setEnabled(false);
		}		
		}
		
		
		tree.addFilter(new CapabilityFilter());





     * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
     */
    public boolean select(Viewer viewer, Object parentElement, Object element) {
        return isElementMatch(viewer, element);
                .getContentProvider()).getChildren(element);
        if ((children != null) && (children.length > 0))
            return filter(viewer, element, children).length > 0;

        String labelText = ((ILabelProvider) ((StructuredViewer) viewer)
                .getLabelProvider()).getText(element);
        if(labelText == null)
        	return false;
        return match(labelText);
    }
    
    /**

    protected boolean match(String string) {
        return matcher.match(string);
    }
    
    /**
     * Answers whether the given Object should be selected in 
     * the filtered control.
     * 
     * @param element
     * @return true if this element should be auto selected
     */
    protected boolean isElementSelectable(Object element){
    	return element != null;
    }
    
    /**
     * Answers whether the given element in the given viewer matches
     * the filter pattern. 
     * 
     * @param viewer
     * @param element
     * @return true if the element matches the filter pattern
     */
    protected boolean isElementMatch(Viewer viewer, Object element){
        Object[] children = ((ITreeContentProvider) ((AbstractTreeViewer) viewer)
                .getContentProvider()).getChildren(element);
        if ((children != null) && (children.length > 0))
            return filter(viewer, element, children).length > 0;

        String labelText = ((ILabelProvider) ((StructuredViewer) viewer)
                .getLabelProvider()).getText(element);
        if(labelText == null)
        	return false;
        return match(labelText);   	
    }
}




package org.eclipse.ui.internal.dialogs;

import org.eclipse.jface.preference.PreferenceLabelProvider;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.viewers.IFontProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.swt.graphics.Font;

/**

		implements IFontProvider {

	
	private FilteredTree filterTree;

	PreferenceBoldLabelProvider(FilteredTree filterTree) {
		this.filterTree = filterTree;
	}
	/**
	 * Using "false" to construct the filter so that this filter can filter
	 * supernodes of a matching node
	 */
	PatternFilter filterForBoldElements = new PreferencePatternFilter(false);

	public Font getFont(Object element) {
		return FilteredTree.getElementFont(element, filterTree, filterForBoldElements);
		String filterText = comboTree.getFilterControlText();

		// Do nothing if it's empty string
		if (!(filterText.equals("") || filterText.equals(comboTree.getInitialText()))) {//$NON-NLS-1$

			boolean initial = comboTree.getInitialText() != null
					&& filterText.equals(comboTree.getInitialText());
			if (initial) {
				filterForBoldElements.setPattern(null);
			} else {
				filterForBoldElements.setPattern(filterText);
			}

			ITreeContentProvider contentProvider = (ITreeContentProvider) comboTree.getViewer()
					.getContentProvider();
			Object parent = contentProvider.getParent(element);

			if (filterForBoldElements.select(comboTree.getViewer(), parent, element)) {
				return JFaceResources.getFontRegistry().getBold(JFaceResources.DIALOG_FONT);
			}
		}
		return null;
	}

}

Lines 19-25 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/dialogs/FilteredTree.java (-64 / +117 lines)
19	import org.eclipse.jface.action.ToolBarManager;	19	import org.eclipse.jface.action.ToolBarManager;
20	import org.eclipse.jface.resource.ImageDescriptor;	20	import org.eclipse.jface.resource.ImageDescriptor;
21	import org.eclipse.jface.resource.JFaceResources;	21	import org.eclipse.jface.resource.JFaceResources;
		22	import org.eclipse.jface.viewers.ISelection;
		23	import org.eclipse.jface.viewers.ITreeContentProvider;
22	import org.eclipse.jface.viewers.TreeViewer;	24	import org.eclipse.jface.viewers.TreeViewer;
		25	import org.eclipse.jface.viewers.ViewerFilter;
23	import org.eclipse.osgi.util.NLS;	26	import org.eclipse.osgi.util.NLS;
24	import org.eclipse.swt.SWT;	27	import org.eclipse.swt.SWT;
25	import org.eclipse.swt.accessibility.AccessibleAdapter;	28	import org.eclipse.swt.accessibility.AccessibleAdapter;
Lines 30-43 Link Here
30	import org.eclipse.swt.events.FocusListener;	33	import org.eclipse.swt.events.FocusListener;
31	import org.eclipse.swt.events.KeyAdapter;	34	import org.eclipse.swt.events.KeyAdapter;
32	import org.eclipse.swt.events.KeyEvent;	35	import org.eclipse.swt.events.KeyEvent;
		36	import org.eclipse.swt.events.TraverseEvent;
		37	import org.eclipse.swt.events.TraverseListener;
33	import org.eclipse.swt.graphics.Color;	38	import org.eclipse.swt.graphics.Color;
		39	import org.eclipse.swt.graphics.Font;
34	import org.eclipse.swt.layout.GridData;	40	import org.eclipse.swt.layout.GridData;
35	import org.eclipse.swt.layout.GridLayout;	41	import org.eclipse.swt.layout.GridLayout;
36	import org.eclipse.swt.widgets.Combo;
37	import org.eclipse.swt.widgets.Composite;	42	import org.eclipse.swt.widgets.Composite;
38	import org.eclipse.swt.widgets.Control;	43	import org.eclipse.swt.widgets.Display;
39	import org.eclipse.swt.widgets.Text;	44	import org.eclipse.swt.widgets.Text;
40	import org.eclipse.swt.widgets.ToolBar;	45	import org.eclipse.swt.widgets.ToolBar;
		46	import org.eclipse.swt.widgets.TreeItem;
41	import org.eclipse.ui.PlatformUI;	47	import org.eclipse.ui.PlatformUI;
42	import org.eclipse.ui.internal.WorkbenchMessages;	48	import org.eclipse.ui.internal.WorkbenchMessages;
43	import org.eclipse.ui.plugin.AbstractUIPlugin;	49	import org.eclipse.ui.plugin.AbstractUIPlugin;
Lines 62-68 Link Here
62		68
63	private PatternFilter patternFilter;	69	private PatternFilter patternFilter;
64		70
65	private PreferenceNodeFilter preferenceFilter;	71	private ViewerFilter viewerFilter;
66		72
67	private FocusListener listener;	73	private FocusListener listener;
68		74
Lines 133-156 Link Here
133	\| GridData.GRAB_HORIZONTAL));	139	\| GridData.GRAB_HORIZONTAL));
134		140
135	createFilterControl(filterParent);	141	createFilterControl(filterParent);
136	getFilterControl().addKeyListener(new KeyAdapter() {	142	getFilterControl().addKeyListener(new KeyAdapter() {
137		143	/*
138	/*	144	* (non-Javadoc)
139	* (non-Javadoc)	145	*
140	*	146	* @see org.eclipse.swt.events.KeyAdapter#keyReleased(org.eclipse.swt.events.KeyEvent)
141	* @see org.eclipse.swt.events.KeyAdapter#keyReleased(org.eclipse.swt.events.KeyEvent)	147	*/
142	*/	148	public void keyReleased(KeyEvent e) {
143	public void keyReleased(KeyEvent e) {	149	// on a CR we want to transfer focus to the list
144	// on a CR we want to transfer focus to the list	150	if(e.keyCode == SWT.ARROW_DOWN){
145	if(e.keyCode == SWT.ARROW_DOWN){	151	treeViewer.getTree().setFocus();
146		152	} else if (e.character == SWT.CR)
147	if (!(getFilterControl() instanceof Combo)) {	153	return;
148	treeViewer.getTree().setFocus();	154
149	}	155	textChanged();
150	} else	156	}
151	textChanged();	157	});
152	}	158
153	});	159	// enter key set focus to tree
		160	getFilterControl().addTraverseListener( new TraverseListener () {
		161	public void keyTraversed(TraverseEvent e) {
		162	if (e.detail == SWT.TRAVERSE_RETURN) {
		163	e.doit = false;
		164	if (getViewer().getTree().getItemCount() == 0) {
		165	Display.getCurrent().beep();
		166	setFilterText(""); //$NON-NLS-1$
		167	} else {
		168	boolean hasFocus = getViewer().getTree().setFocus();
		169	if (hasFocus){
		170	TreeItem item = getFirstHighlightedItem(getViewer().getTree().getItems());
		171	if (item != null){
		172	getViewer().getTree().setSelection(new TreeItem[] {item});
		173	ISelection sel = getViewer().getSelection();
		174	getViewer().setSelection(sel, true);
		175	}
		176	}
		177	}
		178	}
		179	}
		180	});
154		181
155	GridData data = new GridData(GridData.FILL_HORIZONTAL	182	GridData data = new GridData(GridData.FILL_HORIZONTAL
156	\| GridData.GRAB_HORIZONTAL);	183	\| GridData.GRAB_HORIZONTAL);
Lines 182-187 Link Here
182	createRefreshJob();	209	createRefreshJob();
183	}	210	}
184		211
		212	private TreeItem getFirstHighlightedItem(TreeItem[] items){
		213	for (int i = 0; i < items.length; i++){
		214	if (patternFilter.isElementMatch(treeViewer, items[i].getData()) && patternFilter.isElementSelectable(items[i].getData())){
		215	return items[i];
		216	}
		217	return getFirstHighlightedItem(items[i].getItems());
		218	}
		219	return null;
		220	}
185	/**	221	/**
186	* Create the refresh job for the receiver.	222	* Create the refresh job for the receiver.
187	*	223	*
Lines 195-206 Link Here
195	if(treeViewer.getControl().isDisposed())	231	if(treeViewer.getControl().isDisposed())
196	return Status.CANCEL_STATUS;	232	return Status.CANCEL_STATUS;
197		233
198	String filterText = getFilterControlText();	234	String filterText = getFilterControl().getText();
199	boolean initial = initialText != null && filterText.equals(initialText);	235	boolean initial = initialText != null && filterText.equals(initialText);
200	if (initial) {	236	if (initial) {
201	patternFilter.setPattern(null);	237	patternFilter.setPattern(null);
202	} else {	238	} else {
203	patternFilter.setPattern(getFilterControlText());	239	patternFilter.setPattern(filterText);
204	}	240	}
205	treeViewer.getControl().setRedraw(false);	241	treeViewer.getControl().setRedraw(false);
206	treeViewer.refresh(true);	242	treeViewer.refresh(true);
Lines 208-220 Link Here
208		244
209	if (filterText.length() > 0 && !initial) {	245	if (filterText.length() > 0 && !initial) {
210	treeViewer.expandAll();	246	treeViewer.expandAll();
		247	TreeItem[] items = getViewer().getTree().getItems();
		248	if (items.length > 0)
		249	treeViewer.getTree().showItem(items[0]); // to prevent scrolling
211	// enabled toolbar is a hint that there is text to clear	250	// enabled toolbar is a hint that there is text to clear
212	// and the list is currently being filtered	251	// and the list is currently being filtered
213	filterToolBar.getControl().setVisible(true);	252	filterToolBar.getControl().setVisible(true);
214	} else {	253	} else {
215	// disabled toolbar is a hint that there is no text to clear	254	// disabled toolbar is a hint that there is no text to clear
216	// and the list is currently not filtered	255	// and the list is currently not filtered
217	filterToolBar.getControl().setVisible(preferenceFilter != null);	256	filterToolBar.getControl().setVisible(viewerFilter != null);
218	}	257	}
219	return Status.OK_STATUS;	258	return Status.OK_STATUS;
220	}	259	}
Lines 228-275 Link Here
228	*/	267	*/
229	protected void createFilterControl(Composite parent) {	268	protected void createFilterControl(Composite parent) {
230	filterText = new Text(parent, SWT.SINGLE \| SWT.BORDER);	269	filterText = new Text(parent, SWT.SINGLE \| SWT.BORDER);
231	filterText.getAccessible().addAccessibleListener(getAccessibleListener());	270	filterText.getAccessible().addAccessibleListener(
232	}	271	new AccessibleAdapter(){
233		272	/* (non-Javadoc)
234	protected AccessibleAdapter getAccessibleListener() {	273	* @see org.eclipse.swt.accessibility.AccessibleListener#getName(org.eclipse.swt.accessibility.AccessibleEvent)
235	return new AccessibleAdapter(){	274	*/
236	/* (non-Javadoc)	275	public void getName(AccessibleEvent e) {
237	* @see org.eclipse.swt.accessibility.AccessibleListener#getName(org.eclipse.swt.accessibility.AccessibleEvent)	276	String filterTextString = getFilterControl().getText();
238	*/	277	if(filterTextString.length() == 0){
239	public void getName(AccessibleEvent e) {	278	e.result = initialText;
240	String filterTextString = getFilterText();	279	}
241	if(filterTextString.length() == 0){	280	else
242	e.result = initialText;	281	e.result = filterTextString;
243	}	282	}
244	else	283	});
245	e.result = filterTextString;
246	}
247
248	};
249	}	284	}
250		285
251	/**	286	/**
252	* Get the text from the filter widget.
253	* @return String
254	*/
255	protected String getFilterText() {
256	return filterText.getText();
257	}
258	/**
259	* update the receiver after the text has changed	287	* update the receiver after the text has changed
260	*/	288	*/
261	protected void textChanged() {	289	protected void textChanged() {
262	refreshJob.schedule(200);	290	refreshJob.schedule(200);
263	}	291	}
264		292
265	/**
266	* Get the text from the filter control.
267	* @return Text
268	*/
269	protected String getFilterControlText() {
270	return filterText.getText();
271	}
272
273	/**	293	/**
274	* Set the background for the widgets that support the filter text area	294	* Set the background for the widgets that support the filter text area
275	*	295	*
Lines 278-284 Link Here
278	public void setBackground(Color background) {	298	public void setBackground(Color background) {
279	super.setBackground(background);	299	super.setBackground(background);
280	filterParent.setBackground(background);	300	filterParent.setBackground(background);
281	getFilterControl().setBackground(background);
282	filterToolBar.getControl().setBackground(background);	301	filterToolBar.getControl().setBackground(background);
283	}	302	}
284		303
Lines 315-323 Link Here
315	protected void clearText() {	334	protected void clearText() {
316	setFilterText(""); //$NON-NLS-1$	335	setFilterText(""); //$NON-NLS-1$
317		336
318	if(preferenceFilter != null){	337	if(viewerFilter != null){
319	getViewer().removeFilter(preferenceFilter);	338	getViewer().removeFilter(viewerFilter);
320	preferenceFilter = null;	339	viewerFilter = null;
321	getShell().setText(cachedTitle);	340	getShell().setText(cachedTitle);
322	}	341	}
323		342
Lines 347-353 Link Here
347	*	366	*
348	* @return the text field	367	* @return the text field
349	*/	368	*/
350	public Control getFilterControl() {	369	public Text getFilterControl() {
351	return filterText;	370	return filterText;
352	}	371	}
353		372
Lines 394-401 Link Here
394	* Add the filter to the viewer.	413	* Add the filter to the viewer.
395	* @param filter	414	* @param filter
396	*/	415	*/
397	public void addFilter(PreferenceNodeFilter filter) {	416	public void addFilter(ViewerFilter filter) {
398	preferenceFilter = filter;	417	viewerFilter = filter;
399	getViewer().addFilter(filter);	418	getViewer().addFilter(filter);
400	setInitialText(WorkbenchMessages.FilteredTree_FilteredMessage);	419	setInitialText(WorkbenchMessages.FilteredTree_FilteredMessage);
401		420
Lines 412-416 Link Here
412		431
413	}	432	}
414		433
		434	/**
		435	* Return bold font if the given element matches the given pattern.
		436	*
		437	* @param element
		438	* @param tree
		439	* @param filter
		440	* @return bold font
		441	*/
		442	protected static Font getElementFont(Object element, FilteredTree tree, PatternFilter filter){
		443	String filterText = tree.getFilterControl().getText();
		444
		445	// Do nothing if it's empty string
		446	String initialText = tree.getInitialText();
		447	if (!(filterText.equals("") \|\| filterText.equals(initialText))) {//$NON-NLS-1$
		448
		449	boolean initial = initialText != null
		450	&& filterText.equals(initialText);
		451	if (initial) {
		452	filter.setPattern(null);
		453	} else {
		454	filter.setPattern(filterText);
		455	}
		456
		457	ITreeContentProvider contentProvider = (ITreeContentProvider) tree.getViewer()
		458	.getContentProvider();
		459	Object parent = contentProvider.getParent(element);
		460
		461	if (filter.select(tree.getViewer(), parent, element)) {
		462	return JFaceResources.getFontRegistry().getBold(JFaceResources.DIALOG_FONT);
		463	}
		464	}
		465	return null;
		466
		467	}
415		468
416	}	469	}




/*******************************************************************************
 * Copyright (c) 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.internal.dialogs;

import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.TraverseEvent;
import org.eclipse.swt.events.TraverseListener;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.internal.WorkbenchPlugin;

/**
 * The FilteredComboTree is a filtered tree that uses an 
 * editable combo rather than just a text.
 */
public class FilteredComboTree extends FilteredTree {

	private Combo filterCombo;
	
	private static final String SEARCHHISTORY = "search"; //$NON-NLS-1$

	//Set a number limitation of items to be saved in combo
	private static final int maxNumItems = 20;
	/**
	 * Create a new instance of the receiver.
	 * @param parent
	 * @param treeStyle
	 */
	public FilteredComboTree(Composite parent, int treeStyle) {
		super(parent, treeStyle);
	}

	/**
	 *  Create a new instance of the receiver with a supplied filter.
	 * @param parent
	 * @param treeStyle
	 * @param filter
	 */
	public FilteredComboTree(Composite parent, int treeStyle, PatternItemFilter filter) {
		super(parent, treeStyle, filter);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.FilteredTree#createFilterControl(org.eclipse.swt.widgets.Composite)
	 */
	protected void createFilterControl(Composite parent) {
		filterCombo = new Combo(parent, SWT.DROP_DOWN | SWT.BORDER);
		filterCombo.setFont(parent.getFont());
		getPreferenceSearchHistory();
		filterCombo.addTraverseListener( new TraverseListener () {
			public void keyTraversed(TraverseEvent e) {
				if (e.detail == SWT.TRAVERSE_RETURN) {
					e.doit = false;
					if (getViewer().getTree().getItemCount() == 0) {
						Display.getCurrent().beep();
						setFilterText(""); //$NON-NLS-1$
					} else {
						getViewer().getTree().setFocus();
					}
				}
			}
		});
		filterCombo.addFocusListener(new FocusAdapter(){
			/* (non-Javadoc)
			 * @see org.eclipse.swt.events.FocusAdapter#focusLost(org.eclipse.swt.events.FocusEvent)
			 */
			public void focusLost(FocusEvent e) {
				String [] textValues = filterCombo.getItems();
				String newText = filterCombo.getText();
				
				if((newText.equals(""))||(newText .equals(initialText)))//$NON-NLS-1$
					return;
			
				for (int i = 0; i < textValues.length; i++) {
					if(textValues[i].equals(newText))
						return;					
				}
					
				if(textValues.length >= maxNumItems)				
					//Discard the oldest search to get space for new search 
					filterCombo.remove(maxNumItems-1);
				
				filterCombo.add(newText,0);
			}
		});
		filterCombo.addSelectionListener(new SelectionAdapter(){
			/* (non-Javadoc)
			 * @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent)
			 */
			public void widgetSelected(SelectionEvent e) {
				textChanged();
			}
		});
		
		filterCombo.addDisposeListener(new DisposeListener() {
		
			/* (non-Javadoc)
			 * @see org.eclipse.swt.events.DisposeListener#widgetDisposed(org.eclipse.swt.events.DisposeEvent)
			 */
			public void widgetDisposed(DisposeEvent e) {
			   	saveDialogSettings();
			}
		});
		
		filterCombo.getAccessible().addAccessibleListener(getAccessibleListener());
		
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.FilteredTree#getFilterControl()
	 */
	public Control getFilterControl() {
		return filterCombo;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.FilteredTree#getFilterControlText()
	 */
	protected String getFilterControlText() {
		return filterCombo.getText();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.FilteredTree#setFilterText(java.lang.String)
	 */
	protected void setFilterText(String string) {
		filterCombo.setText(string);
		selectAll();
	}
	
	protected void selectAll() {
		filterCombo.setSelection(new Point(0,filterCombo.getText().length()));
	}
	
	/**
	 * Get the combo box used by the receiver.
	 * @return Combo
	 */
	public Combo getFilterCombo() {
		return filterCombo;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.FilteredTree#getFilterText()
	 */
	protected String getFilterText() {
		return filterCombo.getText();
	}
		
	/**
     * Return a dialog setting section for this dialog
     */
    private IDialogSettings getDialogSettings() {
        IDialogSettings settings = WorkbenchPlugin.getDefault()
                .getDialogSettings();
        IDialogSettings thisSettings = settings
                .getSection(getClass().getName());
        if (thisSettings == null)
            thisSettings = settings.addNewSection(getClass().getName());
        return thisSettings;
    }
   
	
	/**
	 * Get the preferences search history for this eclipse's start, 
	 * Note that this history will not be cleared until this eclipse closes
	 * 
	 */
	public void getPreferenceSearchHistory(){		
		IDialogSettings settings = getDialogSettings();
		String[] search = settings.getArray(SEARCHHISTORY);
		
		if(search == null)
			return;
		
		for(int i = 0; i < search.length;i++){
			filterCombo.add(search[i]);
		}
				
	}
	
	 /**
     * Saves the search history.
     */
    private void saveDialogSettings() {   
    	IDialogSettings settings =getDialogSettings();
    	
    	//If the settings contains the same key, the previous value will be replaced by new one
    	settings.put(SEARCHHISTORY,filterCombo.getItems());
               
    }
}




package org.eclipse.ui.internal.dialogs;

import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.views.IViewCategory;
import org.eclipse.ui.views.IViewDescriptor;

/**
 * A class that handles filtering view node items based on a supplied
 * matching string.
 *  
 * @since 3.2
 *
 */
public class ViewPatternFilter extends PatternItemFilter {

	/**
	 * Create a new instance of a ViewPatternFilter 
	 * @param isMatchItem
	 */
	public ViewPatternFilter(boolean isMatchItem) {
		super(isMatchItem);
	}
	
	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
	 *      java.lang.Object, java.lang.Object)
	 */
	public boolean select(Viewer viewer, Object parentElement, Object element) {
		ITreeContentProvider contentProvider = (ITreeContentProvider) ((TreeViewer) viewer)
				.getContentProvider();
		
		String text = null;
		Object[] children = null;
		if (element instanceof IViewCategory){
			IViewCategory desc = (IViewCategory) element;
			children = contentProvider.getChildren(desc);
			text = desc.getLabel();
		}
		else if (element instanceof IViewDescriptor){
			IViewDescriptor desc = (IViewDescriptor) element;
			children = contentProvider.getChildren(desc);
			text = desc.getLabel();			
		}	
		
		if(text != null && wordMatches(text))
			return true;
		
		if (matchItem && children != null) {
			// Will return true if any subnode of the element matches the search
			if (filter(viewer, element, children).length > 0)
				return true;
		}	
		
		return false;	
	}
	
	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementSelectable(java.lang.Object)
	 */
	protected boolean isElementSelectable(Object element){
		return element instanceof IViewDescriptor;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementMatch(org.eclipse.jface.viewers.Viewer, java.lang.Object)
	 */
	protected boolean isElementMatch(Viewer viewer, Object element){
		String text = null;
		if (element instanceof IViewCategory){
			IViewCategory desc = (IViewCategory) element;
			text = desc.getLabel();
		}
		else if (element instanceof IViewDescriptor){
			IViewDescriptor desc = (IViewDescriptor) element;
			text = desc.getLabel();			
		}	

		if(text != null && wordMatches(text))
			return true;

		return false;		
	}
}




package org.eclipse.ui.internal.dialogs;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.jface.preference.IPreferenceNode;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.internal.preferences.WorkbenchPreferenceExtensionNode;

/**
 * A class that handles filtering preference node items based on a supplied
 * matching string.
 *  
 * @since 3.2
 *
 */
public class PreferencePatternFilter extends PatternItemFilter {

	/**
	 * this cache is needed because
	 * WorkbenchPreferenceExtensionNode.getKeywordLabels() is expensive. When it
	 * tracks keyword changes effectivly than this cache can be removed.
	 */
	private Map keywordCache = new HashMap();
	
	
	/**
	 * Create a new instance of a PreferencePatternFilter
	 * 
	 * @param isMatchItem
	 */
	public PreferencePatternFilter(boolean isMatchItem) {
		super(isMatchItem);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
	 *      java.lang.Object, java.lang.Object)
	 */
	public boolean select(Viewer viewer, Object parentElement, Object element) {
		ITreeContentProvider contentProvider = (ITreeContentProvider) ((TreeViewer) viewer)
				.getContentProvider();

		IPreferenceNode node = (IPreferenceNode) element;
		Object[] children = contentProvider.getChildren(node);
		String text = node.getLabelText();

		if(wordMatches(text))
			return true;
		
		if (matchItem) {
			// Will return true if any subnode of the element matches the search
			if (filter(viewer, element, children).length > 0)
				return true;
		}
		return keywordMatches(node);
	}
	
	/*
	 * Return true if the given Object matches with any possible keywords
	 * that have been provided.  Currently this is only applicable for 
	 * preference and property pages.
	 */
	private boolean keywordMatches(Object element){
		if (element instanceof WorkbenchPreferenceExtensionNode) {
			WorkbenchPreferenceExtensionNode workbenchNode = (WorkbenchPreferenceExtensionNode) element;

			Collection keywordCollection = (Collection) keywordCache.get(element);
			if (keywordCollection == null) {
				keywordCollection = workbenchNode.getKeywordLabels();
				keywordCache.put(element, keywordCollection);
			}
			if (keywordCollection.isEmpty())
				return false;
			Iterator keywords = keywordCollection.iterator();
			while (keywords.hasNext()) {
				if (wordMatches((String) keywords.next()))
					return true;
			}
		}
		return false;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementSelectable(java.lang.Object)
	 */
	protected boolean isElementSelectable(Object element){
		return element instanceof WorkbenchPreferenceExtensionNode;
	}
	
	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementMatch(org.eclipse.jface.viewers.Viewer, java.lang.Object)
	 */
	protected boolean isElementMatch(Viewer viewer, Object element){
		IPreferenceNode node = (IPreferenceNode) element;
		String text = node.getLabelText();
		
		if(text != null && wordMatches(text))
			return true;
		
		return keywordMatches(node);
	}
}

Return to bug 102081

Lines 18-29 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/dialogs/ShowViewDialog.java (-20 / +69 lines)
18	import org.eclipse.jface.dialogs.IDialogSettings;	18	import org.eclipse.jface.dialogs.IDialogSettings;
19	import org.eclipse.jface.viewers.DoubleClickEvent;	19	import org.eclipse.jface.viewers.DoubleClickEvent;
20	import org.eclipse.jface.viewers.IDoubleClickListener;	20	import org.eclipse.jface.viewers.IDoubleClickListener;
		21	import org.eclipse.jface.viewers.IFontProvider;
21	import org.eclipse.jface.viewers.ISelectionChangedListener;	22	import org.eclipse.jface.viewers.ISelectionChangedListener;
22	import org.eclipse.jface.viewers.IStructuredSelection;	23	import org.eclipse.jface.viewers.IStructuredSelection;
		24	import org.eclipse.jface.viewers.ITreeContentProvider;
23	import org.eclipse.jface.viewers.SelectionChangedEvent;	25	import org.eclipse.jface.viewers.SelectionChangedEvent;
24	import org.eclipse.jface.viewers.StructuredSelection;	26	import org.eclipse.jface.viewers.StructuredSelection;
25	import org.eclipse.jface.viewers.TreeViewer;	27	import org.eclipse.jface.viewers.TreeViewer;
26	import org.eclipse.swt.SWT;	28	import org.eclipse.swt.SWT;
		29	import org.eclipse.swt.graphics.Font;
27	import org.eclipse.swt.layout.GridData;	30	import org.eclipse.swt.layout.GridData;
28	import org.eclipse.swt.widgets.Button;	31	import org.eclipse.swt.widgets.Button;
29	import org.eclipse.swt.widgets.Composite;	32	import org.eclipse.swt.widgets.Composite;
Lines 56-62 Link Here
56	private static final String STORE_SELECTED_VIEW_ID = DIALOG_SETTING_SECTION_NAME	59	private static final String STORE_SELECTED_VIEW_ID = DIALOG_SETTING_SECTION_NAME
57	+ ".STORE_SELECTED_VIEW_ID"; //$NON-NLS-1$	60	+ ".STORE_SELECTED_VIEW_ID"; //$NON-NLS-1$
58		61
59	private TreeViewer tree;	62	private FilteredTree filteredTree;
60		63
61	private Button okButton;	64	private Button okButton;
62		65
Lines 64-69 Link Here
64		67
65	private IViewRegistry viewReg;	68	private IViewRegistry viewReg;
66		69
		70	private class ViewBoldLabelProvider extends ViewLabelProvider implements IFontProvider {
		71	private FilteredTree filterTree;
		72
		73	ViewBoldLabelProvider(FilteredTree filterTree) {
		74	this.filterTree = filterTree;
		75	}
		76	/**
		77	* Using "false" to construct the filter so that this filter can filter
		78	* supernodes of a matching node
		79	*/
		80	PatternItemFilter filterForBoldElements = new ViewPatternFilter(false);
		81
		82	public Font getFont(Object element) {
		83	return FilteredTree.getElementFont(element, filterTree, filterForBoldElements);
		84	}
		85	}
67	/**	86	/**
68	* Constructs a new ShowViewDialog.	87	* Constructs a new ShowViewDialog.
69	*	88	*
Lines 135-143 Link Here
135	Composite composite = (Composite) super.createDialogArea(parent);	154	Composite composite = (Composite) super.createDialogArea(parent);
136	composite.setFont(parent.getFont());	155	composite.setFont(parent.getFont());
137		156
138	createViewer(composite);	157	createFilteredTreeViewer(composite);
139		158
140	layoutTopControl(tree.getControl());	159	layoutTopControl(filteredTree.getViewer().getControl());
141		160
142	// Restore the last state	161	// Restore the last state
143	restoreWidgetValues();	162	restoreWidgetValues();
Lines 147-167 Link Here
147	}	166	}
148		167
149	/**	168	/**
150	* Create a new viewer in the parent.	169	* Create a new filtered tree viewer in the parent.
151	*	170	*
152	* @param parent the parent <code>Composite</code>.	171	* @param parent the parent <code>Composite</code>.
153	*/	172	*/
154	private void createViewer(Composite parent) {	173	private void createFilteredTreeViewer(Composite parent) {
155	tree = new TreeViewer(parent, SWT.MULTI \| SWT.H_SCROLL \| SWT.V_SCROLL	174	PatternItemFilter filter = new ViewPatternFilter(true);
156	\| SWT.BORDER);	175	int styleBits = SWT.MULTI \| SWT.H_SCROLL \| SWT.V_SCROLL \| SWT.BORDER;
157	tree.setLabelProvider(new ViewLabelProvider());	176	filteredTree = new FilteredTree(parent, styleBits, filter);
158	tree.setContentProvider(new ViewContentProvider());	177	TreeViewer treeViewer = filteredTree.getViewer();
159	tree.setSorter(new ViewSorter((ViewRegistry) viewReg));	178	treeViewer.setLabelProvider(new ViewBoldLabelProvider(filteredTree));
160	tree.setInput(viewReg);	179	treeViewer.setContentProvider(new ViewContentProvider());
161	tree.addSelectionChangedListener(this);	180	treeViewer.setSorter(new ViewSorter((ViewRegistry) viewReg));
162	tree.addDoubleClickListener(this);	181	treeViewer.setInput(viewReg);
163	tree.getTree().setFont(parent.getFont());	182	treeViewer.addSelectionChangedListener(this);
164	}	183	treeViewer.addDoubleClickListener(this);
		184	treeViewer.addFilter(new CapabilityFilter());
		185
		186	filteredTree.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
		187	filteredTree.setInitialText(WorkbenchMessages.WorkbenchPreferenceDialog_FilterMessage);
		188
		189	//if the tree has only one or zero views, make the combo area disable
		190	if(hasAtMostOneView(filteredTree.getViewer())){
		191	filteredTree.getFilterControl().setEnabled(false);
		192	}
		193
		194	applyDialogFont(filteredTree);
		195	}
		196
		197	/**
		198	* Return whether or not there are less than two views in the list.
		199	* @param tree
		200	* @return <code>true</code> if there are less than two
		201	* views in the list.
		202	*/
		203	private boolean hasAtMostOneView(TreeViewer tree){
		204	ITreeContentProvider contentProvider = (ITreeContentProvider ) tree.getContentProvider();
		205	Object[] children= contentProvider.getElements(tree.getInput());
		206
		207	if(children.length <= 1){
		208	if(children.length == 0)
		209	return true;
		210	return !contentProvider.hasChildren(children[0]);
		211	}
		212	return false;
		213	}
165		214
166	/*	215	/*
167	* (non-Javadoc)	216	* (non-Javadoc)
Lines 171-178 Link Here
171	public void doubleClick(DoubleClickEvent event) {	220	public void doubleClick(DoubleClickEvent event) {
172	IStructuredSelection s = (IStructuredSelection) event.getSelection();	221	IStructuredSelection s = (IStructuredSelection) event.getSelection();
173	Object element = s.getFirstElement();	222	Object element = s.getFirstElement();
174	if (tree.isExpandable(element)) {	223	if (filteredTree.getViewer().isExpandable(element)) {
175	tree.setExpandedState(element, !tree.getExpandedState(element));	224	filteredTree.getViewer().setExpandedState(element, !filteredTree.getViewer().getExpandedState(element));
176	} else if (viewDescs.length > 0) {	225	} else if (viewDescs.length > 0) {
177	saveWidgetValues();	226	saveWidgetValues();
178	setReturnCode(OK);	227	setReturnCode(OK);
Lines 236-248 Link Here
236	}	285	}
237		286
238	if (!categoriesToExpand.isEmpty())	287	if (!categoriesToExpand.isEmpty())
239	tree.setExpandedElements(categoriesToExpand.toArray());	288	filteredTree.getViewer().setExpandedElements(categoriesToExpand.toArray());
240		289
241	String selectedViewId = settings.get(STORE_SELECTED_VIEW_ID);	290	String selectedViewId = settings.get(STORE_SELECTED_VIEW_ID);
242	if (selectedViewId != null) {	291	if (selectedViewId != null) {
243	IViewDescriptor viewDesc = reg.find(selectedViewId);	292	IViewDescriptor viewDesc = reg.find(selectedViewId);
244	if (viewDesc != null) {	293	if (viewDesc != null) {
245	tree.setSelection(new StructuredSelection(viewDesc), true);	294	filteredTree.getViewer().setSelection(new StructuredSelection(viewDesc), true);
246	}	295	}
247	}	296	}
248	}	297	}
Lines 255-261 Link Here
255	IDialogSettings settings = getDialogSettings();	304	IDialogSettings settings = getDialogSettings();
256		305
257	// Collect the ids of the all expanded categories	306	// Collect the ids of the all expanded categories
258	Object[] expandedElements = tree.getExpandedElements();	307	Object[] expandedElements = filteredTree.getViewer().getExpandedElements();
259	String[] expandedCategoryIds = new String[expandedElements.length];	308	String[] expandedCategoryIds = new String[expandedElements.length];
260	for (int i = 0; i < expandedElements.length; ++i)	309	for (int i = 0; i < expandedElements.length; ++i)
261	expandedCategoryIds[i] = ((IViewCategory) expandedElements[i]).getId();	310	expandedCategoryIds[i] = ((IViewCategory) expandedElements[i]).getId();

Lines 11-43 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/dialogs/PatternItemFilter.java (-67 / +4 lines)
11	package org.eclipse.ui.internal.dialogs;	11	package org.eclipse.ui.internal.dialogs;
12		12
13	import java.text.BreakIterator;	13	import java.text.BreakIterator;
14	import java.util.Collection;
15	import java.util.HashMap;
16	import java.util.Iterator;
17	import java.util.Map;
18
19	import org.eclipse.jface.preference.IPreferenceNode;
20	import org.eclipse.jface.viewers.ITreeContentProvider;
21	import org.eclipse.jface.viewers.TreeViewer;
22	import org.eclipse.jface.viewers.Viewer;
23	import org.eclipse.ui.internal.preferences.WorkbenchPreferenceExtensionNode;
24		14
25	/**	15	/**
26	* A class which handles filtering preferences nodes based on a supplied	16	* Abstract class that handles filtering items based on a supplied
27	* matching string.	17	* matching string.
28	*	18	*
29	* @since 3.1	19	* @since 3.1
30	*	20	*
31	*/	21	*/
32	public class PatternItemFilter extends PatternFilter {	22	public abstract class PatternItemFilter extends PatternFilter {
33
34	/**
35	* this cache is needed because
36	* WorkbenchPreferenceExtensionNode.getKeywordLabels() is expensive. When it
37	* tracks keyword changes effectivly than this cache can be removed.
38	*/
39	private Map keywordCache = new HashMap();
40
41	protected boolean matchItem;	23	protected boolean matchItem;
42		24
43	/**	25	/**
Lines 49-100 Link Here
49	super();	31	super();
50	matchItem = isMatchItem;	32	matchItem = isMatchItem;
51	}	33	}
52		34
53	/*
54	* (non-Javadoc)
55	*
56	* @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
57	* java.lang.Object, java.lang.Object)
58	*/
59	public boolean select(Viewer viewer, Object parentElement, Object element) {
60
61	ITreeContentProvider contentProvider = (ITreeContentProvider) ((TreeViewer) viewer)
62	.getContentProvider();
63
64	IPreferenceNode node = (IPreferenceNode) element;
65	Object[] children = contentProvider.getChildren(node);
66	String text = node.getLabelText();
67
68	if(wordMatches(text))
69	return true;
70
71	if (matchItem) {
72
73	// Will return true if any subnode of the element matches the search
74	if (filter(viewer, element, children).length > 0)
75	return true;
76	}
77
78	if (node instanceof WorkbenchPreferenceExtensionNode) {
79	WorkbenchPreferenceExtensionNode workbenchNode = (WorkbenchPreferenceExtensionNode) node;
80
81	Collection keywordCollection = (Collection) keywordCache.get(node);
82	if (keywordCollection == null) {
83	keywordCollection = workbenchNode.getKeywordLabels();
84	keywordCache.put(node, keywordCollection);
85	}
86	if (keywordCollection.isEmpty())
87	return false;
88	Iterator keywords = keywordCollection.iterator();
89	while (keywords.hasNext()) {
90	if (wordMatches((String) keywords.next()))
91	return true;
92	}
93	}
94	return false;
95
96	}
97
98	/**	35	/**
99	* Return whether or not if any of the words in text satisfy the	36	* Return whether or not if any of the words in text satisfy the
100	* match critera.	37	* match critera.
Lines 102-108 Link Here
102	* @return boolean <code>true</code> if one of the words in text	39	* @return boolean <code>true</code> if one of the words in text
103	* satisifes the match criteria.	40	* satisifes the match criteria.
104	*/	41	*/
105	private boolean wordMatches(String text) {	42	protected boolean wordMatches(String text) {
106		43
107	//If the whole text matches we are all set	44	//If the whole text matches we are all set
108	if(match(text))	45	if(match(text))

Removed Link Here

(-)Eclipse UI/org/eclipse/ui/internal/dialogs/FilteredComboTree.java (-210 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ui.internal.dialogs;
12
13	import org.eclipse.jface.dialogs.IDialogSettings;
14	import org.eclipse.swt.SWT;
15	import org.eclipse.swt.events.DisposeEvent;
16	import org.eclipse.swt.events.DisposeListener;
17	import org.eclipse.swt.events.FocusAdapter;
18	import org.eclipse.swt.events.FocusEvent;
19	import org.eclipse.swt.events.SelectionAdapter;
20	import org.eclipse.swt.events.SelectionEvent;
21	import org.eclipse.swt.events.TraverseEvent;
22	import org.eclipse.swt.events.TraverseListener;
23	import org.eclipse.swt.graphics.Point;
24	import org.eclipse.swt.widgets.Combo;
25	import org.eclipse.swt.widgets.Composite;
26	import org.eclipse.swt.widgets.Control;
27	import org.eclipse.swt.widgets.Display;
28	import org.eclipse.ui.internal.WorkbenchPlugin;
29
30	/**
31	* The FilteredComboTree is a filtered tree that uses an
32	* editable combo rather than just a text.
33	*/
34	public class FilteredComboTree extends FilteredTree {
35
36	private Combo filterCombo;
37
38	private static final String SEARCHHISTORY = "search"; //$NON-NLS-1$
39
40	//Set a number limitation of items to be saved in combo
41	private static final int maxNumItems = 20;
42	/**
43	* Create a new instance of the receiver.
44	* @param parent
45	* @param treeStyle
46	*/
47	public FilteredComboTree(Composite parent, int treeStyle) {
48	super(parent, treeStyle);
49	}
50
51	/**
52	* Create a new instance of the receiver with a supplied filter.
53	* @param parent
54	* @param treeStyle
55	* @param filter
56	*/
57	public FilteredComboTree(Composite parent, int treeStyle, PatternItemFilter filter) {
58	super(parent, treeStyle, filter);
59	}
60
61	/* (non-Javadoc)
62	* @see org.eclipse.ui.internal.dialogs.FilteredTree#createFilterControl(org.eclipse.swt.widgets.Composite)
63	*/
64	protected void createFilterControl(Composite parent) {
65	filterCombo = new Combo(parent, SWT.DROP_DOWN \| SWT.BORDER);
66	filterCombo.setFont(parent.getFont());
67	getPreferenceSearchHistory();
68	filterCombo.addTraverseListener( new TraverseListener () {
69	public void keyTraversed(TraverseEvent e) {
70	if (e.detail == SWT.TRAVERSE_RETURN) {
71	e.doit = false;
72	if (getViewer().getTree().getItemCount() == 0) {
73	Display.getCurrent().beep();
74	setFilterText(""); //$NON-NLS-1$
75	} else {
76	getViewer().getTree().setFocus();
77	}
78	}
79	}
80	});
81	filterCombo.addFocusListener(new FocusAdapter(){
82	/* (non-Javadoc)
83	* @see org.eclipse.swt.events.FocusAdapter#focusLost(org.eclipse.swt.events.FocusEvent)
84	*/
85	public void focusLost(FocusEvent e) {
86	String [] textValues = filterCombo.getItems();
87	String newText = filterCombo.getText();
88
89	if((newText.equals(""))\|\|(newText .equals(initialText)))//$NON-NLS-1$
90	return;
91
92	for (int i = 0; i < textValues.length; i++) {
93	if(textValues[i].equals(newText))
94	return;
95	}
96
97	if(textValues.length >= maxNumItems)
98	//Discard the oldest search to get space for new search
99	filterCombo.remove(maxNumItems-1);
100
101	filterCombo.add(newText,0);
102	}
103	});
104	filterCombo.addSelectionListener(new SelectionAdapter(){
105	/* (non-Javadoc)
106	* @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent)
107	*/
108	public void widgetSelected(SelectionEvent e) {
109	textChanged();
110	}
111	});
112
113	filterCombo.addDisposeListener(new DisposeListener() {
114
115	/* (non-Javadoc)
116	* @see org.eclipse.swt.events.DisposeListener#widgetDisposed(org.eclipse.swt.events.DisposeEvent)
117	*/
118	public void widgetDisposed(DisposeEvent e) {
119	saveDialogSettings();
120	}
121	});
122
123	filterCombo.getAccessible().addAccessibleListener(getAccessibleListener());
124
125	}
126
127	/* (non-Javadoc)
128	* @see org.eclipse.ui.internal.dialogs.FilteredTree#getFilterControl()
129	*/
130	public Control getFilterControl() {
131	return filterCombo;
132	}
133
134	/* (non-Javadoc)
135	* @see org.eclipse.ui.internal.dialogs.FilteredTree#getFilterControlText()
136	*/
137	protected String getFilterControlText() {
138	return filterCombo.getText();
139	}
140
141	/* (non-Javadoc)
142	* @see org.eclipse.ui.internal.dialogs.FilteredTree#setFilterText(java.lang.String)
143	*/
144	protected void setFilterText(String string) {
145	filterCombo.setText(string);
146	selectAll();
147	}
148
149	protected void selectAll() {
150	filterCombo.setSelection(new Point(0,filterCombo.getText().length()));
151	}
152
153	/**
154	* Get the combo box used by the receiver.
155	* @return Combo
156	*/
157	public Combo getFilterCombo() {
158	return filterCombo;
159	}
160
161	/* (non-Javadoc)
162	* @see org.eclipse.ui.internal.dialogs.FilteredTree#getFilterText()
163	*/
164	protected String getFilterText() {
165	return filterCombo.getText();
166	}
167
168	/**
169	* Return a dialog setting section for this dialog
170	*/
171	private IDialogSettings getDialogSettings() {
172	IDialogSettings settings = WorkbenchPlugin.getDefault()
173	.getDialogSettings();
174	IDialogSettings thisSettings = settings
175	.getSection(getClass().getName());
176	if (thisSettings == null)
177	thisSettings = settings.addNewSection(getClass().getName());
178	return thisSettings;
179	}
180
181
182	/**
183	* Get the preferences search history for this eclipse's start,
184	* Note that this history will not be cleared until this eclipse closes
185	*
186	*/
187	public void getPreferenceSearchHistory(){
188	IDialogSettings settings = getDialogSettings();
189	String[] search = settings.getArray(SEARCHHISTORY);
190
191	if(search == null)
192	return;
193
194	for(int i = 0; i < search.length;i++){
195	filterCombo.add(search[i]);
196	}
197
198	}
199
200	/**
201	* Saves the search history.
202	*/
203	private void saveDialogSettings() {
204	IDialogSettings settings =getDialogSettings();
205
206	//If the settings contains the same key, the previous value will be replaced by new one
207	settings.put(SEARCHHISTORY,filterCombo.getItems());
208
209	}
210	}

Added Link Here

(-)Eclipse (+89 lines)
1	package org.eclipse.ui.internal.dialogs;
2
3	import org.eclipse.jface.viewers.ITreeContentProvider;
4	import org.eclipse.jface.viewers.TreeViewer;
5	import org.eclipse.jface.viewers.Viewer;
6	import org.eclipse.ui.views.IViewCategory;
7	import org.eclipse.ui.views.IViewDescriptor;
8
9	/**
10	* A class that handles filtering view node items based on a supplied
11	* matching string.
12	*
13	* @since 3.2
14	*
15	*/
16	public class ViewPatternFilter extends PatternItemFilter {
17
18	/**
19	* Create a new instance of a ViewPatternFilter
20	* @param isMatchItem
21	*/
22	public ViewPatternFilter(boolean isMatchItem) {
23	super(isMatchItem);
24	}
25
26	/*
27	* (non-Javadoc)
28	*
29	* @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
30	* java.lang.Object, java.lang.Object)
31	*/
32	public boolean select(Viewer viewer, Object parentElement, Object element) {
33	ITreeContentProvider contentProvider = (ITreeContentProvider) ((TreeViewer) viewer)
34	.getContentProvider();
35
36	String text = null;
37	Object[] children = null;
38	if (element instanceof IViewCategory){
39	IViewCategory desc = (IViewCategory) element;
40	children = contentProvider.getChildren(desc);
41	text = desc.getLabel();
42	}
43	else if (element instanceof IViewDescriptor){
44	IViewDescriptor desc = (IViewDescriptor) element;
45	children = contentProvider.getChildren(desc);
46	text = desc.getLabel();
47	}
48
49	if(text != null && wordMatches(text))
50	return true;
51
52	if (matchItem && children != null) {
53	// Will return true if any subnode of the element matches the search
54	if (filter(viewer, element, children).length > 0)
55	return true;
56	}
57
58	return false;
59	}
60
61	/*
62	* (non-Javadoc)
63	* @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementSelectable(java.lang.Object)
64	*/
65	protected boolean isElementSelectable(Object element){
66	return element instanceof IViewDescriptor;
67	}
68
69	/*
70	* (non-Javadoc)
71	* @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementMatch(org.eclipse.jface.viewers.Viewer, java.lang.Object)
72	*/
73	protected boolean isElementMatch(Viewer viewer, Object element){
74	String text = null;
75	if (element instanceof IViewCategory){
76	IViewCategory desc = (IViewCategory) element;
77	text = desc.getLabel();
78	}
79	else if (element instanceof IViewDescriptor){
80	IViewDescriptor desc = (IViewDescriptor) element;
81	text = desc.getLabel();
82	}
83
84	if(text != null && wordMatches(text))
85	return true;
86
87	return false;
88	}
89	}

Added Link Here

(-)Eclipse (+111 lines)
1	package org.eclipse.ui.internal.dialogs;
2
3	import java.util.Collection;
4	import java.util.HashMap;
5	import java.util.Iterator;
6	import java.util.Map;
7
8	import org.eclipse.jface.preference.IPreferenceNode;
9	import org.eclipse.jface.viewers.ITreeContentProvider;
10	import org.eclipse.jface.viewers.TreeViewer;
11	import org.eclipse.jface.viewers.Viewer;
12	import org.eclipse.ui.internal.preferences.WorkbenchPreferenceExtensionNode;
13
14	/**
15	* A class that handles filtering preference node items based on a supplied
16	* matching string.
17	*
18	* @since 3.2
19	*
20	*/
21	public class PreferencePatternFilter extends PatternItemFilter {
22
23	/**
24	* this cache is needed because
25	* WorkbenchPreferenceExtensionNode.getKeywordLabels() is expensive. When it
26	* tracks keyword changes effectivly than this cache can be removed.
27	*/
28	private Map keywordCache = new HashMap();
29
30
31	/**
32	* Create a new instance of a PreferencePatternFilter
33	*
34	* @param isMatchItem
35	*/
36	public PreferencePatternFilter(boolean isMatchItem) {
37	super(isMatchItem);
38	}
39
40	/*
41	* (non-Javadoc)
42	*
43	* @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
44	* java.lang.Object, java.lang.Object)
45	*/
46	public boolean select(Viewer viewer, Object parentElement, Object element) {
47	ITreeContentProvider contentProvider = (ITreeContentProvider) ((TreeViewer) viewer)
48	.getContentProvider();
49
50	IPreferenceNode node = (IPreferenceNode) element;
51	Object[] children = contentProvider.getChildren(node);
52	String text = node.getLabelText();
53
54	if(wordMatches(text))
55	return true;
56
57	if (matchItem) {
58	// Will return true if any subnode of the element matches the search
59	if (filter(viewer, element, children).length > 0)
60	return true;
61	}
62	return keywordMatches(node);
63	}
64
65	/*
66	* Return true if the given Object matches with any possible keywords
67	* that have been provided. Currently this is only applicable for
68	* preference and property pages.
69	*/
70	private boolean keywordMatches(Object element){
71	if (element instanceof WorkbenchPreferenceExtensionNode) {
72	WorkbenchPreferenceExtensionNode workbenchNode = (WorkbenchPreferenceExtensionNode) element;
73
74	Collection keywordCollection = (Collection) keywordCache.get(element);
75	if (keywordCollection == null) {
76	keywordCollection = workbenchNode.getKeywordLabels();
77	keywordCache.put(element, keywordCollection);
78	}
79	if (keywordCollection.isEmpty())
80	return false;
81	Iterator keywords = keywordCollection.iterator();
82	while (keywords.hasNext()) {
83	if (wordMatches((String) keywords.next()))
84	return true;
85	}
86	}
87	return false;
88	}
89
90	/*
91	* (non-Javadoc)
92	* @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementSelectable(java.lang.Object)
93	*/
94	protected boolean isElementSelectable(Object element){
95	return element instanceof WorkbenchPreferenceExtensionNode;
96	}
97
98	/*
99	* (non-Javadoc)
100	* @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementMatch(org.eclipse.jface.viewers.Viewer, java.lang.Object)
101	*/
102	protected boolean isElementMatch(Viewer viewer, Object element){
103	IPreferenceNode node = (IPreferenceNode) element;
104	String text = node.getLabelText();
105
106	if(text != null && wordMatches(text))
107	return true;
108
109	return keywordMatches(node);
110	}
111	}