Attachment #28401 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.viewers.IDoubleClickListener;
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;

    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;


        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 ViewLabelProvider());
		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 (text == null)
			return false;
		
		//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);
    }
    
    /**

     * Answers whether the given String matches the pattern.
     * 
     * @param string the String to test
     * 
     * @return whether the string matches the pattern
     */
    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.  This is a default implementation that will 
     * match any entry in the tree based on whether the provided filter 
     * text matches the text of the given element's text.  Subclasses 
     * should override this method.
     * 
     * @param viewer the tree viewer in which the element resides
     * @param element the element in the tree to check for a match
     * 
     * @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;

/**

public class PreferenceBoldLabelProvider extends PreferenceLabelProvider
		implements IFontProvider {

	private FilteredTree filterTree;
	private FilteredComboTree comboTree;

	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.getBoldFont(element, filterTree,
				filterForBoldElements);

		// 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 (-65 / +127 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 keyPressed(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	boolean hasItems = getViewer().getTree().getItemCount() > 0;
145	if(e.keyCode == SWT.ARROW_DOWN){	151	if(hasItems && e.keyCode == SWT.ARROW_DOWN){
146		152	treeViewer.getTree().setFocus();
147	if (!(getFilterControl() instanceof Combo)) {	153	} else if (e.character == SWT.CR){
148	treeViewer.getTree().setFocus();	154	return;
149	}	155	}
150	} else	156	else{
151	textChanged();	157	textChanged();
152	}	158	}
153	});	159	}
		160	});
		161
		162	// enter key set focus to tree
		163	getFilterControl().addTraverseListener( new TraverseListener () {
		164	public void keyTraversed(TraverseEvent e) {
		165	if (e.detail == SWT.TRAVERSE_RETURN) {
		166	e.doit = false;
		167	if (getViewer().getTree().getItemCount() == 0) {
		168	Display.getCurrent().beep();
		169	} else {
		170	boolean hasFocus = getViewer().getTree().setFocus();
		171	if (hasFocus){
		172	TreeItem item = getFirstHighlightedItem(getViewer().getTree().getItems());
		173	if (item != null){
		174	getViewer().getTree().setSelection(new TreeItem[] {item});
		175	ISelection sel = getViewer().getSelection();
		176	getViewer().setSelection(sel, true);
		177	}
		178	}
		179	}
		180	}
		181	}
		182	});
154		183
155	GridData data = new GridData(GridData.FILL_HORIZONTAL	184	GridData data = new GridData(GridData.FILL_HORIZONTAL
156	\| GridData.GRAB_HORIZONTAL);	185	\| GridData.GRAB_HORIZONTAL);
Lines 174-180 Link Here
174	*/	203	*/
175	public void widgetDisposed(DisposeEvent e) {	204	public void widgetDisposed(DisposeEvent e) {
176	refreshJob.cancel();	205	refreshJob.cancel();
177
178	}	206	}
179	});	207	});
180	treeViewer.addFilter(patternFilter);	208	treeViewer.addFilter(patternFilter);
Lines 182-187 Link Here
182	createRefreshJob();	210	createRefreshJob();
183	}	211	}
184		212
		213	private TreeItem getFirstHighlightedItem(TreeItem[] items){
		214	for (int i = 0; i < items.length; i++){
		215	if (patternFilter.isElementMatch(treeViewer, items[i].getData()) && patternFilter.isElementSelectable(items[i].getData())){
		216	return items[i];
		217	}
		218	return getFirstHighlightedItem(items[i].getItems());
		219	}
		220	return null;
		221	}
185	/**	222	/**
186	* Create the refresh job for the receiver.	223	* Create the refresh job for the receiver.
187	*	224	*
Lines 195-206 Link Here
195	if(treeViewer.getControl().isDisposed())	232	if(treeViewer.getControl().isDisposed())
196	return Status.CANCEL_STATUS;	233	return Status.CANCEL_STATUS;
197		234
198	String filterText = getFilterControlText();	235	String filterText = getFilterControl().getText();
199	boolean initial = initialText != null && filterText.equals(initialText);	236	boolean initial = initialText != null && filterText.equals(initialText);
200	if (initial) {	237	if (initial) {
201	patternFilter.setPattern(null);	238	patternFilter.setPattern(null);
202	} else {	239	} else {
203	patternFilter.setPattern(getFilterControlText());	240	patternFilter.setPattern(filterText);
204	}	241	}
205	treeViewer.getControl().setRedraw(false);	242	treeViewer.getControl().setRedraw(false);
206	treeViewer.refresh(true);	243	treeViewer.refresh(true);
Lines 208-220 Link Here
208		245
209	if (filterText.length() > 0 && !initial) {	246	if (filterText.length() > 0 && !initial) {
210	treeViewer.expandAll();	247	treeViewer.expandAll();
		248	TreeItem[] items = getViewer().getTree().getItems();
		249	if (items.length > 0)
		250	treeViewer.getTree().showItem(items[0]); // to prevent scrolling
211	// enabled toolbar is a hint that there is text to clear	251	// enabled toolbar is a hint that there is text to clear
212	// and the list is currently being filtered	252	// and the list is currently being filtered
213	filterToolBar.getControl().setVisible(true);	253	filterToolBar.getControl().setVisible(true);
214	} else {	254	} else {
215	// disabled toolbar is a hint that there is no text to clear	255	// disabled toolbar is a hint that there is no text to clear
216	// and the list is currently not filtered	256	// and the list is currently not filtered
217	filterToolBar.getControl().setVisible(preferenceFilter != null);	257	filterToolBar.getControl().setVisible(viewerFilter != null);
218	}	258	}
219	return Status.OK_STATUS;	259	return Status.OK_STATUS;
220	}	260	}
Lines 228-275 Link Here
228	*/	268	*/
229	protected void createFilterControl(Composite parent) {	269	protected void createFilterControl(Composite parent) {
230	filterText = new Text(parent, SWT.SINGLE \| SWT.BORDER);	270	filterText = new Text(parent, SWT.SINGLE \| SWT.BORDER);
231	filterText.getAccessible().addAccessibleListener(getAccessibleListener());	271	filterText.getAccessible().addAccessibleListener(
232	}	272	new AccessibleAdapter(){
233		273	/* (non-Javadoc)
234	protected AccessibleAdapter getAccessibleListener() {	274	* @see org.eclipse.swt.accessibility.AccessibleListener#getName(org.eclipse.swt.accessibility.AccessibleEvent)
235	return new AccessibleAdapter(){	275	*/
236	/* (non-Javadoc)	276	public void getName(AccessibleEvent e) {
237	* @see org.eclipse.swt.accessibility.AccessibleListener#getName(org.eclipse.swt.accessibility.AccessibleEvent)	277	String filterTextString = getFilterControl().getText();
238	*/	278	if(filterTextString.length() == 0){
239	public void getName(AccessibleEvent e) {	279	e.result = initialText;
240	String filterTextString = getFilterText();	280	}
241	if(filterTextString.length() == 0){	281	else
242	e.result = initialText;	282	e.result = filterTextString;
243	}	283	}
244	else	284	});
245	e.result = filterTextString;
246	}
247
248	};
249	}	285	}
250		286
251	/**	287	/**
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	288	* update the receiver after the text has changed
260	*/	289	*/
261	protected void textChanged() {	290	protected void textChanged() {
262	refreshJob.schedule(200);	291	refreshJob.schedule(200);
263	}	292	}
264		293
265	/**
266	* Get the text from the filter control.
267	* @return Text
268	*/
269	protected String getFilterControlText() {
270	return filterText.getText();
271	}
272
273	/**	294	/**
274	* Set the background for the widgets that support the filter text area	295	* Set the background for the widgets that support the filter text area
275	*	296	*
Lines 278-284 Link Here
278	public void setBackground(Color background) {	299	public void setBackground(Color background) {
279	super.setBackground(background);	300	super.setBackground(background);
280	filterParent.setBackground(background);	301	filterParent.setBackground(background);
281	getFilterControl().setBackground(background);
282	filterToolBar.getControl().setBackground(background);	302	filterToolBar.getControl().setBackground(background);
283	}	303	}
284		304
Lines 315-323 Link Here
315	protected void clearText() {	335	protected void clearText() {
316	setFilterText(""); //$NON-NLS-1$	336	setFilterText(""); //$NON-NLS-1$
317		337
318	if(preferenceFilter != null){	338	if(viewerFilter != null){
319	getViewer().removeFilter(preferenceFilter);	339	getViewer().removeFilter(viewerFilter);
320	preferenceFilter = null;	340	viewerFilter = null;
321	getShell().setText(cachedTitle);	341	getShell().setText(cachedTitle);
322	}	342	}
323		343
Lines 347-353 Link Here
347	*	367	*
348	* @return the text field	368	* @return the text field
349	*/	369	*/
350	public Control getFilterControl() {	370	public Text getFilterControl() {
351	return filterText;	371	return filterText;
352	}	372	}
353		373
Lines 394-401 Link Here
394	* Add the filter to the viewer.	414	* Add the filter to the viewer.
395	* @param filter	415	* @param filter
396	*/	416	*/
397	public void addFilter(PreferenceNodeFilter filter) {	417	public void addFilter(ViewerFilter filter) {
398	preferenceFilter = filter;	418	viewerFilter = filter;
399	getViewer().addFilter(filter);	419	getViewer().addFilter(filter);
400	setInitialText(WorkbenchMessages.FilteredTree_FilteredMessage);	420	setInitialText(WorkbenchMessages.FilteredTree_FilteredMessage);
401		421
Lines 412-416 Link Here
412		432
413	}	433	}
414		434
		435	/**
		436	* Return a bold font if the given element matches the given pattern.
		437	* Clients can opt to call this method from a Viewer's label provider to get
		438	* a bold font for which to highlight the given element in the tree.
		439	*
		440	* @param element
		441	* element for which a match should be determined
		442	* @param tree
		443	* FilteredTree in which the element resides
		444	* @param filter
		445	* PatternFilter which determines a match
		446	*
		447	* @return bold font
		448	*/
		449	protected static Font getBoldFont(Object element, FilteredTree tree,
		450	PatternFilter filter) {
		451	String filterText = tree.getFilterControl().getText();
		452
		453	// Do nothing if it's empty string
		454	String initialText = tree.getInitialText();
		455	if (!(filterText.equals("") \|\| filterText.equals(initialText))) {//$NON-NLS-1$
		456
		457	boolean initial = initialText != null
		458	&& filterText.equals(initialText);
		459	if (initial) {
		460	filter.setPattern(null);
		461	} else {
		462	filter.setPattern(filterText);
		463	}
		464
		465	ITreeContentProvider contentProvider = (ITreeContentProvider) tree
		466	.getViewer().getContentProvider();
		467	Object parent = contentProvider.getParent(element);
		468
		469	if (filter.select(tree.getViewer(), parent, element)) {
		470	return JFaceResources.getFontRegistry().getBold(
		471	JFaceResources.DIALOG_FONT);
		472	}
		473	}
		474	return null;
		475
		476	}
415		477
416	}	478	}




/*******************************************************************************
 * 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 (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 (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 (wordMatches(text))
			return true;

		return keywordMatches(node);
	}
}

Return to bug 102081

Lines 20-25 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/dialogs/ShowViewDialog.java (-20 / +54 lines)
20	import org.eclipse.jface.viewers.IDoubleClickListener;	20	import org.eclipse.jface.viewers.IDoubleClickListener;
21	import org.eclipse.jface.viewers.ISelectionChangedListener;	21	import org.eclipse.jface.viewers.ISelectionChangedListener;
22	import org.eclipse.jface.viewers.IStructuredSelection;	22	import org.eclipse.jface.viewers.IStructuredSelection;
		23	import org.eclipse.jface.viewers.ITreeContentProvider;
23	import org.eclipse.jface.viewers.SelectionChangedEvent;	24	import org.eclipse.jface.viewers.SelectionChangedEvent;
24	import org.eclipse.jface.viewers.StructuredSelection;	25	import org.eclipse.jface.viewers.StructuredSelection;
25	import org.eclipse.jface.viewers.TreeViewer;	26	import org.eclipse.jface.viewers.TreeViewer;
Lines 56-62 Link Here
56	private static final String STORE_SELECTED_VIEW_ID = DIALOG_SETTING_SECTION_NAME	57	private static final String STORE_SELECTED_VIEW_ID = DIALOG_SETTING_SECTION_NAME
57	+ ".STORE_SELECTED_VIEW_ID"; //$NON-NLS-1$	58	+ ".STORE_SELECTED_VIEW_ID"; //$NON-NLS-1$
58		59
59	private TreeViewer tree;	60	private FilteredTree filteredTree;
60		61
61	private Button okButton;	62	private Button okButton;
62		63
Lines 135-143 Link Here
135	Composite composite = (Composite) super.createDialogArea(parent);	136	Composite composite = (Composite) super.createDialogArea(parent);
136	composite.setFont(parent.getFont());	137	composite.setFont(parent.getFont());
137		138
138	createViewer(composite);	139	createFilteredTreeViewer(composite);
139		140
140	layoutTopControl(tree.getControl());	141	layoutTopControl(filteredTree.getViewer().getControl());
141		142
142	// Restore the last state	143	// Restore the last state
143	restoreWidgetValues();	144	restoreWidgetValues();
Lines 147-167 Link Here
147	}	148	}
148		149
149	/**	150	/**
150	* Create a new viewer in the parent.	151	* Create a new filtered tree viewer in the parent.
151	*	152	*
152	* @param parent the parent <code>Composite</code>.	153	* @param parent the parent <code>Composite</code>.
153	*/	154	*/
154	private void createViewer(Composite parent) {	155	private void createFilteredTreeViewer(Composite parent) {
155	tree = new TreeViewer(parent, SWT.MULTI \| SWT.H_SCROLL \| SWT.V_SCROLL	156	PatternItemFilter filter = new ViewPatternFilter(true);
156	\| SWT.BORDER);	157	int styleBits = SWT.MULTI \| SWT.H_SCROLL \| SWT.V_SCROLL \| SWT.BORDER;
157	tree.setLabelProvider(new ViewLabelProvider());	158	filteredTree = new FilteredTree(parent, styleBits, filter);
158	tree.setContentProvider(new ViewContentProvider());	159	TreeViewer treeViewer = filteredTree.getViewer();
159	tree.setSorter(new ViewSorter((ViewRegistry) viewReg));	160	treeViewer.setLabelProvider(new ViewLabelProvider());
160	tree.setInput(viewReg);	161	treeViewer.setContentProvider(new ViewContentProvider());
161	tree.addSelectionChangedListener(this);	162	treeViewer.setSorter(new ViewSorter((ViewRegistry) viewReg));
162	tree.addDoubleClickListener(this);	163	treeViewer.setInput(viewReg);
163	tree.getTree().setFont(parent.getFont());	164	treeViewer.addSelectionChangedListener(this);
164	}	165	treeViewer.addDoubleClickListener(this);
		166	treeViewer.addFilter(new CapabilityFilter());
		167
		168	filteredTree.setBackground(parent.getDisplay().getSystemColor(
		169	SWT.COLOR_WIDGET_BACKGROUND));
		170	filteredTree
		171	.setInitialText(WorkbenchMessages.WorkbenchPreferenceDialog_FilterMessage);
		172
		173	// if the tree has only one or zero views, make the combo area disable
		174	if (hasAtMostOneView(filteredTree.getViewer())) {
		175	filteredTree.getFilterControl().setEnabled(false);
		176	}
		177
		178	applyDialogFont(filteredTree);
		179	}
		180
		181	/**
		182	* Return whether or not there are less than two views in the list.
		183	*
		184	* @param tree
		185	* @return <code>true</code> if there are less than two views in the list.
		186	*/
		187	private boolean hasAtMostOneView(TreeViewer tree) {
		188	ITreeContentProvider contentProvider = (ITreeContentProvider) tree
		189	.getContentProvider();
		190	Object[] children = contentProvider.getElements(tree.getInput());
		191
		192	if (children.length <= 1) {
		193	if (children.length == 0)
		194	return true;
		195	return !contentProvider.hasChildren(children[0]);
		196	}
		197	return false;
		198	}
165		199
166	/*	200	/*
167	* (non-Javadoc)	201	* (non-Javadoc)
Lines 171-178 Link Here
171	public void doubleClick(DoubleClickEvent event) {	205	public void doubleClick(DoubleClickEvent event) {
172	IStructuredSelection s = (IStructuredSelection) event.getSelection();	206	IStructuredSelection s = (IStructuredSelection) event.getSelection();
173	Object element = s.getFirstElement();	207	Object element = s.getFirstElement();
174	if (tree.isExpandable(element)) {	208	if (filteredTree.getViewer().isExpandable(element)) {
175	tree.setExpandedState(element, !tree.getExpandedState(element));	209	filteredTree.getViewer().setExpandedState(element, !filteredTree.getViewer().getExpandedState(element));
176	} else if (viewDescs.length > 0) {	210	} else if (viewDescs.length > 0) {
177	saveWidgetValues();	211	saveWidgetValues();
178	setReturnCode(OK);	212	setReturnCode(OK);
Lines 236-248 Link Here
236	}	270	}
237		271
238	if (!categoriesToExpand.isEmpty())	272	if (!categoriesToExpand.isEmpty())
239	tree.setExpandedElements(categoriesToExpand.toArray());	273	filteredTree.getViewer().setExpandedElements(categoriesToExpand.toArray());
240		274
241	String selectedViewId = settings.get(STORE_SELECTED_VIEW_ID);	275	String selectedViewId = settings.get(STORE_SELECTED_VIEW_ID);
242	if (selectedViewId != null) {	276	if (selectedViewId != null) {
243	IViewDescriptor viewDesc = reg.find(selectedViewId);	277	IViewDescriptor viewDesc = reg.find(selectedViewId);
244	if (viewDesc != null) {	278	if (viewDesc != null) {
245	tree.setSelection(new StructuredSelection(viewDesc), true);	279	filteredTree.getViewer().setSelection(new StructuredSelection(viewDesc), true);
246	}	280	}
247	}	281	}
248	}	282	}
Lines 255-261 Link Here
255	IDialogSettings settings = getDialogSettings();	289	IDialogSettings settings = getDialogSettings();
256		290
257	// Collect the ids of the all expanded categories	291	// Collect the ids of the all expanded categories
258	Object[] expandedElements = tree.getExpandedElements();	292	Object[] expandedElements = filteredTree.getViewer().getExpandedElements();
259	String[] expandedCategoryIds = new String[expandedElements.length];	293	String[] expandedCategoryIds = new String[expandedElements.length];
260	for (int i = 0; i < expandedElements.length; ++i)	294	for (int i = 0; i < expandedElements.length; ++i)
261	expandedCategoryIds[i] = ((IViewCategory) expandedElements[i]).getId();	295	expandedCategoryIds[i] = ((IViewCategory) expandedElements[i]).getId();

Lines 11-43 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/dialogs/PatternItemFilter.java (-67 / +6 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) {
		43	if (text == null)
		44	return false;
106		45
107	//If the whole text matches we are all set	46	//If the whole text matches we are all set
108	if(match(text))	47	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 (+87 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	} else if (element instanceof IViewDescriptor) {
43	IViewDescriptor desc = (IViewDescriptor) element;
44	children = contentProvider.getChildren(desc);
45	text = desc.getLabel();
46	}
47
48	if (wordMatches(text))
49	return true;
50
51	if (matchItem && children != null) {
52	// Will return true if any subnode of the element matches the search
53	if (filter(viewer, element, children).length > 0)
54	return true;
55	}
56
57	return false;
58	}
59
60	/*
61	* (non-Javadoc)
62	* @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementSelectable(java.lang.Object)
63	*/
64	protected boolean isElementSelectable(Object element) {
65	return element instanceof IViewDescriptor;
66	}
67
68	/*
69	* (non-Javadoc)
70	* @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementMatch(org.eclipse.jface.viewers.Viewer, java.lang.Object)
71	*/
72	protected boolean isElementMatch(Viewer viewer, Object element) {
73	String text = null;
74	if (element instanceof IViewCategory) {
75	IViewCategory desc = (IViewCategory) element;
76	text = desc.getLabel();
77	} else if (element instanceof IViewDescriptor) {
78	IViewDescriptor desc = (IViewDescriptor) element;
79	text = desc.getLabel();
80	}
81
82	if (wordMatches(text))
83	return true;
84
85	return false;
86	}
87	}

Added Link Here

(-)Eclipse (+114 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	* Create a new instance of a PreferencePatternFilter
32	*
33	* @param isMatchItem
34	*/
35	public PreferencePatternFilter(boolean isMatchItem) {
36	super(isMatchItem);
37	}
38
39	/*
40	* (non-Javadoc)
41	*
42	* @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
43	* java.lang.Object, java.lang.Object)
44	*/
45	public boolean select(Viewer viewer, Object parentElement, Object element) {
46	ITreeContentProvider contentProvider = (ITreeContentProvider) ((TreeViewer) viewer)
47	.getContentProvider();
48
49	IPreferenceNode node = (IPreferenceNode) element;
50	Object[] children = contentProvider.getChildren(node);
51	String text = node.getLabelText();
52
53	if (wordMatches(text))
54	return true;
55
56	if (matchItem) {
57	// Will return true if any subnode of the element matches the search
58	if (filter(viewer, element, children).length > 0)
59	return true;
60	}
61	return keywordMatches(node);
62	}
63
64	/*
65	* Return true if the given Object matches with any possible keywords that
66	* have been provided. Currently this is only applicable for preference and
67	* property pages.
68	*/
69	private boolean keywordMatches(Object element) {
70	if (element instanceof WorkbenchPreferenceExtensionNode) {
71	WorkbenchPreferenceExtensionNode workbenchNode = (WorkbenchPreferenceExtensionNode) element;
72
73	Collection keywordCollection = (Collection) keywordCache
74	.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	*
93	* @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementSelectable(java.lang.Object)
94	*/
95	protected boolean isElementSelectable(Object element) {
96	return element instanceof WorkbenchPreferenceExtensionNode;
97	}
98
99	/*
100	* (non-Javadoc)
101	*
102	* @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementMatch(org.eclipse.jface.viewers.Viewer,
103	* java.lang.Object)
104	*/
105	protected boolean isElementMatch(Viewer viewer, Object element) {
106	IPreferenceNode node = (IPreferenceNode) element;
107	String text = node.getLabelText();
108
109	if (wordMatches(text))
110	return true;
111
112	return keywordMatches(node);
113	}
114	}